ChessAnalysisPipeline 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

CHAP/edd/models.py

@@ -1,22 +1,30 @@
-# third party modules
-import numpy as np
+# System modules
 import os
 from pathlib import PosixPath
-from pydantic import (BaseModel,
-                      confloat,
-                      conint,
-                      conlist,
-                      constr,
-                      DirectoryPath,
-                      FilePath,
-                      root_validator,
-                      validator)
+from typing import (
+    Literal,
+    Optional,
+    Union,
+)
+
+# Third party modules
+import numpy as np
+from hexrd.material import Material
+from pydantic import (
+    BaseModel,
+    confloat,
+    conint,
+    conlist,
+    constr,
+    DirectoryPath,
+    FilePath,
+    root_validator,
+    validator,
+)
 from scipy.interpolate import interp1d
-from typing import Literal, Optional, Union
 
-# local modules
+# Local modules
 from CHAP.common.models.map import MapConfig
-from CHAP.utils.material import Material
 from CHAP.utils.parfile import ParFile
 from CHAP.utils.scanparsers import SMBMCAScanParser as ScanParser
 
@@ -25,50 +33,64 @@ class MCAElementConfig(BaseModel):
     """Class representing metadata required to configure a single MCA
     detector element.
 
-    :ivar detector_name: name of the MCA used with the scan
+    :ivar detector_name: Name of the MCA detector element in the scan,
+        defaults to `'mca1'`.
     :type detector_name: str
-    :ivar num_bins: number of channels on the MCA
-    :type num_bins: int
-    :ivar include_bin_ranges: list of MCA channel index ranges whose
-        data should be included after applying a mask
-    :type include_bin_ranges: list[list[int]]
+    :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
     """
     detector_name: constr(strip_whitespace=True, min_length=1) = 'mca1'
     num_bins: Optional[conint(gt=0)]
-    include_bin_ranges: Optional[
-        conlist(
-            min_items=1,
-            item_type=conlist(
-                item_type=conint(ge=0),
-                min_items=2,
-                max_items=2))] = None
+    include_bin_ranges: conlist(
+        min_items=1,
+        item_type=conlist(
+            item_type=conint(ge=0),
+            min_items=2,
+            max_items=2)) = []
 
     @validator('include_bin_ranges', each_item=True)
     def validate_include_bin_range(cls, value, values):
-        """Ensure no bin ranges are outside the boundary of the detector"""
+        """Ensure that no bin ranges are outside the boundary of the
+        detector.
+
+        :param value: Field value to validate (`include_bin_ranges`).
+        :type values: dict
+        :param values: Dictionary of previously validated field values.
+        :type values: dict
+        :return: The validated value of `include_bin_ranges`.
+        :rtype: dict
+        """
         num_bins = values.get('num_bins')
         if num_bins is not None:
-            value[1] = min(value[1], num_bins)
+            value[1] = min(value[1], num_bins-1)
+        if value[0] >= value[1]:
+            raise ValueError('Invalid bin range in include_bin_ranges '
+                             f'({value})')
         return value
 
     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.
 
-        :return: boolean mask array
+        :return: Boolean mask array.
         :rtype: numpy.ndarray
         """
         mask = np.asarray([False] * self.num_bins)
         bin_indices = np.arange(self.num_bins)
         for min_, max_ in self.include_bin_ranges:
-            _mask = np.logical_and(bin_indices > min_, bin_indices < max_)
-            mask = np.logical_or(mask, _mask)
+            mask = np.logical_or(
+                mask, np.logical_and(bin_indices >= min_, bin_indices <= max_))
         return mask
 
     def dict(self, *args, **kwargs):
         """Return a representation of this configuration in a
         dictionary that is suitable for dumping to a YAML file.
 
-        :return: dictionary representation of the configuration.
+        :return: Dictionary representation of the configuration.
         :rtype: dict
         """
         d = super().dict(*args, **kwargs)
@@ -82,22 +104,26 @@ class MCAScanDataConfig(BaseModel):
     """Class representing metadata required to locate raw MCA data for
     a single scan and construct a mask for it.
 
-    :ivar spec_file: Path to the SPEC file containing the scan
-    :ivar scan_number: Number of the scan in `spec_file`
-    :ivar detectors: list of detector element metadata configurations
-
-    :ivar detector_name: name of the MCA used with the scan
-    :ivar num_bins: number of channels on the MCA
-
-    :ivar include_bin_ranges: list of MCA channel index ranges whose
-        data should be included after applying a mask
+    :ivar inputdir: Input directory, used only if any file in the
+            configuration is not an absolute path.
+    :type inputdir: str, optional
+    :ivar spec_file: Path to the SPEC file containing the scan.
+    :type spec_file: str, optional
+    :ivar scan_number: Number of the scan in `spec_file`.
+    :type scan_number: int, optional
+    :ivar par_file: Path to the par file associated with the scan.
+    :type par_file: str, optional
+    :ivar scan_column: Required column name in `par_file`.
+    :type scan_column: str, optional
+    :ivar detectors: List of MCA detector element metadata
+        configurations.
+    :type detectors: list[MCAElementConfig]
     """
     inputdir: Optional[DirectoryPath]
     spec_file: Optional[FilePath]
     scan_number: Optional[conint(gt=0)]
     par_file: Optional[FilePath]
-    scan_column: Optional[Union[conint(ge=0), str]]
-
+    scan_column: Optional[str]
     detectors: conlist(min_items=1, item_type=MCAElementConfig)
 
     _parfile: Optional[ParFile]
@@ -108,35 +134,30 @@ class MCAScanDataConfig(BaseModel):
 
     @root_validator(pre=True)
     def validate_scan(cls, values):
-        """Finalize file paths for spec_file/par_file and flux_file.
+        """Finalize file paths for spec_file and par_file.
 
-        :param values: dictionary of field values to validate
+        :param values: Dictionary of class field values.
         :type values: dict
-        :return: the validated form of `values`
+        :raises ValueError: Invalid SPEC or par file.
+        :return: The validated list of `values`.
         :rtype: dict
         """
         inputdir = values.get('inputdir')
         spec_file = values.get('spec_file')
         par_file = values.get('par_file')
-        flux_file = values.get('flux_file')
-        if flux_file:
-            if not os.path.isabs(flux_file):
-                values['flux_file'] = os.path.join(inputdir, flux_file)
-        if spec_file and par_file:
+        if spec_file is not None and par_file is not None:
             raise ValueError('Use either spec_file or par_file, not both')
-        elif spec_file:
-            if inputdir is not None:
-                if not os.path.isabs(spec_file):
-                    values['spec_file'] = os.path.join(inputdir, spec_file)
-        elif par_file:
-            if inputdir is not None:
-                if not os.path.isabs(par_file):
-                    values['par_file'] = os.path.join(inputdir, par_file)
+        elif spec_file is not None:
+            if inputdir is not None and not os.path.isabs(spec_file):
+                values['spec_file'] = os.path.join(inputdir, spec_file)
+        elif par_file is not None:
+            if inputdir is not None and not os.path.isabs(par_file):
+                values['par_file'] = os.path.join(inputdir, par_file)
             if 'scan_column' not in values:
                 raise ValueError(
-                    'When par_file is used, scan_column must be used, too')
+                    'scan_column is required when par_file is used')
             if isinstance(values['scan_column'], str):
-                parfile = ParFile(values.get('par_file'))
+                parfile = ParFile(par_file)
                 if values['scan_column'] not in parfile.column_names:
                     raise ValueError(
                         f'No column named {values["scan_column"]} in '
@@ -149,31 +170,68 @@ class MCAScanDataConfig(BaseModel):
 
     @root_validator
     def validate_detectors(cls, values):
-        """Fill in values for _scanparser / _parfile (if
-        applicable). Fill in values for each detector's num_bins
-        field, if needed.
+        """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
+        flux file, if available.
+
+        :param values: Dictionary of previously validated field values.
+        :type values: dict
+        :raises ValueError: Unable to obtain a value for num_bins.
+        :return: The validated list of `values`.
+        :rtype: dict
         """
-        if values.get('spec_file', False):
-            values['_scanparser'] = ScanParser(values.get('spec_file'),
-                                               values.get('scan_number'))
+        spec_file = values.get('spec_file')
+        par_file = values.get('par_file')
+        detectors = values.get('detectors')
+        flux_file = values.get('flux_file')
+        if spec_file is not None:
+            values['_scanparser'] = ScanParser(
+                spec_file, values.get('scan_number'))
             values['_parfile'] = None
-        elif values.get('par_file', False):
-            values['_parfile'] = ParFile(values.get('par_file'))
+        elif par_file is not None:
+            values['_parfile'] = ParFile(par_file)
             values['_scanparser'] = ScanParser(
                 values['_parfile'].spec_file,
                 values['_parfile'].good_scan_numbers()[0])
-        for detector in values.get('detectors'):
+        for detector in detectors:
             if detector.num_bins is None:
                 try:
                     detector.num_bins = values['_scanparser']\
                         .get_detector_num_bins(detector.detector_name)
-                except Exception as exc:
-                    raise ValueError('No value found for num_bins') from exc
+                except Exception as e:
+                    raise ValueError('No value found for num_bins') from e
+        if flux_file is not None:
+            # System modules
+            from copy import deepcopy
+
+            # Local modules
+            from CHAP.utils.general import (
+                index_nearest_down,
+                index_nearest_upp,
+            )
+            flux = np.loadtxt(flux_file)
+            flux_file_energies = flux[:,0]/1.e3
+            energy_range = (flux_file_energies.min(), 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
 
         return values
 
     @property
     def scanparser(self):
+        """Return the scanparser."""
         try:
             scanparser = self._scanparser
         except:
@@ -184,15 +242,18 @@ class MCAScanDataConfig(BaseModel):
     def mca_data(self, detector_config, scan_step_index=None):
         """Get the array of MCA data collected by the scan.
 
-        :param detector_config: detector for which data will be returned
+        :param detector_config: Detector for which data is returned.
         :type detector_config: MCAElementConfig
-        :return: MCA data
+        :param scan_step_index: Only return the MCA spectrum for the
+            given scan step index, defaults to `None`, which returns
+            all the available MCA spectra.
+        :type scan_step_index: int, optional
+        :return: The current detectors's MCA data.
         :rtype: np.ndarray
         """
         detector_name = detector_config.detector_name
         if self._parfile is not None:
             if scan_step_index is None:
-                import numpy as np
                 data = np.asarray(
                     [ScanParser(self._parfile.spec_file, scan_number)\
                      .get_all_detector_data(detector_name)[0] \
@@ -215,7 +276,7 @@ class MCAScanDataConfig(BaseModel):
         """Return a representation of this configuration in a
         dictionary that is suitable for dumping to a YAML file.
 
-        :return: dictionary representation of the configuration.
+        :return: Dictionary representation of the configuration.
         :rtype: dict
         """
         d = super().dict(*args, **kwargs)
@@ -235,14 +296,14 @@ class MCAScanDataConfig(BaseModel):
 
 
 class MaterialConfig(BaseModel):
-    """Model for parameters to characterize a sample material
-
-    :ivar hexrd_h5_material_file: path to a HEXRD materials.h5 file containing
-        an entry for the material properties.
-    :ivar hexrd_h5_material_name: Name of the material entry in
-        `hexrd_h5_material_file`.
-    :ivar lattice_parameter_angstrom: lattice spacing in angstrom to use for
-        a cubic crystal.
+    """Model for parameters to characterize a sample material.
+
+    :ivar material_name: Sample material name.
+    :type material_name: str, optional
+    :ivar lattice_parameters: Lattice spacing(s) in angstroms.
+    :type lattice_parameters: float, list[float], optional
+    :ivar sgnum: Space group of the material.
+    :type sgnum: int, optional
     """
     material_name: Optional[constr(strip_whitespace=True, min_length=1)]
     lattice_parameters: Optional[Union[
@@ -257,32 +318,43 @@ class MaterialConfig(BaseModel):
 
     @root_validator
     def validate_material(cls, values):
+        """Create and validate the private attribute _material.
+
+        :param values: Dictionary of previously validated field values.
+        :type values: dict
+        :return: The validated list of `values`.
+        :rtype: dict
+        """
+        # Local modules
         from CHAP.edd.utils import make_material
+
         values['_material'] = make_material(values.get('material_name'),
                                             values.get('sgnum'),
                                             values.get('lattice_parameters'))
         return values
 
-    def unique_ds(self, tth_tol=0.15, tth_max=90.0):
-        """Get a list of unique HKLs and their lattice spacings
+    def unique_hkls_ds(self, tth_tol=0.15, tth_max=90.0):
+        """Get a list of unique HKLs and their lattice spacings.
 
-        :param tth_tol: minimum resolvable difference in 2&theta
+        :param tth_tol: Minimum resolvable difference in 2&theta
             between two unique HKL peaks, defaults to `0.15`.
         :type tth_tol: float, optional
-        :param tth_max: detector rotation about hutch x axis, defaults
-            to `90.0`.
+        :param tth_max: Detector rotation about hutch x axis,
+            defaults to `90.0`.
         :type tth_max: float, optional
-        :return: unique HKLs and their lattice spacings in angstroms
+        :return: Unique HKLs and their lattice spacings in angstroms.
         :rtype: np.ndarray, np.ndarray
         """
+        # Local modules
         from CHAP.edd.utils import get_unique_hkls_ds
+
         return get_unique_hkls_ds([self._material])
 
     def dict(self, *args, **kwargs):
         """Return a representation of this configuration in a
         dictionary that is suitable for dumping to a YAML file.
 
-        :return: dictionary representation of the configuration.
+        :return: Dictionary representation of the configuration.
         :rtype: dict
         """
         d = super().dict(*args, **kwargs)
@@ -295,79 +367,87 @@ class MaterialConfig(BaseModel):
 
 
 class MCAElementCalibrationConfig(MCAElementConfig):
-    """Class representing metadata & parameters required for
-    calibrating a single MCA detector element.
-
-    :ivar max_energy_kev: maximum channel energy of the MCA in keV
-    :ivar tth_max: detector rotation about hutch x axis, defaults to `90`.
-    :ivar hkl_tth_tol: minimum resolvable difference in 2&theta between two
-        unique HKL peaks, defaults to `0.15`.
-    :ivar fit_hkls: list of unique HKL indices to fit peaks for in the
-        calibration routine
-    :ivar tth_initial_guess: initial guess for 2&theta
-    :ivar slope_initial_guess: initial guess for detector channel energy
-        correction linear slope, defaults to `1.0`.
-    :ivar intercept_initial_guess: initial guess for detector channel energy
-        correction y-intercept, defaults to `0.0`.
-    :ivar tth_calibrated: calibrated value for 2&theta, defaults to None
-    :ivar slope_calibrated: calibrated value for detector channel energy
-        correction linear slope, defaults to `None`
-    :ivar intercept_calibrated: calibrated value for detector channel energy
-        correction y-intercept, defaluts to None
+    """Class representing metadata required to calibrate a single MCA
+    detector element.
+
+    :ivar max_energy_kev: Maximum channel energy of the MCA in keV.
+    :type max_energy_kev: float
+    :ivar tth_max: Detector rotation about lab frame x axis,
+       defaults to `90`.
+    :type tth_max: float, optional
+    :ivar hkl_tth_tol: Minimum resolvable difference in 2&theta between
+        two unique HKL peaks, defaults to `0.15`.
+    :type hkl_tth_tol: float, optional
+    :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 tth_initial_guess: Initial guess for 2&theta,
+        defaults to `5.0`.
+    :type tth_initial_guess: float, optional
+    :ivar slope_initial_guess: Initial guess for the detector channel
+        energy correction linear slope, defaults to `1.0`.
+    :type slope_initial_guess: float, optional
+    :ivar intercept_initial_guess: Initial guess for detector channel
+        energy correction y-intercept, defaults to `0.0`.
+    :type intercept_initial_guess: float, optional
+    :ivar tth_calibrated: Calibrated value for 2&theta.
+    :type tth_calibrated: float, optional
+    :ivar slope_calibrated: Calibrated value for detector channel
+        energy correction linear slope.
+    :type  slope_calibrated: float, optional
+    :ivar intercept_calibrated: Calibrated value for detector channel
+        energy correction y-intercept.
+    :type intercept_calibrated: float, optional
     """
     max_energy_kev: confloat(gt=0)
     tth_max: confloat(gt=0, allow_inf_nan=False) = 90.0
     hkl_tth_tol: confloat(gt=0, allow_inf_nan=False) = 0.15
-    fit_hkls: Optional[conlist(item_type=conint(ge=0), min_items=1)] = None
-    tth_initial_guess: confloat(gt=0, le=tth_max, allow_inf_nan=False)
+    hkl_indices: Optional[conlist(item_type=conint(ge=0), min_items=1)] = []
+    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
     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)]
 
-    def fit_ds(self, materials):
-        """Get a list of HKLs and their lattice spacings that will be
-        fit in the calibration routine
-
-        :return: HKLs to fit and their lattice spacings in angstroms
-        :rtype: np.ndarray, np.ndarray
-        """
-        if not isinstance(materials, list):
-            materials = [materials]
-        from CHAP.edd.utils import get_unique_hkls_ds
-        unique_hkls, unique_ds = get_unique_hkls_ds(materials)
-
-        fit_hkls = np.array([unique_hkls[i] for i in self.fit_hkls])
-        fit_ds = np.array([unique_ds[i] for i in self.fit_hkls])
-
-        return fit_hkls, fit_ds
+    @validator('hkl_indices', pre=True)
+    def validate_hkl_indices(cls, hkl_indices):
+        if isinstance(hkl_indices, str):
+            # Local modules
+            from CHAP.utils.general import string_to_list
 
+            hkl_indices = string_to_list(hkl_indices)
+        return sorted(hkl_indices)
 
 class MCAElementDiffractionVolumeLengthConfig(MCAElementConfig):
-    """Class representing input parameters required to perform a
-    diffraction volume length measurement for a single MCA detector
-    element.
+    """Class representing metadata required to perform a diffraction
+    volume length measurement for a single MCA detector element.
 
-    :ivar measurement_mode: placeholder for recording whether the
+    :ivar measurement_mode: Placeholder for recording whether the
         measured DVL value was obtained through the automated
-        calculation or a manual selection.
-    :type measurement_mode: Literal['manual', 'auto']
-    :ivar sigma_to_dvl_factor: to measure the DVL, a gaussian is fit
-        to a reduced from of the raster scan MCA data. This variable
-        is a scalar that converts the standard deviation of the
-        gaussian fit to the measured DVL.
-    :type sigma_to_dvl_factor: Optional[Literal[1.75, 1., 2.]]
-    :ivar dvl_measured: placeholder for the measured diffraction
-        volume length before writing data to file.
+        calculation or a manual selection, defaults to `'auto'`.
+    :type measurement_mode: Literal['manual', 'auto'], optional
+    :ivar sigma_to_dvl_factor: The DVL is obtained by fitting a reduced
+        form of the MCA detector data. `sigma_to_dvl_factor` is a
+        scalar value that converts the standard deviation of the
+        gaussian fit to the measured DVL, defaults to `3.5`.
+    :type sigma_to_dvl_factor: Literal[3.5, 2.0, 4.0], optional
+    :ivar dvl_measured: Placeholder for the measured diffraction
+        volume length before writing the data to file.
+    :type dvl_measured: float, optional
     """
     measurement_mode: Optional[Literal['manual', 'auto']] = 'auto'
-    sigma_to_dvl_factor: Optional[Literal[3.5, 2., 4.]] = 3.5
+    sigma_to_dvl_factor: Optional[Literal[3.5, 2.0, 4.0]] = 3.5
     dvl_measured: Optional[confloat(gt=0)] = None
 
     def dict(self, *args, **kwargs):
-        """If measurement_mode is 'manual', exclude
-        sigma_to_dvl_factor from the dict representation.
+        """Return a representation of this configuration in a
+        dictionary that is suitable for dumping to a YAML file.
+        Exclude `sigma_to_dvl_factor` from the dict representation if
+        `measurement_mode` is `'manual'`.
+
+        :return: Dictionary representation of the configuration.
+        :rtype: dict
         """
         d = super().dict(*args, **kwargs)
         if self.measurement_mode == 'manual':
@@ -380,7 +460,7 @@ class DiffractionVolumeLengthConfig(MCAScanDataConfig):
     volume length calculation for an EDD setup using a steel-foil
     raster scan.
 
-    :ivar detectors: list of individual detector elmeent DVL
+    :ivar detectors: Individual detector element DVL
         measurement configurations
     :type detectors: list[MCAElementDiffractionVolumeLengthConfig]
     """
@@ -392,7 +472,7 @@ class DiffractionVolumeLengthConfig(MCAScanDataConfig):
         """Return the list of values visited by the scanning motor
         over the course of the raster scan.
 
-        :return: list of scanned motor values
+        :return: List of scanned motor values
         :rtype: np.ndarray
         """
         if self._parfile is not None:
@@ -404,69 +484,103 @@ class DiffractionVolumeLengthConfig(MCAScanDataConfig):
     @property
     def scanned_dim_lbl(self):
         """Return a label for plot axes corresponding to the scanned
-        dimension
+        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 a Material representing CeO2 used in calibrations.
 
-    :ivar hexrd_h5_material_name: Name of the material entry in
-        `hexrd_h5_material_file`, defaults to `'CeO2'`.
-    :ivar lattice_parameter_angstrom: lattice spacing in angstrom to use for
-        the cubic CeO2 crystal, defaults to `5.41153`.
+class CeriaConfig(MaterialConfig):
+    """Model for the sample material used in calibrations.
+
+    :ivar material_name: Calibration material name,
+        defaults to `'CeO2'`.
+    :type material_name: str, optional
+    :ivar lattice_parameters: Lattice spacing(s) for the calibration
+        material in angstroms, defaults to `5.41153`.
+    :type lattice_parameters: float, list[float], optional
+    :ivar sgnum: Space group of the calibration material,
+        defaults to `225`.
+    :type sgnum: int, optional
     """
+    #RV Name suggests it's always Ceria, why have material_name?
     material_name: constr(strip_whitespace=True, min_length=1) = 'CeO2'
-    sgnum: Optional[conint(ge=0)] = 225
     lattice_parameters: confloat(gt=0) = 5.41153
+    sgnum: Optional[conint(ge=0)] = 225
 
 
 class MCACeriaCalibrationConfig(MCAScanDataConfig):
     """
-    Class representing metadata required to perform a Ceria calibration for an
-    MCA detector.
-
-    :ivar scan_step_index: Index of the scan step to use for calibration,
-        optional. If not specified, the calibration routine will be performed
-        on the average of all MCA spectra for the scan.
-
-    :ivar flux_file: csv file containing station beam energy in eV (column 0)
-        and flux (column 1)
-
-    :ivar material: material configuration for Ceria
+    Class representing metadata required to perform a Ceria calibration
+    for an MCA detector.
+
+    :ivar scan_step_index: Optional scan step index to use for the
+        calibration. If not specified, the calibration will be
+        performed on the average of all MCA spectra for the scan.
+    :type scan_step_index: int, optional
+    :ivar flux_file: File name of the csv flux file containing station
+        beam energy in eV (column 0) versus flux (column 1).
+    :type flux_file: str
+    :ivar material: Material configuration for Ceria.
     :type material: CeriaConfig
-
-    :ivar detectors: list of individual detector element calibration
-        configurations
+    :ivar detectors: List of individual MCA detector element
+        calibration configurations.
     :type detectors: list[MCAElementCalibrationConfig]
-
-    :ivar max_iter: maximum number of iterations of the calibration routine,
-        defaults to `10`.
-    :ivar tune_tth_tol: stop iteratively tuning 2&theta when an iteration
-        produces a change in the tuned value of 2&theta that is smaller than
-        this value, defaults to `1e-8`.
+    :ivar max_iter: Maximum number of iterations of the calibration
+        routine, defaults to `10`.
+    :type detectors: int, optional
+    :ivar tune_tth_tol: Cutoff error for tuning 2&theta. Stop iterating
+        the calibration routine after an iteration produces a change in
+        the tuned value of 2&theta that is smaller than this cutoff,
+        defaults to `1e-8`.
+    :ivar tune_tth_tol: float, optional
     """
     scan_step_index: Optional[conint(ge=0)]
-
-    flux_file: FilePath
-
     material: CeriaConfig = CeriaConfig()
-
     detectors: conlist(min_items=1, item_type=MCAElementCalibrationConfig)
-
+    flux_file: FilePath
     max_iter: conint(gt=0) = 10
     tune_tth_tol: confloat(ge=0) = 1e-8
 
+    @root_validator(pre=True)
+    def validate_config(cls, values):
+        """Ensure that a valid configuration was provided and finalize
+        flux_file filepath.
+
+        :param values: Dictionary of class field values.
+        :type values: dict
+        :return: The validated list of `values`.
+        :rtype: dict
+        """
+        inputdir = values.get('inputdir')
+        if inputdir is not None:
+            flux_file = values.get('flux_file')
+            if not os.path.isabs(flux_file):
+                values['flux_file'] = os.path.join(inputdir, flux_file)
+
+        return values
+
+    @property
+    def flux_file_energy_range(self):
+        """Get the energy range in the flux corection file.
+
+        :return: The energy range in the flux corection file.
+        :rtype: tuple(float, float)
+        """
+        flux = np.loadtxt(self.flux_file)
+        energies = flux[:,0]/1.e3
+        return energies.min(), energies.max()
+
     def mca_data(self, detector_config):
-        """Get the 1D array of MCA data to use for calibration.
+        """Get the array of MCA data to use for calibration.
 
-        :param detector_config: detector for which data will be returned
+        :param detector_config: Detector for which data is returned.
         :type detector_config: MCAElementConfig
-        :return: MCA data
+        :return: The current detectors's MCA data.
         :rtype: np.ndarray
         """
         if self.scan_step_index is None:
@@ -482,10 +596,10 @@ class MCACeriaCalibrationConfig(MCAScanDataConfig):
 
     def flux_correction_interpolation_function(self):
         """
-        Get an interpolation function to correct MCA data for relative energy
-        flux of the incident beam.
+        Get an interpolation function to correct MCA data for the
+        relative energy flux of the incident beam.
 
-        :return: energy flux correction interpolation function
+        :return: Energy flux correction interpolation function.
         :rtype: scipy.interpolate._polyint._Interpolator1D
         """
 
@@ -497,32 +611,85 @@ class MCACeriaCalibrationConfig(MCAScanDataConfig):
 
 
 class MCAElementStrainAnalysisConfig(MCAElementConfig):
-    """Model for parameters need to perform strain analysis fitting
-    for one MCA element.
+    """Class representing metadata required to perform a strain
+    analysis fitting for a single MCA detector element.
+
+    :ivar max_energy_kev: Maximum channel energy of the MCA in keV.
+    :type max_energy_kev: float, optional
+    :ivar num_bins: Number of MCA channels.
+    :type num_bins: int, optional
+    :param tth_max: Detector rotation about hutch x axis, defaults
+            to `90.0`.
+    :type tth_max: float, optional
+    :ivar hkl_tth_tol: Minimum resolvable difference in 2&theta between
+        two unique HKL peaks, defaults to `0.15`.
+    :type hkl_tth_tol: float, optional
+    :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 peak_models: Peak model for peak fitting,
+        defaults to `'gaussian'`.
+    :type peak_models: Literal['gaussian', 'lorentzian']],
+        list[Literal['gaussian', 'lorentzian']]], optional
+    :ivar fwhm_min: Minimum FWHM for peak fitting, defaults to `1.0`.
+    :type fwhm_min: float, optional
+    :ivar fwhm_max: Maximum FWHM for peak fitting, defaults to `5.0`.
+    :type fwhm_max: float, optional
+    :ivar rel_amplitude_cutoff: Relative peak amplitude cutoff for
+        peak fitting (any peak with an amplitude smaller than
+        `rel_amplitude_cutoff` times the sum of all peak amplitudes
+        gets removed from the fit model), defaults to `None`.
+    :type rel_amplitude_cutoff: float, optional
+    :ivar tth_calibrated: Calibrated value for 2&theta.
+    :type tth_calibrated: float, optional
+    :ivar slope_calibrated: Calibrated value for detector channel.
+        energy correction linear slope
+    :type  slope_calibrated: float, optional
+    :ivar intercept_calibrated: Calibrated value for detector channel
+        energy correction y-intercept.
+    :type intercept_calibrated: float, optional
     """
+    max_energy_kev: Optional[confloat(gt=0)]
+    num_bins: Optional[conint(gt=0)]
     tth_max: confloat(gt=0, allow_inf_nan=False) = 90.0
     hkl_tth_tol: confloat(gt=0, allow_inf_nan=False) = 0.15
-    fit_hkls: Optional[conlist(item_type=conint(ge=0), min_items=1)] = None
+    hkl_indices: Optional[conlist(item_type=conint(ge=0), min_items=1)] = []
     background: Optional[str]
     peak_models: Union[
         conlist(item_type=Literal['gaussian', 'lorentzian'], min_items=1),
         Literal['gaussian', 'lorentzian']] = 'gaussian'
+    fwhm_min: confloat(gt=0, allow_inf_nan=False) = 1.0
+    fwhm_max: confloat(gt=0, allow_inf_nan=False) = 5.0
+    rel_amplitude_cutoff: Optional[confloat(gt=0, lt=1.0, allow_inf_nan=False)]
 
-    tth_file: Optional[FilePath]
     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)]
-    max_energy_kev: Optional[confloat(gt=0)]
-    num_bins: Optional[conint(gt=0)]
+    tth_file: Optional[FilePath]
+    tth_map: Optional[np.ndarray] = None
 
-    _tth_map: Optional[np.ndarray]
+    @validator('hkl_indices', pre=True)
+    def validate_hkl_indices(cls, hkl_indices):
+        if isinstance(hkl_indices, str):
+            # Local modules
+            from CHAP.utils.general import string_to_list
+
+            hkl_indices = string_to_list(hkl_indices)
+        return sorted(hkl_indices)
+
+    class Config:
+        arbitrary_types_allowed = True
 
     def add_calibration(self, calibration):
         """Finalize values for some fields using a completed
         MCAElementCalibrationConfig that corresponds to the same
         detector.
 
-        :param calibration: MCAElementCalibrationConfig
+        :param calibration: Existing calibration configuration to use
+            by MCAElementStrainAnalysisConfig.
+        :type calibration: MCAElementCalibrationConfig
         :return: None
         """
         add_fields = ['tth_calibrated', 'slope_calibrated',
@@ -530,71 +697,91 @@ class MCAElementStrainAnalysisConfig(MCAElementConfig):
         for field in add_fields:
             setattr(self, field, getattr(calibration, field))
 
-    def fit_ds(self, materials):
-        """Get a list of HKLs and their lattice spacings that will be
-        fit in the strain analysis routine
+    def get_tth_map(self, map_config):
+        """Return a map of 2&theta values to use -- may vary at each
+        point in the map.
 
-        :return: HKLs to fit and their lattice spacings in angstroms
-        :rtype: np.ndarray, np.ndarray
+        :param map_config: The map configuration with which the
+            returned map of 2&theta values will be used.
+        :type map_config: CHAP.common.models.map.MapConfig
+        :return: Map of 2&theta values.
+        :rtype: np.ndarray
         """
-        if not isinstance(materials, list):
-            materials = [materials]
-        from CHAP.edd.utils import get_unique_hkls_ds
-        unique_hkls, unique_ds = get_unique_hkls_ds(materials)
-
-        # unique_hkls, unique_ds = material.unique_ds(
-        #     tth_tol=self.hkl_tth_tol, tth_max=self.tth_max)
-
-        fit_hkls = np.array([unique_hkls[i] for i in self.fit_hkls])
-        fit_ds = np.array([unique_ds[i] for i in self.fit_hkls])
-
-        return fit_hkls, fit_ds
+        if getattr(self, 'tth_map', None) is not None:
+            return self.tth_map
+        return np.full(map_config.shape, self.tth_calibrated)
 
-    def tth_map(self, map_config):
-        """Return a map of tth values to use -- may vary at each point
-        in the map.
+    def dict(self, *args, **kwargs):
+        """Return a representation of this configuration in a
+        dictionary that is suitable for dumping to a YAML file.
 
-        :param map_config: the map configuration with which the
-            returned map of tth values will be used.
-        :type map_config: MapConfig
-        :return: map of thh values
-        :rtype: np.ndarray
+        :return: Dictionary representation of the configuration.
+        :rtype: dict
         """
-        if self._tth_map is not None:
-            return self._tth_map
-        return np.full(map_config.shape, self.tth_calibrated)
+        d = super().dict(*args, **kwargs)
+        for k,v in d.items():
+            if isinstance(v, PosixPath):
+                d[k] = str(v)
+            if isinstance(v, np.ndarray):
+                d[k] = v.tolist()
+        return d
 
 
 class StrainAnalysisConfig(BaseModel):
-    """Model for inputs to CHAP.edd.StrainAnalysisProcessor"""
+    """Class representing input parameters required to perform a
+    strain analysis.
+
+    :ivar inputdir: Input directory, used only if any file in the
+            configuration is not an absolute path.
+    :type inputdir: str, optional
+    :ivar map_config: The map configuration for the MCA data on which
+        the strain analysis is performed.
+    :type map_config: CHAP.common.models.map.MapConfig, optional
+    :ivar par_file: Path to the par file associated with the scan.
+    :type par_file: str, optional
+    :ivar par_dims: List of independent dimensions.
+    :type par_dims: list[dict[str,str]], optional
+    :ivar other_dims: List of other column names from `par_file`.
+    :type other_dims: list[dict[str,str]], optional
+    :ivar detectors: List of individual detector element strain
+        analysis configurations
+    :type detectors: list[MCAElementStrainAnalysisConfig]
+    :ivar material_name: Sample material configurations.
+    :type material_name: list[MaterialConfig]
+    """
     inputdir: Optional[DirectoryPath]
     map_config: Optional[MapConfig]
     par_file: Optional[FilePath]
     par_dims: Optional[list[dict[str,str]]]
     other_dims: Optional[list[dict[str,str]]]
-    flux_file: FilePath
     detectors: conlist(min_items=1, item_type=MCAElementStrainAnalysisConfig)
     materials: list[MaterialConfig]
+    flux_file: FilePath
 
     _parfile: Optional[ParFile]
 
     @root_validator(pre=True)
-    def validate_map(cls, values):
-        """Ensure exactly one valid map configuration was provided,
-        and finalize input filepaths
+    def validate_config(cls, values):
+        """Ensure that a valid configuration was provided and finalize
+        input filepaths.
+
+        :param values: Dictionary of class field values.
+        :type values: dict
+        :raises ValueError: Missing par_dims value.
+        :return: The validated list of `values`.
+        :rtype: dict
         """
         inputdir = values.get('inputdir')
         flux_file = values.get('flux_file')
         par_file = values.get('par_file')
-        if flux_file:
-            if not os.path.isabs(flux_file):
-                values['flux_file'] = os.path.join(inputdir, flux_file)
-        if par_file:
-            if not os.path.isabs(par_file):
+        if inputdir is not None and not os.path.isabs(flux_file):
+            values['flux_file'] = os.path.join(inputdir, flux_file)
+        if par_file is not None:
+            if inputdir is not None and not os.path.isabs(par_file):
                 values['par_file'] = os.path.join(inputdir, par_file)
             if 'par_dims' not in values:
                 raise ValueError(
-                    'If using par_file, must also use par_dims')
+                    'par_dims is required when using par_file')
             values['_parfile'] = ParFile(values['par_file'])
             values['map_config'] = values['_parfile'].get_map(
                 'EDD', 'id1a3', values['par_dims'],
@@ -603,7 +790,7 @@ class StrainAnalysisConfig(BaseModel):
         if isinstance(map_config, dict):
             for i, scans in enumerate(map_config.get('spec_scans')):
                 spec_file = scans.get('spec_file')
-                if not os.path.isabs(spec_file):
+                if inputdir is not None and not os.path.isabs(spec_file):
                     values['map_config']['spec_scans'][i]['spec_file'] = \
                         os.path.join(inputdir, spec_file)
         return values
@@ -630,7 +817,7 @@ class StrainAnalysisConfig(BaseModel):
                     + 'StrainAnalysisConfig that uses par_file.')
             else:
                 try:
-                    detector._tth_map = ParFile(values['par_file']).map_values(
+                    detector.tth_map = ParFile(values['par_file']).map_values(
                         values['map_config'], np.loadtxt(detector.tth_file))
                 except Exception as e:
                     raise ValueError(
@@ -638,11 +825,46 @@ class StrainAnalysisConfig(BaseModel):
                         + f'{detector.tth_file}') from e
         return detector
 
+    def mca_data(self, detector=None, map_index=None):
+        """Get MCA data for a single or multiple detector elements.
+
+        :param detector: Detector(s) for which data is returned,
+            defaults to `None`, which return MCA data for all 
+            detector elements.
+        :type detector: Union[int, MCAElementStrainAnalysisConfig],
+            optional
+        :param map_index: Index of a single point in the map, defaults
+            to `None`, which returns MCA data for each point in the map.
+        :type map_index: tuple, optional
+        :return: A single MCA spectrum.
+        :rtype: np.ndarray
+        """
+        if detector is None:
+            mca_data = []
+            for detector_config in self.detectors:
+                mca_data.append(self.mca_data(detector_config, map_index))
+            return np.asarray(mca_data)
+        else:
+            if isinstance(detector, int):
+                detector_config = self.detectors[detector]
+            else:
+                if not isinstance(detector, MCAElementStrainAnalysisConfig):
+                    raise ValueError('Invalid parameter detector ({detector})')
+                detector_config = detector
+            if map_index is None:
+                mca_data = []
+                for map_index in np.ndindex(self.map_config.shape):
+                    mca_data.append(self.mca_data(detector_config, map_index))
+                return np.asarray(mca_data)
+            else:
+                return self.map_config.get_detector_data(
+                    detector_config.detector_name, map_index)
+
     def dict(self, *args, **kwargs):
         """Return a representation of this configuration in a
         dictionary that is suitable for dumping to a YAML file.
 
-        :return: dictionary representation of the configuration.
+        :return: Dictionary representation of the configuration.
         :rtype: dict
         """
         d = super().dict(*args, **kwargs)
@@ -652,29 +874,3 @@ class StrainAnalysisConfig(BaseModel):
         if '_scanparser' in d:
             del d['_scanparser']
         return d
-
-    def mca_data(self, detector_config, map_index):
-        """Get MCA data for a single detector element.
-
-        :param detector_config: the detector to get data for
-        :type detector_config: MCAElementStrainAnalysisConfig
-        :param map_index: index of a single point in the map
-        :type map_index: tuple
-        :return: one spectrum of MCA data
-        :rtype: np.ndarray
-        """
-        map_coords = {dim: self.map_config.coords[dim][i]
-                      for dim,i in zip(self.map_config.dims, map_index)}
-        for scans in self.map_config.spec_scans:
-            for scan_number in scans.scan_numbers:
-                scanparser = scans.get_scanparser(scan_number)
-                for scan_step_index in range(scanparser.spec_scan_npts):
-                    _coords = {
-                        dim.label:dim.get_value(
-                            scans, scan_number, scan_step_index)
-                        for dim in self.map_config.independent_dimensions}
-                    if _coords == map_coords:
-                        break
-        scanparser = scans.get_scanparser(scan_number)
-        return scanparser.get_detector_data(detector_config.detector_name,
-                                            scan_step_index)