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

CHAP/common/reader.py

@@ -8,7 +8,9 @@ Description: Module for Writers used in multiple experiment-specific
 
 # System modules
 from os.path import (
+    isabs,
     isfile,
+    join,
     splitext,
 )
 from sys import modules
@@ -36,6 +38,35 @@ class BinaryFileReader(Reader):
         return data
 
 
+class FabioImageReader(Reader):
+    """Reader for images using the python package
+    [`fabio`](https://fabio.readthedocs.io/en/main/).
+    """
+    def read(self, filename, frame=None, inputdir='.'):
+        """Return the data from the image file(s) provided.
+
+        :param filename: The image filename, or glob pattern for image
+            filenames, to read.
+        :type filename: str
+        :param frame: The index of a specific frame to read from the
+            file(s), defaults to `None`.
+        :type filename: int, optional
+        :returns: Image data as a numpy array (or list of numpy
+            arrays, if a glob pattern matching more than one file was
+            provided).
+        """
+        from glob import glob
+        import fabio
+
+        filenames = glob(filename)
+        data = []
+        for f in filenames:
+            image = fabio.open(f, frame=frame)
+            data.append(image.data)
+            image.close()
+        return data
+
+
 class H5Reader(Reader):
     """Reader for h5 files.
     """
@@ -97,6 +128,8 @@ class MapReader(Reader):
         # Local modules
         from CHAP.common.models.map import MapConfig
 
+        raise RuntimeError('MapReader is obsolete, use MapProcessor')
+
         if filename is not None:
             if map_config is not None:
                 raise RuntimeError('Specify either filename or map_config '
@@ -130,13 +163,14 @@ class MapReader(Reader):
                         attrs={'spec_file': str(scans.spec_file)})
 
         # Add sample metadata
-        nxentry[map_config.sample.name] = NXsample(**map_config.sample.dict())
+        nxentry[map_config.sample.name] = NXsample(
+            **map_config.sample.dict())
 
         # Set up default data group
         nxentry.data = NXdata()
         if map_config.map_type == 'structured':
             nxentry.data.attrs['axes'] = map_config.dims
-        for i, dim in enumerate(map_config.independent_dimensions[::-1]):
+        for i, dim in enumerate(map_config.independent_dimensions):
             nxentry.data[dim.label] = NXfield(
                 value=map_config.coords[dim.label],
                 units=dim.units,
@@ -214,9 +248,149 @@ class NexusReader(Reader):
         return nxobject
 
 
+class NXdataReader(Reader):
+    """Reader for constructing an NXdata object from components"""
+    def read(self, name, nxfield_params, signal_name, axes_names, attrs={},
+             inputdir='.'):
+        """Return a basic NXdata object constructed from components.
+
+        :param name: The name of the NXdata group.
+        :type name: str
+        :param nxfield_params: List of sets of parameters for
+            `NXfieldReader` specifying the NXfields belonging to the
+            NXdata.
+        :type nxfield_params: list[dict]
+        :param signal_name: Name of the signal for the NXdata (must be
+            one of the names of the NXfields indicated in `nxfields`)
+        :type signal: str
+        :param axes_names: Name or names of the coordinate axes
+            NXfields associated with the signal (must be names of
+            NXfields indicated in `nxfields`)
+        :type axes_names: Union[str, list[str]]
+        :param attrs: Optional dictionary of additional attributes for
+            the NXdata
+        :type attrs: dict
+        :param inputdir: Input directory to use for `NXfieldReader`s,
+            defaults to `"."`
+        :type inputdir: str
+        :returns: A new NXdata object
+        :rtype: nexusformat.nexus.NXdata
+        """
+        from nexusformat.nexus import NXdata
+
+        # Read in NXfields
+        nxfields = [NXfieldReader().read(**params, inputdir=inputdir)
+                    for params in nxfield_params]
+        nxfields = {nxfield.nxname: nxfield for nxfield in nxfields}
+
+        # Get signal NXfield
+        try:
+            nxsignal = nxfields[signal_name]
+        except:
+            raise ValueError(
+                '`signal_name` must be the name of one of the NXfields '
+                + 'indicated in `nxfields`: '
+                + ', '.join(nxfields.keys())
+            )
+
+        # Get axes NXfield(s)
+        if isinstance(axes_names, str):
+            axes_names = [axes_names]
+        try:
+            nxaxes = [nxfields[axis_name] for axis_name in axes_names]
+        except:
+            raise ValueError(
+                '`axes_names` must contain only names of NXfields indicated '
+                + 'in `nxfields`: ' + ', '.join(nxfields.keys())
+            )
+        for i, nxaxis in enumerate(nxaxes):
+            if len(nxaxis) != nxsignal.shape[i]:
+                raise ValueError(
+                    f'Shape mismatch on signal dimension {i}: signal '
+                    + f'"{nxsignal.nxname}" has {nxsignal.shape[i]} values, '
+                    + f'but axis "{nxaxis.nxname}" has {len(nxaxis)} values.')
+
+        result = NXdata(signal=nxsignal, axes=nxaxes, name=name, attrs=attrs,
+                        **nxfields)
+        self.logger.info(result.tree)
+        return result
+
+
+class NXfieldReader(Reader):
+    """Reader for an NXfield with options to modify certain attributes."""
+    def read(self, filename, nxpath, nxname=None, update_attrs=None,
+             slice_params=None, inputdir='.'):
+        """Return a copy of the indicated NXfield from the file. Name
+        and attributes of the returned copy may be modified with the
+        `nxname` and `update_attrs` keyword arguments.
+
+        :param filename: Name of the NeXus file containing the NXfield to read.
+        :type filename: str
+        :param nxpath: Path in `nxfile` pointing to the NXfield to read.
+        :type nxpath: str
+        :param nxname: Optional new name for the returned NXfield,
+            defaults to None
+        :type nxname: str, optional
+        :param update_attrs: Optional dictonary used to add to /
+            update the original NXfield's attributes, defaults to None
+        :type update_attrs: dict, optional
+        :param slice_params: Parameters for returning just a slice of
+            the full field data. Slice parameters are provided in a
+            list dictionaries with integer values for any / all of the
+            following keys: `"start"`, `"end"`, `"step"`. Default
+            values used are: `"start"` - `0`, `"end"` -- `None`,
+            `"step"` -- `1`. The order of the list must correspond to
+            the order of the field's axes. Defaults to `None`.
+        :type slice_params: list[dict[str, int]], optional
+        :param inputdir: Directory containing `nxfile`, defaults to `"."`
+        :type inputdir: str
+        :returns: A copy of the indicated NXfield (with name and
+            attributes optionally modified).
+        :rtype: nexusformat.nexus.NXfield
+        """
+        # Third party modules
+        from nexusformat.nexus import nxload, NXfield
+
+        # Local modules
+        from CHAP.utils.general import nxcopy
+
+        if not isabs(filename):
+            filename = join(inputdir, filename)
+        nxroot = nxload(filename)
+        nxfield = nxroot[nxpath]
+
+        if nxname is None:
+            nxname = nxfield.nxname
+
+        attrs = nxfield.attrs
+        if update_attrs is not None:
+            attrs.update(update_attrs)
+
+        if slice_params is None:
+            value = nxfield.nxdata
+        else:
+            if len(slice_params) < nxfield.ndim:
+                slice_params.extend([{}] * (nxfield.ndim - len(slice_params)))
+            if len(slice_params) > nxfield.ndim:
+                slice_params = slice_params[0:nxfield.ndim]
+            slices = ()
+            default_slice = {'start': 0, 'end': None, 'step': 1}
+            for s in slice_params:
+                for k, v in default_slice.items():
+                    if k not in s:
+                        s[k] = v
+                slices = (*slices, slice(s['start'], s['end'], s['step']))
+            value = nxfield.nxdata[slices]
+
+        nxfield = NXfield(value=value, name=nxname, attrs=attrs)
+        self.logger.debug(f'Result -- nxfield.tree =\n{nxfield.tree}')
+
+        return nxfield
+
+
 class SpecReader(Reader):
     """Reader for CHESS SPEC scans"""
-    def read(self, filename=None, spec_config=None, detector_names=[],
+    def read(self, filename=None, config=None, detector_names=None,
             inputdir=None):
         """Take a SPEC configuration filename or dictionary and return
         the raw data as a Nexus NXentry object.
@@ -225,15 +399,17 @@ class SpecReader(Reader):
             to read from to pass onto the constructor of
             `CHAP.common.models.map.SpecConfig`, defaults to `None`.
         :type filename: str, optional
-        :param spec_config: A SPEC configuration to be passed directly
+        :param config: A SPEC configuration to be passed directly
             to the constructor of `CHAP.common.models.map.SpecConfig`,
             defaults to `None`.
-        :type spec_config: dict, optional
-        :param detector_names: Detector prefixes to include raw data
-            for in the returned NeXus NXentry object, defaults to `[]`.
-        :type detector_names: list[str], optional
+        :type config: dict, optional
+        :param detector_names: Detector names/prefixes to include raw
+            data for in the returned NeXus NXentry object,
+            defaults to `None`.
+        :type detector_names: Union(int, str, list[int], list[str]),
+            optional
         :return: The data from the provided SPEC configuration.
-        :rtype: nexusformat.nexus.NXentry
+        :rtype: nexusformat.nexus.NXroot
         """
         # Third party modules
         from json import dumps
@@ -242,14 +418,15 @@ class SpecReader(Reader):
             NXdata,
             NXentry,
             NXfield,
+            NXroot,
         )
 
         # Local modules
         from CHAP.common.models.map import SpecConfig
 
         if filename is not None:
-            if spec_config is not None:
-                raise RuntimeError('Specify either filename or spec_config '
+            if config is not None:
+                raise RuntimeError('Specify either filename or config '
                                    'in common.SpecReader, not both')
             # Read the map configuration from file
             if not isfile(filename):
@@ -260,22 +437,62 @@ class SpecReader(Reader):
             else:
                 raise RuntimeError('input file has a non-implemented '
                                    f'extension ({filename})')
-            spec_config = reader.read(filename)
-        elif not isinstance(spec_config, dict):
-            raise RuntimeError('Invalid parameter spec_config in '
-                               f'common.SpecReader ({spec_config})')
+            config = reader.read(filename)
+        elif not isinstance(config, dict):
+            raise RuntimeError('Invalid parameter config in '
+                               f'common.SpecReader ({config})')
 
         # Validate the SPEC configuration provided by constructing a
         # SpecConfig
-        spec_config = SpecConfig(**spec_config, inputdir=inputdir)
-
-        # Set up NXentry and add misc. CHESS-specific metadata
-        # as well as all spec_motors, scan_columns, and smb_pars
-        nxentry = NXentry(name=spec_config.experiment_type)
-        nxentry.spec_config = dumps(spec_config.dict())
-        nxentry.attrs['station'] = spec_config.station
+        config = SpecConfig(**config, inputdir=inputdir)
+
+        # Validate the detector names/prefixes
+        if config.experiment_type == 'EDD':
+            if detector_names is not None:
+                if isinstance(detector_names, (int, str)):
+                    detector_names = [str(detector_names)]
+                for i, detector_name in enumerate(detector_names):
+                    if isinstance(detector_name, int):
+                        detector_names[i] = str(detector_name)
+                    elif not isinstance(detector_name, str):
+                        raise ValueError('Invalid "detector_names" parameter '
+                                         f'({detector_names})')
+        else:
+            # Local modules
+            from CHAP.utils.general import is_str_series
+
+            if detector_names is None:
+                raise ValueError(
+                    'Missing "detector_names" parameter')
+            if isinstance(detector_names, str):
+                detector_names = [detector_names]
+            if not is_str_series(detector_names, log=False):
+                raise ValueError(
+                    'Invalid "detector_names" parameter ({detector_names})')
+
+        # Create the NXroot object
+        nxroot = NXroot()
+        nxentry = NXentry(name=config.experiment_type)
+        nxroot[nxentry.nxname] = nxentry
+        nxentry.set_default()
+
+        # Set up NXentry and add misc. CHESS-specific metadata as well
+        # as all spec_motors, scan_columns, and smb_pars, and the
+        # detector info and raw detector data
+        nxentry.config = dumps(config.dict())
+        nxentry.attrs['station'] = config.station
+        if config.experiment_type == 'EDD':
+            if detector_names is None:
+                detector_indices = None
+            else:
+                nxentry.detector_names = detector_names
+                detector_indices = [int(d) for d in detector_names]
+        else:
+            if detector_names is not None:
+                nxentry.detector_names = detector_names
         nxentry.spec_scans = NXcollection()
-        for scans in spec_config.spec_scans:
+#        nxpaths = []
+        for scans in config.spec_scans:
             nxscans = NXcollection()
             nxentry.spec_scans[f'{scans.scanparsers[0].scan_name}'] = nxscans
             nxscans.attrs['spec_file'] = str(scans.spec_file)
@@ -283,25 +500,45 @@ class SpecReader(Reader):
             for scan_number in scans.scan_numbers:
                 scanparser = scans.get_scanparser(scan_number)
                 nxscans[scan_number] = NXcollection()
-                if hasattr(scanparser, 'spec_positioner_values'):
+                try:
                     nxscans[scan_number].spec_motors = dumps(
                         {k:float(v) for k,v
                          in scanparser.spec_positioner_values.items()})
-                if hasattr(scanparser, 'spec_scan_data'):
+                except:
+                    pass
+                try:
                     nxscans[scan_number].scan_columns = dumps(
                         {k:list(v) for k,v
                          in scanparser.spec_scan_data.items() if len(v)})
-                if hasattr(scanparser, 'pars'):
+                except:
+                    pass
+                try:
                     nxscans[scan_number].smb_pars = dumps(
                         {k:v for k,v in scanparser.pars.items()})
-                if detector_names:
+                except:
+                    pass
+                if config.experiment_type == 'EDD':
                     nxdata = NXdata()
                     nxscans[scan_number].data = nxdata
+#                    nxpaths.append(
+#                        f'spec_scans/{nxscans.nxname}/{scan_number}/data')
+                    nxdata.data = NXfield(
+                       value=scanparser.get_detector_data(detector_indices))
+                else:
+                    nxdata = NXdata()
+                    nxscans[scan_number].data = nxdata
+#                    nxpaths.append(
+#                        f'spec_scans/{nxscans.nxname}/{scan_number}/data')
                     for detector_name in detector_names:
                         nxdata[detector_name] = NXfield(
                            value=scanparser.get_detector_data(detector_name))
 
-        return nxentry
+        if config.experiment_type == 'EDD' and detector_names is None:
+            nxentry.detector_names = [
+                str(i) for i in range(nxdata.data.shape[1])]
+
+        #return nxroot, nxpaths
+        return nxroot
 
 
 class URLReader(Reader):

CHAP/common/writer.py

@@ -89,13 +89,15 @@ def write_yaml(data, filename, force_overwrite=False):
 
 def write_filetree(data, outputdir, force_overwrite=False):
     # System modules
-    from os import mkdir
+    from os import makedirs
 
     # Third party modules
     from nexusformat.nexus import (
         NXentry,
+        NXsubentry,
         NXgroup,
         NXobject,
+        NXroot,
         NXsubentry,
     )
 
@@ -103,8 +105,10 @@ def write_filetree(data, outputdir, force_overwrite=False):
         raise TypeError('Cannot write object of type'
                         f'{type(data).__name__} as a file tree to disk.')
 
+    # FIX: Right now this can bomb if MultiplePipelineItem
+    # is called simultaneously from multiple nodes in MPI
     if not os_path.isdir(outputdir):
-        mkdir(outputdir)
+        makedirs(outputdir)
 
     for k, v in data.items():
         if isinstance(v, NXsubentry) and 'schema' in v.attrs:
@@ -114,15 +118,28 @@ def write_filetree(data, outputdir, force_overwrite=False):
                 write_txt(list(v.data), filename, force_overwrite)
             elif schema == 'json':
                 write_txt(str(v.data), filename, force_overwrite)
+            elif schema == 'yml' or schema == 'yaml':
+                from json import loads
+                write_yaml(loads(v.data.nxdata), filename, force_overwrite)
             elif schema == 'tif' or schema == 'tiff':
                 write_tif(v.data, filename, force_overwrite)
             elif schema == 'h5':
-                nxentry = NXentry()
+                if any(isinstance(vv, NXsubentry) for vv in v.values()):
+                    nxbase = NXroot()
+                else:
+                    nxbase = NXentry()
                 for kk, vv in v.attrs.items():
-                    nxentry.attrs[kk] = vv
+                    if kk not in ('schema', 'filename'):
+                        nxbase.attrs[kk] = vv
                 for kk, vv in v.items():
-                    nxentry[kk] = vv
-                write_nexus(nxentry, filename, force_overwrite)
+                    if isinstance(vv, NXsubentry):
+                        nxentry = NXentry()
+                        nxbase[vv.nxname] = nxentry
+                        for kkk, vvv in vv.items():
+                            nxentry[kkk] = vvv
+                    else:
+                        nxbase[kk] = vv
+                write_nexus(nxbase, filename, force_overwrite)
             else:
                 raise TypeError(f'Files of type {schema} not yet implemented')
         elif isinstance(v, NXgroup):
@@ -204,6 +221,44 @@ class FileTreeWriter(Writer):
         return data
 
 
+class H5Writer(Writer):
+    """Writer for H5 files from an `nexusformat.nexus.NXdata` object"""
+    def write(self, data, filename, force_overwrite=False):
+        """Write the NeXus object contained in `data` to hdf5 file.
+
+        :param data: The data to write to file.
+        :type data: CHAP.pipeline.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
+        """
+        # Third party modules
+        from h5py import File
+        from nexusformat.nexus import NXdata
+
+        data = self.unwrap_pipelinedata(data)[-1]
+        if not isinstance(data, NXdata):
+            raise ValueError('Invalid data parameter {(data)}')
+
+        mode = 'w' if force_overwrite else 'w-'
+        with File(filename, mode) as f:
+            f[data.signal] = data.nxsignal
+            for i, axes in enumerate(data.attrs['axes']):
+                f[axes] = data[axes]
+                f[data.signal].dims[i].label = \
+                    f'{axes} ({data[axes].units})' \
+                    if 'units' in data[axes].attrs else axes
+                f[axes].make_scale(axes)
+                f[data.signal].dims[i].attach_scale(f[axes])
+
+        return data
+
+
 class MatplotlibAnimationWriter(Writer):
     """Writer for saving matplotlib animations."""
     def write(self, data, filename, fps=1):
@@ -261,7 +316,7 @@ class MatplotlibFigureWriter(Writer):
 
 class NexusWriter(Writer):
     """Writer for NeXus files from `NXobject`-s"""
-    def write(self, data, filename, force_overwrite=False):
+    def write(self, data, filename, nxpath=None, force_overwrite=False):
         """Write the NeXus object contained in `data` to file.
 
         :param data: The data to write to file.
@@ -275,26 +330,138 @@ class NexusWriter(Writer):
         :return: The data written to file.
         :rtype: nexusformat.nexus.NXobject
         """
+        # System modules
+        import os
+
+        # Third party modules
         from nexusformat.nexus import (
+            NXFile,
             NXentry,
+            NXobject,
             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)
+        if not isinstance(data, NXobject):
+            return data
 
+        nxname = data.nxname
+        if not os.path.isfile(filename) and nxpath is not None:
+            self.logger.warning(
+                f'{filename} does not yet exist. Argument for nxpath '
+                '({nxpath}) will be ignored.')
+            nxpath = None
+        if nxpath is None:
+            nxclass = data.nxclass
+            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)
+        else:
+            nxfile = NXFile(filename, 'rw')
+            root = nxfile.readfile()
+            if nxfile.get(nxpath) is None:
+                nxpath = root.NXentry[0].nxpath
+                self.logger.warning(
+                    f'Path "{nxpath}" not present in {filename}. '
+                    + f'Using {nxpath} instead.')
+            full_nxpath = os.path.join(nxpath, nxname)
+            self.logger.debug(f'Full path for object to write: {full_nxpath}')
+            if nxfile.get(full_nxpath) is not None:
+                self.logger.debug(
+                    f'{os.path.join(nxpath, nxname)} already exists in '
+                    f'{filename}')
+                if force_overwrite:
+                    self.logger.warning(
+                        'Deleting existing NXobject at '
+                        + f'{os.path.join(nxpath, nxname)} in {filename}')
+                    del root[full_nxpath]
+            try:
+                root[full_nxpath] = data
+            except Exception as e:
+                nxfile.close()
+                raise e
+            nxfile.close()
         return data
 
 
+class PyfaiResultsWriter(Writer):
+    """Writer for results of one or more pyFAI integrations. Able to
+    handle multiple output formats. Currently supported formats are:
+    .npz, .nxs.
+    """
+    def write(self, data, filename, force_overwrite=False):
+        """Save pyFAI integration results to a file. Format is
+        determined automatically form the extension of `filename`.
+
+        :param data: Integration results to save.
+        :type data: Union[PipelineData,
+            list[pyFAI.containers.IntegrateResult]]
+        :param filename: Name of the file to which results will be
+            saved. Format of output is determined ffrom the
+            extension. Currently supported formats are: `.npz`,
+            `.nxs`
+        :type filename: str
+        """
+        import os
+
+        from pyFAI.containers import Integrate1dResult, Integrate2dResult
+
+        try:
+            results = self.unwrap_pipelinedata(data)[0]
+        except:
+            results = data
+        if not isinstance(results, list):
+            results = [results]
+        if not all([isinstance(r, Integrate1dResult) for r in results]) \
+           and not all([isinstance(r, Integrate2dResult) for r in results]):
+            raise Exception(
+                'Bad input data: all items must have the same type -- either '
+                + 'all pyFAI.containers.Integrate1dResult, or all '
+                + 'pyFAI.containers.Integrate2dResult.')
+
+        if os.path.isfile(filename):
+            if force_overwrite:
+                self.logger.warning(f'Removing existing file {filename}')
+                os.remove(filename)
+            else:
+                raise Exception(f'{filename} already exists.')
+        _, ext = os.path.splitext(filename)
+        if ext.lower() == '.npz':
+            self.write_npz(results, filename)
+        elif ext.lower() == '.nxs':
+            self.write_nxs(results, filename)
+        else:
+            raise Exception(f'Unsupported file format: {ext}')
+        self.logger.info(f'Wrote to {filename}')
+        return results
+
+    def write_npz(self, results, filename):
+        """Save `results` to the .npz file, `filename`"""
+        import numpy as np
+
+        data = {'radial': results[0].radial,
+                'intensity': [r.intensity for r in results]}
+        if hasattr(results[0], 'azimuthal'):
+            # 2d results
+            data['azimuthal'] = results[0].azimuthal
+        if all([r.sigma for r in results]):
+            # errors were included
+            data['sigma'] = [r.sigma for r in results]
+
+        np.savez(filename, **data)
+
+    def write_nxs(results, filename):
+        """Save `results` to the .nxs file, `filename`"""
+        raise NotImplementedError
+
+
+
 class TXTWriter(Writer):
     """Writer for plain text files from string or tuples or lists of
     strings."""
@@ -345,6 +512,12 @@ class YAMLWriter(Writer):
         :rtype: dict
         """
         data = self.unwrap_pipelinedata(data)[-1]
+        try:
+            from pydantic import BaseModel
+            if isinstance(data, BaseModel):
+                data = data.dict()
+        except:
+            pass
         write_yaml(data, filename, force_overwrite)
         return data
 

CHAP/edd/__init__.py

@@ -1,12 +1,19 @@
 """This subpackage contains `PipelineItems` unique to EDD data
 processing workflows.
 """
-# from CHAP.edd.reader import
+from CHAP.edd.reader import (EddMapReader,
+                             EddMPIMapReader,
+                             ScanToMapReader,
+                             SetupNXdataReader,
+                             UpdateNXdataReader,
+                             NXdataSliceReader)
 from CHAP.edd.processor import (DiffractionVolumeLengthProcessor,
                                 LatticeParameterRefinementProcessor,
-                                MCACeriaCalibrationProcessor,
+                                MCAEnergyCalibrationProcessor,
+                                MCATthCalibrationProcessor,
                                 MCADataProcessor,
                                 MCAEnergyCalibrationProcessor,
+                                MCACalibratedDataPlotter,
                                 StrainAnalysisProcessor)
 # from CHAP.edd.writer import