ChessAnalysisPipeline 0.0.12__py3-none-any.whl → 0.0.14__py3-none-any.whl

CHAP/common/writer.py

@@ -5,11 +5,10 @@ Author     : Valentin Kuznetsov <vkuznet AT gmail dot com>
 Description: Module for Writers used in multiple experiment-specific workflows.
 """
 
-# system modules
-from os import mkdir
+# System modules
 from os import path as os_path
 
-# local modules
+# Local modules
 from CHAP import Writer
 
 def write_matplotlibfigure(data, filename, force_overwrite=False):
@@ -89,6 +88,9 @@ def write_yaml(data, filename, force_overwrite=False):
         yaml.dump(data, f, sort_keys=False)
 
 def write_filetree(data, outputdir, force_overwrite=False):
+    # System modules
+    from os import mkdir
+
     # Third party modules
     from nexusformat.nexus import (
         NXentry,
@@ -130,15 +132,15 @@ def write_filetree(data, outputdir, force_overwrite=False):
 class ExtractArchiveWriter(Writer):
     """Writer for tar files from binary data"""
     def write(self, data, filename):
-        """Take a .tar archive represented as bytes in `data` and
-        write the extracted archive to files.
+        """Take a .tar archive represented as bytes contained in `data`
+        and write the extracted archive to files.
 
-        :param data: the archive data
-        :type data: bytes
-        :param filename: the name of a directory to which the archive
-            files will be written
+        :param data: The data to write to archive.
+        :type data: list[PipelineData]
+        :param filename: The name of the directory to write the archive
+            files to.
         :type filename: str
-        :return: the original `data`
+        :return: The achived data
         :rtype: bytes
         """
         # System modules
@@ -153,86 +155,193 @@ class ExtractArchiveWriter(Writer):
         return data
 
 
+class FileTreeWriter(Writer):
+    """Writer for a file tree in NeXus format"""
+    def write(self, data, outputdir, force_overwrite=False):
+        """Write a NeXus format object contained in `data` to a 
+        directory tree stuctured like the NeXus tree.
+
+        :param data: The data to write to disk.
+        :type data: list[PipelineData]
+        :param outputdir: The name of the directory to write to.
+        :type outputdir: str
+        :param force_overwrite: Flag to allow data to be overwritten
+            if it already exists, defaults to `False`.
+        :type force_overwrite: bool, optional
+        :raises RuntimeError: If `filename` already exists and
+            `force_overwrite` is `False`.
+        :return: The data written to disk.
+        :rtype: Union[nexusformat.nexus.NXroot,
+            nexusformat.nexus.NXentry]
+        """
+        # Third party modules
+        from nexusformat.nexus import (
+            NXentry,
+            NXroot,
+        )
+
+        data = self.unwrap_pipelinedata(data)[-1]
+        if isinstance(data, NXroot):
+            if 'default' in data.attrs:
+                nxentry = data[data.attrs['default']]
+            else:
+                nxentry = [v for v in data.values()
+                           if isinstance(data, NXentry)]
+                if len(nxentry) == 1:
+                    nxentry = nxentry[0]
+                else:
+                    raise TypeError('Cannot write object of type '
+                                    f'{type(data).__name__} as a file tree '
+                                    'to disk.')
+        elif isinstance(data, NXentry):
+            nxentry = data
+        else:
+            raise TypeError('Cannot write object of type '
+                            f'{type(data).__name__} as a file tree to disk.')
+
+        write_filetree(nxentry, outputdir, force_overwrite)
+
+        return data
+
+
+class MatplotlibAnimationWriter(Writer):
+    """Writer for saving matplotlib animations."""
+    def write(self, data, filename, fps=1):
+        """Write the matplotlib.animation.ArtistAnimation object
+        contained in `data` to file.
+
+        :param data: The matplotlib animation.
+        :type data: list[PipelineData]
+        :param filename: The name of the file to write to.
+        :type filename: str
+        :param fps: Movie frame rate (frames per second),
+            defaults to `1`
+        :type fps: int, optional
+        :return: The original animation.
+        :rtype: matplotlib.animation.ArtistAnimation
+        """
+        data = self.unwrap_pipelinedata(data)[-1]
+        extension = os_path.splitext(filename)[1]
+        if not extension:
+            data.save(f'{filename}.gif', fps=fps)
+        elif extension == '.gif':
+            data.save(filename, fps=fps)
+        elif extension == '.mp4':
+            data.save(filename, writer='ffmpeg', fps=fps)
+
+        return data
+
+
 class MatplotlibFigureWriter(Writer):
     """Writer for saving matplotlib figures to image files."""
     def write(self, data, filename, savefig_kw={}, force_overwrite=False):
-        """Write the matplotlib.fgure.Figure contained in `data` to
-        the filename provided.
-
-        :param data: input containing a matplotlib figure
-        :type data: CHAP.pipeline.PipelineData
-        :param filename: name of the file to write to.
-        :param savefig_kw: keyword args to pass to
-            matplotlib.figure.Figure.savefig, defaults to {}
+        """Write the matplotlib.figure.Figure contained in `data` to
+        file.
+
+        :param data: The matplotlib figure
+        :type data: list[PipelineData]
+        :param filename: The name of the file to write to.
+        :type filename: str
+        :param savefig_kw: Keyword args to pass to
+            matplotlib.figure.Figure.savefig, defaults to {}.
         :type savefig_kw: dict, optional
-        :param force_overwrite: flag to allow data in `filename` to be
-            overwritten, if it already exists.
-        :return: the original input data
+        :param force_overwrite: Flag to allow data in `filename` to be
+            overwritten if it already exists, defaults to `False`.
+        :type force_overwrite: bool, optional
+        :raises RuntimeError: If `filename` already exists and
+            `force_overwrite` is `False`.
+        :return: The original figure object
+        :rtype: matplotlib.figure.Figure
         """
         data = self.unwrap_pipelinedata(data)[-1]
         write_matplotlibfigure(data, filename, force_overwrite)
+
         return data
 
 
 class NexusWriter(Writer):
     """Writer for NeXus files from `NXobject`-s"""
     def write(self, data, filename, force_overwrite=False):
-        """Write `data` to a NeXus file
-
-        :param data: the data to write to `filename`.
-        :type data: nexusformat.nexus.NXobject
-        :param filename: name of the file to write to.
-        :param force_overwrite: flag to allow data in `filename` to be
-            overwritten, if it already exists.
-        :return: the original input data
+        """Write the NeXus object contained in `data` to file.
+
+        :param data: The data to write to file.
+        :type data: list[PipelineData]
+        :param filename: The name of the file to write to.
+        :param force_overwrite: Flag to allow data in `filename` to be
+            overwritten if it already exists, defaults to `False`.
+        :type force_overwrite: bool, optional
+        :raises RuntimeError: If `filename` already exists and
+            `force_overwrite` is `False`.
+        :return: The data written to file.
+        :rtype: nexusformat.nexus.NXobject
         """
+        from nexusformat.nexus import (
+            NXentry,
+            NXroot,
+        )
         data = self.unwrap_pipelinedata(data)[-1]
+        nxclass = data.nxclass
+        nxname = data.nxname
+        if nxclass == 'NXentry':
+            data = NXroot(data)
+            data[nxname].set_default()
+        elif nxclass != 'NXroot':
+            data = NXroot(NXentry(data))
+            if nxclass == 'NXdata':
+                data.entry[nxname].set_default()
+            data.entry.set_default()
         write_nexus(data, filename, force_overwrite)
+
         return data
 
 
 class TXTWriter(Writer):
-    """Writer for plain text files from string or list of strings."""
-    def write(self, data, filename, force_overwrite=False, append=False):
-        """If `data` is a `str`, `tuple[str]` or `list[str]`, write it
-        to `filename`.
-
-        :param data: the string or tuple or list of strings to write to
-            `filename`.
-        :type data: str, tuple, list
-        :param filename: name of the file to write to.
+    """Writer for plain text files from string or tuples or lists of
+    strings."""
+    def write(self, data, filename, append=False, force_overwrite=False):
+        """Write a string or tuple or list of strings contained in 
+        `data` to file.
+
+        :param data: The data to write to disk.
+        :type data: str, tuple[str], list[str]
+        :param filename: The name of the file to write to.
         :type filename: str
-        :param force_overwrite: flag to allow data in `filename` to be
-            overwritten if it already exists.
-        :type force_overwrite: bool
-        :raises TypeError: if `data` is not a `str`, `tuple[str]` or
-            `list[str]`
-        :raises RuntimeError: if `filename` already exists and
+        :param append: Flag to allow data in `filename` to be
+            be appended, defaults to `False`.
+        :type append: bool, optional
+        :param force_overwrite: Flag to allow data in `filename` to be
+            overwritten if it already exists, defaults to `False`.
+        :type force_overwrite: bool, optional
+        :raises TypeError: If the object contained in `data` is not a
+            `str`, `tuple[str]` or `list[str]`.
+        :raises RuntimeError: If `filename` already exists and
             `force_overwrite` is `False`.
-        :return: the original input data
-        :rtype: str, tuple, list
+        :return: The data written to file.
+        :rtype: str, tuple[str], list[str]
         """
         data = self.unwrap_pipelinedata(data)[-1]
         write_txt(data, filename, force_overwrite, append)
+
         return data
 
 
 class YAMLWriter(Writer):
     """Writer for YAML files from `dict`-s"""
     def write(self, data, filename, force_overwrite=False):
-        """If `data` is a `dict`, write it to `filename`.
+        """Write the dictionary contained in `data` to file.
 
-        :param data: the dictionary to write to `filename`.
+        :param data: The data to write to file.
         :type data: dict
-        :param filename: name of the file to write to.
+        :param filename: The name of the file to write to.
         :type filename: str
-        :param force_overwrite: flag to allow data in `filename` to be
-            overwritten if it already exists.
-        :type force_overwrite: bool
-        :raises TypeError: if `data` is not a `dict`
-        :raises RuntimeError: if `filename` already exists and
+        :param force_overwrite: Flag to allow data in `filename` to be
+            overwritten if it already exists, defaults to `False`.
+        :type force_overwrite: bool, optional
+        :raises TypeError: If the object contained in `data` is not a
+            `dict`.
+        :raises RuntimeError: If `filename` already exists and
             `force_overwrite` is `False`.
-        :return: the original input data
+        :return: The data written to file.
         :rtype: dict
         """
         data = self.unwrap_pipelinedata(data)[-1]
@@ -240,47 +349,8 @@ class YAMLWriter(Writer):
         return data
 
 
-class FileTreeWriter(Writer):
-    """Writer for a file tree in NeXus format"""
-    def write(self, data, outputdir, force_overwrite=False):
-        """Write `data` to a NeXus file
-
-        :param data: the data to write to disk.
-        :type data: Union[nexusformat.nexus.NXroot,
-            nexusformat.nexus.NXentry]
-        :param force_overwrite: flag to allow data to be overwritten,
-            if it already exists.
-        :return: the original input data
-        """
-        # Third party modules
-        from nexusformat.nexus import (
-            NXentry,
-            NXroot,
-        )
-
-        data = self.unwrap_pipelinedata(data)[-1]
-        if isinstance(data, NXroot):
-            if 'default' in data.attrs:
-                nxentry = data[data.attrs['default']]
-            else:
-                nxentry = [v for v in data.values()
-                           if isinstance(data, NXentry)]
-                if len(nxentry) == 1:
-                    nxentry = nxentry[0]
-                else:
-                    raise TypeError('Cannot write object of type '
-                                    f'{type(data).__name__} as a file tree '
-                                    'to disk.')
-        elif isinstance(data, NXentry):
-            nxentry = data
-        else:
-            raise TypeError('Cannot write object of type '
-                            f'{type(data).__name__} as a file tree to disk.')
-
-        write_filetree(nxentry, outputdir, force_overwrite)
-        return data
-
-
 if __name__ == '__main__':
+    # Local modules
     from CHAP.writer import main
+
     main()

CHAP/edd/__init__.py

@@ -3,8 +3,10 @@ processing workflows.
 """
 # from CHAP.edd.reader import
 from CHAP.edd.processor import (DiffractionVolumeLengthProcessor,
+                                LatticeParameterRefinementProcessor,
                                 MCACeriaCalibrationProcessor,
                                 MCADataProcessor,
+                                MCAEnergyCalibrationProcessor,
                                 StrainAnalysisProcessor)
 # from CHAP.edd.writer import
 

CHAP/edd/models.py

@@ -38,43 +38,70 @@ class MCAElementConfig(BaseModel):
     :type detector_name: str
     :ivar num_bins: Number of MCA channels.
     :type num_bins: int, optional
-    :ivar include_bin_ranges: List of MCA channel index ranges whose
-        data should be included after applying a mask (the bounds are
-        inclusive), defaults to `[]`
-    :type include_bin_ranges: list[[int, int]], optional
+    :ivar include_energy_ranges: List of MCA channel energy ranges
+        whose data should be included after applying a mask (the
+        bounds are inclusive), defaults to `[[50,150]]`
+    :type include_energy_ranges: list[[float, float]], optional
     """
     detector_name: constr(strip_whitespace=True, min_length=1) = 'mca1'
     num_bins: Optional[conint(gt=0)]
-    include_bin_ranges: conlist(
+    max_energy_kev: confloat(gt=0) = 200
+    include_energy_ranges: conlist(
         min_items=1,
         item_type=conlist(
-            item_type=conint(ge=0),
+            item_type=confloat(ge=0),
             min_items=2,
-            max_items=2)) = []
+            max_items=2)) = [[50,150]]
 
-    @validator('include_bin_ranges', each_item=True)
-    def validate_include_bin_range(cls, value, values):
-        """Ensure that no bin ranges are outside the boundary of the
+    @validator('include_energy_ranges', each_item=True)
+    def validate_include_energy_range(cls, value, values):
+        """Ensure that no energy ranges are outside the boundary of the
         detector.
 
-        :param value: Field value to validate (`include_bin_ranges`).
+        :param value: Field value to validate (`include_energy_ranges`).
         :type values: dict
         :param values: Dictionary of previously validated field values.
         :type values: dict
-        :return: The validated value of `include_bin_ranges`.
+        :return: The validated value of `include_energy_ranges`.
         :rtype: dict
         """
-        num_bins = values.get('num_bins')
-        if num_bins is not None:
-            value[1] = min(value[1], num_bins-1)
-        if value[0] >= value[1]:
-            raise ValueError('Invalid bin range in include_bin_ranges '
-                             f'({value})')
+        max_energy_kev = values.get('max_energy_kev')
+        value.sort()
+        if value[1] > max_energy_kev:
+            value[1] = max_energy_kev
         return value
 
+    @property
+    def include_bin_ranges(self):
+        """Return the value of `include_energy_ranges` represented in
+        terms of channel indices instead of channel energies.
+        """
+        from CHAP.utils.general import index_nearest_down, index_nearest_upp
+
+        include_bin_ranges = []
+        energies = np.linspace(0, self.max_energy_kev, self.num_bins)
+        for e_min, e_max in self.include_energy_ranges:
+            include_bin_ranges.append(
+                [index_nearest_down(energies, e_min),
+                 index_nearest_upp(energies, e_max)])
+        return include_bin_ranges
+
+    def get_energy_ranges(self, bin_ranges):
+        """Given a list of channel index ranges, return the
+        correspongin list of channel energy ranges.
+
+        :param bin_ranges: A list of channel bin ranges to convert to
+            energy ranges.
+        :type bin_ranges: list[list[int]]
+        :returns: Energy ranges
+        :rtype: list[list[float]]
+        """
+        energies = np.linspace(0, self.max_energy_kev, self.num_bins)
+        return [[energies[i] for i in range_] for range_ in bin_ranges]
+
     def mca_mask(self):
         """Get a boolean mask array to use on this MCA element's data.
-        Note that the bounds of self.include_bin_ranges are inclusive.
+        Note that the bounds of self.include_energy_ranges are inclusive.
 
         :return: Boolean mask array.
         :rtype: numpy.ndarray
@@ -94,9 +121,9 @@ class MCAElementConfig(BaseModel):
         :rtype: dict
         """
         d = super().dict(*args, **kwargs)
-        d['include_bin_ranges'] = [
-            list(d['include_bin_ranges'][i]) \
-            for i in range(len(d['include_bin_ranges']))]
+        d['include_energy_ranges'] = [
+            [float(energy) for energy in d['include_energy_ranges'][i]]
+            for i in range(len(d['include_energy_ranges']))]
         return d
 
 
@@ -172,7 +199,7 @@ class MCAScanDataConfig(BaseModel):
     def validate_detectors(cls, values):
         """Fill in values for _scanparser / _parfile (if applicable).
         Fill in each detector's num_bins field, if needed.
-        Check each detector's include_bin_ranges field against the
+        Check each detector's include_energy_ranges field against the
         flux file, if available.
 
         :param values: Dictionary of previously validated field values.
@@ -212,20 +239,21 @@ class MCAScanDataConfig(BaseModel):
             )
             flux = np.loadtxt(flux_file)
             flux_file_energies = flux[:,0]/1.e3
-            energy_range = (flux_file_energies.min(), flux_file_energies.max())
+            flux_e_min = flux_file_energies.min()
+            flux_e_max = flux_file_energies.max()
             for detector in detectors:
                 mca_bin_energies = np.linspace( 
                     0, detector.max_energy_kev, detector.num_bins)
-                e_min = index_nearest_upp(mca_bin_energies, energy_range[0])
-                e_max = index_nearest_down(mca_bin_energies, energy_range[1])
-                for i, (min_, max_) in enumerate(
-                        deepcopy(detector.include_bin_ranges)):
-                    if min_ < e_min or max_ > e_max:
-                        bin_range = [max(min_, e_min), min(max_, e_max)]
-                        print(f'WARNING: include_bin_ranges[{i}] out of range '
-                              f'({detector.include_bin_ranges[i]}): adjusted '
-                              f'to {bin_range}')
-                        detector.include_bin_ranges[i] = bin_range
+                for i, (det_e_min, det_e_max) in enumerate(
+                        deepcopy(detector.include_energy_ranges)):
+                    if det_e_min < flux_e_min or det_e_max > flux_e_max:
+                        energy_range = [min(det_e_min, flux_e_min),
+                                        max(det_e_max, flux_e_max)]
+                        print(
+                            f'WARNING: include_energy_ranges[{i}] out of range'
+                            f' ({detector.include_energy_ranges[i]}): adjusted'
+                            f' to {energy_range}')
+                        detector.include_energy_ranges[i] = energy_range
 
         return values
 
@@ -381,6 +409,8 @@ class MCAElementCalibrationConfig(MCAElementConfig):
     :ivar hkl_indices: List of unique HKL indices to fit peaks for in
         the calibration routine, defaults to `[]`.
     :type hkl_indices: list[int], optional
+    :ivar background: Background model for peak fitting.
+    :type background: str, list[str], optional
     :ivar tth_initial_guess: Initial guess for 2&theta,
         defaults to `5.0`.
     :type tth_initial_guess: float, optional
@@ -394,7 +424,7 @@ class MCAElementCalibrationConfig(MCAElementConfig):
     :type tth_calibrated: float, optional
     :ivar slope_calibrated: Calibrated value for detector channel
         energy correction linear slope.
-    :type  slope_calibrated: float, optional
+    :type slope_calibrated: float, optional
     :ivar intercept_calibrated: Calibrated value for detector channel
         energy correction y-intercept.
     :type intercept_calibrated: float, optional
@@ -403,6 +433,7 @@ class MCAElementCalibrationConfig(MCAElementConfig):
     tth_max: confloat(gt=0, allow_inf_nan=False) = 90.0
     hkl_tth_tol: confloat(gt=0, allow_inf_nan=False) = 0.15
     hkl_indices: Optional[conlist(item_type=conint(ge=0), min_items=1)] = []
+    background: Optional[Union[str, list]]
     tth_initial_guess: confloat(gt=0, le=tth_max, allow_inf_nan=False) = 5.0
     slope_initial_guess: float = 1.0
     intercept_initial_guess: float = 0.0
@@ -435,10 +466,19 @@ class MCAElementDiffractionVolumeLengthConfig(MCAElementConfig):
     :ivar dvl_measured: Placeholder for the measured diffraction
         volume length before writing the data to file.
     :type dvl_measured: float, optional
+    :ivar fit_amplitude: Placeholder for amplitude of the gaussian fit.
+    :type fit_amplitude: float, optional
+    :ivar fit_center: Placeholder for center of the gaussian fit.
+    :type fit_center: float, optional
+    :ivar fit_sigma: Placeholder for sigma of the gaussian fit.
+    :type fit_sigma: float, optional
     """
     measurement_mode: Optional[Literal['manual', 'auto']] = 'auto'
     sigma_to_dvl_factor: Optional[Literal[3.5, 2.0, 4.0]] = 3.5
     dvl_measured: Optional[confloat(gt=0)] = None
+    fit_amplitude: Optional[float] = None
+    fit_center: Optional[float] = None
+    fit_sigma: Optional[float] = None
 
     def dict(self, *args, **kwargs):
         """Return a representation of this configuration in a
@@ -452,6 +492,8 @@ class MCAElementDiffractionVolumeLengthConfig(MCAElementConfig):
         d = super().dict(*args, **kwargs)
         if self.measurement_mode == 'manual':
             del d['sigma_to_dvl_factor']
+        for param in ('amplitude', 'center', 'sigma'):
+            d[f'fit_{param}'] = float(d[f'fit_{param}'])
         return d
 
 
@@ -460,10 +502,15 @@ class DiffractionVolumeLengthConfig(MCAScanDataConfig):
     volume length calculation for an EDD setup using a steel-foil
     raster scan.
 
+    :ivar sample_thickness: Thickness of scanned foil sample. Quantity
+        must be provided in the same units as the values of the
+        scanning motor.
+    :type sample_thickness: float
     :ivar detectors: Individual detector element DVL
         measurement configurations
     :type detectors: list[MCAElementDiffractionVolumeLengthConfig]
     """
+    sample_thickness: float
     detectors: conlist(min_items=1,
                        item_type=MCAElementDiffractionVolumeLengthConfig)
 
@@ -481,18 +528,6 @@ class DiffractionVolumeLengthConfig(MCAScanDataConfig):
                 scan_numbers=self._parfile.good_scan_numbers())
         return self.scanparser.spec_scan_motor_vals[0]
 
-    @property
-    def scanned_dim_lbl(self):
-        """Return a label for plot axes corresponding to the scanned
-        dimension.
-
-        :return: Name of scanned motor.
-        :rtype: str
-        """
-        if self._parfile is not None:
-            return self.scan_column
-        return self.scanparser.spec_scan_motor_mnes[0]
-
 
 class CeriaConfig(MaterialConfig):
     """Model for the sample material used in calibrations.
@@ -629,6 +664,8 @@ class MCAElementStrainAnalysisConfig(MCAElementConfig):
     :type hkl_indices: list[int], optional
     :ivar background: Background model for peak fitting.
     :type background: str, list[str], optional
+    :ivar num_proc: Number of processors used for peak fitting.
+    :type num_proc: int, optional
     :ivar peak_models: Peak model for peak fitting,
         defaults to `'gaussian'`.
     :type peak_models: Literal['gaussian', 'lorentzian']],
@@ -656,7 +693,8 @@ class MCAElementStrainAnalysisConfig(MCAElementConfig):
     tth_max: confloat(gt=0, allow_inf_nan=False) = 90.0
     hkl_tth_tol: confloat(gt=0, allow_inf_nan=False) = 0.15
     hkl_indices: Optional[conlist(item_type=conint(ge=0), min_items=1)] = []
-    background: Optional[str]
+    background: Optional[Union[str, list]]
+    num_proc: Optional[conint(gt=0)] = os.cpu_count()
     peak_models: Union[
         conlist(item_type=Literal['gaussian', 'lorentzian'], min_items=1),
         Literal['gaussian', 'lorentzian']] = 'gaussian'
@@ -667,6 +705,13 @@ class MCAElementStrainAnalysisConfig(MCAElementConfig):
     tth_calibrated: Optional[confloat(gt=0, allow_inf_nan=False)]
     slope_calibrated: Optional[confloat(allow_inf_nan=False)]
     intercept_calibrated: Optional[confloat(allow_inf_nan=False)]
+    calibration_bin_ranges: Optional[
+        conlist(
+            min_items=1,
+            item_type=conlist(
+                item_type=conint(ge=0),
+                min_items=2,
+            max_items=2))]
     tth_file: Optional[FilePath]
     tth_map: Optional[np.ndarray] = None
 
@@ -696,6 +741,7 @@ class MCAElementStrainAnalysisConfig(MCAElementConfig):
                       'intercept_calibrated', 'num_bins', 'max_energy_kev']
         for field in add_fields:
             setattr(self, field, getattr(calibration, field))
+        self.calibration_bin_ranges = calibration.include_bin_ranges
 
     def get_tth_map(self, map_config):
         """Return a map of 2&theta values to use -- may vary at each