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

CHAP/edd/models.py

@@ -1,4 +1,5 @@
 # System modules
+from copy import deepcopy
 import os
 from pathlib import PosixPath
 from typing import (
@@ -13,6 +14,7 @@ from hexrd.material import Material
 from pydantic import (
     BaseModel,
     DirectoryPath,
+    Field,
     FilePath,
     PrivateAttr,
     StrictBool,
@@ -20,16 +22,16 @@ from pydantic import (
     conint,
     conlist,
     constr,
-    root_validator,
-    validator,
+    field_validator,
+    model_validator,
 )
 from scipy.interpolate import interp1d
+from typing_extensions import Annotated
 
 # Local modules
 from CHAP.common.models.map import MapConfig
 from CHAP.utils.parfile import ParFile
-from CHAP.utils.scanparsers import SMBMCAScanParser as ScanParser
-
+from chess_scanparsers import SMBMCAScanParser as ScanParser
 
 # Baseline configuration class
 
@@ -65,33 +67,27 @@ class MaterialConfig(BaseModel):
     :ivar sgnum: Space group of the material.
     :type sgnum: int, optional
     """
-    material_name: Optional[constr(strip_whitespace=True, min_length=1)]
+    material_name: Optional[constr(strip_whitespace=True, min_length=1)] = None
     lattice_parameters: Optional[Union[
         confloat(gt=0),
-        conlist(item_type=confloat(gt=0), min_items=1, max_items=6)]]
-    sgnum: Optional[conint(ge=0)]
+        conlist(min_length=1, max_length=6, item_type=confloat(gt=0))]] = None
+    sgnum: Optional[conint(ge=0)] = None
 
     _material: Optional[Material]
 
-    class Config:
-        underscore_attrs_are_private = False
-
-    @root_validator
-    def validate_material(cls, values):
+    @model_validator(mode='after')
+    def validate_material(self):
         """Create and validate the private attribute _material.
 
-        :param values: Dictionary of previously validated field values.
-        :type values: dict
-        :return: The validated list of `values`.
+        :return: The validated list of class properties.
         :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
+        self._material = make_material(
+            self.material_name, self.sgnum, self.lattice_parameters)
+        return self
 
     def unique_hkls_ds(self, tth_tol=0.15, tth_max=90.0):
         """Get a list of unique HKLs and their lattice spacings.
@@ -103,7 +99,7 @@ class MaterialConfig(BaseModel):
             defaults to `90.0`.
         :type tth_max: float, optional
         :return: Unique HKLs and their lattice spacings in angstroms.
-        :rtype: np.ndarray, np.ndarray
+        :rtype: numpy.ndarray, numpy.ndarray
         """
         # Local modules
         from CHAP.edd.utils import get_unique_hkls_ds
@@ -118,7 +114,7 @@ class MaterialConfig(BaseModel):
         :rtype: dict
         """
         d = super().dict(*args, **kwargs)
-        for k,v in d.items():
+        for k, v in d.items():
             if isinstance(v, PosixPath):
                 d[k] = str(v)
         if '_material' in d:
@@ -139,7 +135,22 @@ class MCAElementConfig(BaseModel):
     :type num_bins: int, optional
     """
     detector_name: constr(strip_whitespace=True, min_length=1) = 'mca1'
-    num_bins: Optional[conint(gt=0)]
+    num_bins: Optional[conint(gt=0)] = None
+
+    @field_validator('detector_name', mode='before')
+    @classmethod
+    def validate_detector_name(cls, detector_name):
+        """Validate the specified detector name.
+
+        :ivar detector_name: Name of the MCA detector element in the scan.
+        :type detector_name: Union(str, int)
+        :raises ValueError: Invalid detector_name.
+        :return: detector_name.
+        :rtype: str
+        """
+        if isinstance(detector_name, int):
+            return str(detector_name)
+        return detector_name
 
     def dict(self, *args, **kwargs):
         """Return a representation of this configuration in a
@@ -185,47 +196,55 @@ 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
     energy_calibration_coeffs: conlist(
-        min_items=3, max_items=3,
+        min_length=3, max_length=3,
         item_type=confloat(allow_inf_nan=False)) = [0, 0, 1]
-    background: Optional[Union[str, list]]
+    background: Optional[Union[str, list]] = None
     baseline: Optional[Union[bool, BaselineConfig]] = False
     tth_initial_guess: confloat(gt=0, le=tth_max, allow_inf_nan=False) = 5.0
-    tth_calibrated: Optional[confloat(gt=0, allow_inf_nan=False)]
-    include_energy_ranges: conlist(
-        min_items=1,
-        item_type=conlist(
-            item_type=confloat(ge=25),
-            min_items=2,
-            max_items=2)) = [[50, 150]]
+    tth_calibrated: Optional[confloat(gt=0, allow_inf_nan=False)] = None
+    include_energy_ranges: Annotated[
+        conlist(
+            min_length=1,
+            item_type=conlist(
+                min_length=2,
+                max_length=2,
+                item_type=confloat(ge=25))),
+        Field(validate_default=True)] = [[50, 150]]
 
     _hkl_indices: list = PrivateAttr()
 
-    @validator('include_energy_ranges', each_item=True)
-    def validate_include_energy_range(cls, value, values):
+    @field_validator('include_energy_ranges')
+    @classmethod
+    def validate_include_energy_range(cls, include_energy_ranges, info):
         """Ensure that no energy ranges are outside the boundary of the
         detector.
 
-        :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_energy_ranges`.
+        :param include_energy_ranges:
+            The value of `include_energy_ranges` to validate.
+        :type include_energy_ranges: dict
+        :param info: Pydantic validator info object.
+        :type info: pydantic_core._pydantic_core.ValidationInfo
         :rtype: dict
         """
-        value.sort()
-        n_max = values.get('num_bins')
+        n_max = info.data.get('num_bins')
+        for i in range(len(include_energy_ranges)):
+            include_energy_ranges[i].sort()
         if n_max is not None:
             n_max -= 1
-            a, b, c = values.get('energy_calibration_coeffs')
+            a, b, c = info.data.get('energy_calibration_coeffs')
             e_max = (a*n_max + b)*n_max +c
-            if value[0] < c or value[1] > e_max:
-                newvalue = [float(max(value[0], c)),
-                        float(min(value[1], e_max))]
-                print(
-                    f'WARNING: include_energy_range out of range'
-                    f' ({value}): adjusted to {newvalue}')
-                value = newvalue
-        return value
+            for i, include_energy_range in enumerate(
+                    deepcopy(include_energy_ranges)):
+                if (include_energy_range[0] < c
+                        or include_energy_range[1] > e_max):
+                    include_energy_ranges[i] = [
+                        float(max(include_energy_range[0], c)),
+                        float(min(include_energy_range[1], e_max))]
+                    print(
+                        f'WARNING: include_energy_range out of range'
+                        f' ({include_energy_range}): adjusted to '
+                        f'{include_energy_ranges[i]}')
+        return include_energy_ranges
 
     @property
     def energies(self):
@@ -293,10 +312,17 @@ class MCAElementCalibrationConfig(MCAElementConfig):
         """Set the private attribute `hkl_indices`."""
         self._hkl_indices = hkl_indices
 
-#RV need def dict?
-#        d['include_energy_ranges'] = [
-#            [float(energy) for energy in d['include_energy_ranges'][i]]
-#            for i in range(len(d['include_energy_ranges']))]
+    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.
+        :rtype: dict
+        """
+        d = super().dict(*args, **kwargs)
+        if '_hkl_indices:' in d:
+            del d['_hkl_indices:']
+        return d
 
 
 class MCAElementDiffractionVolumeLengthConfig(MCAElementConfig):
@@ -327,11 +353,11 @@ class MCAElementDiffractionVolumeLengthConfig(MCAElementConfig):
     """
     include_bin_ranges: Optional[
         conlist(
-            min_items=1,
+            min_length=1,
             item_type=conlist(
-                item_type=conint(ge=0),
-                min_items=2,
-                max_items=2))]
+                min_length=2,
+                max_length=2,
+                item_type=conint(ge=0)))] = None
     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
@@ -420,7 +446,7 @@ class MCAElementStrainAnalysisConfig(MCAElementConfig):
     :ivar tth_file: Path to the file with the 2&theta map.
     :type tth_file: FilePath, optional
     :ivar tth_map: Map of the 2&theta values.
-    :type tth_map: np.ndarray, optional
+    :type tth_map: numpy.ndarray, optional
     :ivar include_energy_ranges: List of MCA channel energy ranges
         in keV whose data should be included after applying a mask
         (bounds are inclusive), defaults to `[[50, 150]]`
@@ -429,36 +455,36 @@ 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))] = []
-    background: Optional[Union[str, list]]
+    background: Optional[Union[str, list]] = None
     baseline: Optional[Union[bool, BaselineConfig]] = False
     num_proc: Optional[conint(gt=0)] = os.cpu_count()
     peak_models: Union[
-        conlist(item_type=Literal['gaussian', 'lorentzian'], min_items=1),
+        conlist(min_length=1, item_type=Literal['gaussian', 'lorentzian']),
         Literal['gaussian', 'lorentzian']] = 'gaussian'
     fwhm_min: confloat(gt=0, allow_inf_nan=False) = 0.25
     fwhm_max: confloat(gt=0, allow_inf_nan=False) = 2.0
     centers_range: confloat(gt=0, allow_inf_nan=False) = 2.0
-    rel_height_cutoff: Optional[confloat(gt=0, lt=1.0, allow_inf_nan=False)]
-
-    tth_calibrated: Optional[confloat(gt=0, allow_inf_nan=False)]
+    rel_height_cutoff: Optional[
+        confloat(gt=0, lt=1.0, allow_inf_nan=False)] = None
+    tth_calibrated: Optional[confloat(gt=0, allow_inf_nan=False)] = None
     energy_calibration_coeffs: conlist(
-        min_items=3, max_items=3,
+        min_length=3, max_length=3,
         item_type=confloat(allow_inf_nan=False)) = [0, 0, 1]
     calibration_bin_ranges: Optional[
         conlist(
-            min_items=1,
+            min_length=1,
             item_type=conlist(
-                item_type=conint(ge=0),
-                min_items=2,
-                max_items=2))]
-    tth_file: Optional[FilePath]
+                min_length=2,
+                max_length=2,
+                item_type=conint(ge=0)))] = None
+    tth_file: Optional[FilePath] = None
     tth_map: Optional[np.ndarray] = None
     include_energy_ranges: conlist( 
-        min_items=1,
+        min_length=1,
         item_type=conlist(
-            item_type=confloat(ge=25),
-            min_items=2,
-            max_items=2)) = [[50, 150]]
+            min_length=2,
+            max_length=2,
+            item_type=confloat(ge=25))) = [[50, 150]]
 
     #RV lots of overlap with MCAElementCalibrationConfig (only missing
     #   tth_initial_guess)
@@ -468,7 +494,8 @@ class MCAElementStrainAnalysisConfig(MCAElementConfig):
     #   the unique fields tth_initial_guess added?
     #   Revisit when we redo the detectors
 
-    @validator('hkl_indices', pre=True)
+    @field_validator('hkl_indices', mode='before')
+    @classmethod
     def validate_hkl_indices(cls, hkl_indices):
         if isinstance(hkl_indices, str):
             # Local modules
@@ -555,7 +582,7 @@ class MCAElementStrainAnalysisConfig(MCAElementConfig):
 
         :param map_shape: The shape of the suplied 2&theta map.
         :return: Map of 2&theta values.
-        :rtype: np.ndarray
+        :rtype: numpy.ndarray
         """
         if getattr(self, 'tth_map', None) is not None:
             if self.tth_map.shape != map_shape:
@@ -573,7 +600,7 @@ class MCAElementStrainAnalysisConfig(MCAElementConfig):
         :rtype: dict
         """
         d = super().dict(*args, **kwargs)
-        for k,v in d.items():
+        for k, v in d.items():
             if isinstance(v, PosixPath):
                 d[k] = str(v)
             if isinstance(v, np.ndarray):
@@ -588,7 +615,7 @@ class MCAScanDataConfig(BaseModel):
     a single scan and construct a mask for it.
 
     :ivar inputdir: Input directory, used only if any file in the
-            configuration is not an absolute path.
+        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
@@ -602,86 +629,84 @@ class MCAScanDataConfig(BaseModel):
         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[str]
-    detectors: conlist(min_items=1, item_type=MCAElementConfig)
-
-    _parfile: Optional[ParFile]
-    _scanparser: Optional[ScanParser]
-
-    class Config:
-        underscore_attrs_are_private = False
-
-    @root_validator(pre=True)
-    def validate_scan(cls, values):
+    inputdir: Optional[DirectoryPath] = None
+    spec_file: Optional[FilePath] = None
+    scan_number: Optional[conint(gt=0)] = None
+    par_file: Optional[FilePath] = None
+    scan_column: Optional[str] = None
+    detectors: conlist(min_length=1, item_type=MCAElementConfig)
+
+    _parfile: Optional[ParFile] = None
+    _scanparser: Optional[ScanParser] = None
+
+    @model_validator(mode='before')
+    @classmethod
+    def validate_scan(cls, data):
         """Finalize file paths for spec_file and par_file.
 
-        :param values: Dictionary of class field values.
-        :type values: dict
+        :param data: Pydantic validator data object.
+        :type data: MCAScanDataConfig,
+            pydantic_core._pydantic_core.ValidationInfo
         :raises ValueError: Invalid SPEC or par file.
-        :return: The validated list of `values`.
+        :return: The validated list of class properties.
         :rtype: dict
         """
-        inputdir = values.get('inputdir')
-        spec_file = values.get('spec_file')
-        par_file = values.get('par_file')
+        inputdir = data.get('inputdir')
+        spec_file = data.get('spec_file')
+        par_file = data.get('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 is not None:
             if inputdir is not None and not os.path.isabs(spec_file):
-                values['spec_file'] = os.path.join(inputdir, spec_file)
+                data['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:
+                data['par_file'] = os.path.join(inputdir, par_file)
+            if 'scan_column' not in data:
                 raise ValueError(
                     'scan_column is required when par_file is used')
-            if isinstance(values['scan_column'], str):
+            if isinstance(data['scan_column'], str):
                 parfile = ParFile(par_file)
-                if values['scan_column'] not in parfile.column_names:
+                if data['scan_column'] not in parfile.column_names:
                     raise ValueError(
-                        f'No column named {values["scan_column"]} in '
-                        + '{values["par_file"]}. Options: '
+                        f'No column named {data["scan_column"]} in '
+                        + '{data["par_file"]}. Options: '
                         + ', '.join(parfile.column_names))
         else:
             raise ValueError('Must use either spec_file or par_file')
 
-        return values
+        return data
 
-    @root_validator
-    def validate_detectors(cls, values):
+    @model_validator(mode='after')
+    def validate_detectors(self):
         """Fill in values for _scanparser / _parfile (if applicable).
         Fill in each detector's num_bins field, if needed.
         Check each detector's include_energy_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`.
+        :return: The validated list of class properties.
         :rtype: dict
         """
-        spec_file = values.get('spec_file')
-        par_file = values.get('par_file')
-        detectors = values.get('detectors')
-        flux_file = values.get('flux_file')
+        spec_file = self.spec_file
+        par_file = self.par_file
+        detectors = self.detectors
+        flux_file = self.flux_file
         if spec_file is not None:
-            values['_scanparser'] = ScanParser(
-                spec_file, values.get('scan_number'))
-            values['_parfile'] = None
+            self._scanparser = ScanParser(
+                spec_file, self.scan_number)
+            self._parfile = None
         elif par_file is not None:
-            values['_parfile'] = ParFile(par_file)
-            values['_scanparser'] = ScanParser(
-                values['_parfile'].spec_file,
-                values['_parfile'].good_scan_numbers()[0])
+            self._parfile = ParFile(par_file)
+            self._scanparser = ScanParser(
+                self._parfile.spec_file,
+                self._parfile.good_scan_numbers()[0])
         for detector in detectors:
             if detector.num_bins is None:
                 try:
-                    detector.num_bins = values['_scanparser']\
-                        .get_detector_num_bins(detector.detector_name)
+                    detector.num_bins = \
+                        self._scanparser.get_detector_num_bins(
+                                detector.detector_name)
                 except Exception as e:
                     raise ValueError('No value found for num_bins') from e
         if flux_file is not None:
@@ -704,7 +729,7 @@ class MCAScanDataConfig(BaseModel):
                             f' to {energy_range}')
                         detector.include_energy_ranges[i] = energy_range
 
-        return values
+        return self
 
     @property
     def scanparser(self):
@@ -716,39 +741,6 @@ class MCAScanDataConfig(BaseModel):
             self._scanparser = scanparser
         return scanparser
 
-    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 is returned.
-        :type detector_config: MCAElementConfig
-        :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:
-                data = np.asarray(
-                    [ScanParser(self._parfile.spec_file, scan_number)\
-                     .get_all_detector_data(detector_name)[0] \
-                     for scan_number in self._parfile.good_scan_numbers()])
-            else:
-                data = ScanParser(
-                    self._parfile.spec_file,
-                    self._parfile.good_scan_numbers()[scan_step_index])\
-                    .get_all_detector_data(detector_name)
-        else:
-            if scan_step_index is None:
-                data = self.scanparser.get_all_detector_data(
-                    detector_name)
-            else:
-                data = self.scanparser.get_detector_data(
-                    detector_config.detector_name, scan_step_index)
-        return data
-
     def dict(self, *args, **kwargs):
         """Return a representation of this configuration in a
         dictionary that is suitable for dumping to a YAML file.
@@ -757,7 +749,7 @@ class MCAScanDataConfig(BaseModel):
         :rtype: dict
         """
         d = super().dict(*args, **kwargs)
-        for k,v in d.items():
+        for k, v in d.items():
             if isinstance(v, PosixPath):
                 d[k] = str(v)
         if d.get('_parfile') is None:
@@ -786,8 +778,8 @@ class DiffractionVolumeLengthConfig(MCAScanDataConfig):
     :type detectors: list[MCAElementDiffractionVolumeLengthConfig]
     """
     sample_thickness: float
-    detectors: conlist(min_items=1,
-                       item_type=MCAElementDiffractionVolumeLengthConfig)
+    detectors: conlist(
+        min_length=1, item_type=MCAElementDiffractionVolumeLengthConfig)
 
     @property
     def scanned_vals(self):
@@ -795,7 +787,7 @@ class DiffractionVolumeLengthConfig(MCAScanDataConfig):
         over the course of the raster scan.
 
         :return: List of scanned motor values
-        :rtype: np.ndarray
+        :rtype: numpy.ndarray
         """
         if self._parfile is not None:
             return self._parfile.get_values(
@@ -804,18 +796,21 @@ class DiffractionVolumeLengthConfig(MCAScanDataConfig):
         return self.scanparser.spec_scan_motor_vals[0]
 
 
-class MCAEnergyCalibrationConfig(MCAScanDataConfig):
+class MCAEnergyCalibrationConfig(BaseModel):
     """
     Class representing metadata required to perform an energy
     calibration for an MCA detector.
 
+    :ivar inputdir: Input directory, used only if any file in the
+        configuration is not an absolute path.
+    :type inputdir: str, optional
     :ivar scan_step_indices: Optional scan step indices 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_indices: list[int], optional
     :ivar detectors: List of individual MCA detector element
         calibration configurations.
-    :type detectors: list[MCAElementCalibrationConfig]
+    :type detectors: list[MCAElementCalibrationConfig], 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, optional
@@ -838,51 +833,54 @@ class MCAEnergyCalibrationConfig(MCAScanDataConfig):
     :type fit_index_ranges: list[[int, int]], optional
 
     """
-    scan_step_indices: Optional[conlist(min_items=1, item_type=conint(ge=0))]
-    detectors: conlist(min_items=1, item_type=MCAElementCalibrationConfig)
-    flux_file: Optional[FilePath]
+    inputdir: Optional[DirectoryPath] = None
+    scan_step_indices: Optional[Annotated[conlist(
+        min_length=1, item_type=conint(ge=0)),
+        Field(validate_default=True)]] = None
+    detectors: Optional[conlist(item_type=MCAElementCalibrationConfig)] = None
+    flux_file: Optional[FilePath] = None
     material: Optional[MaterialConfig] = MaterialConfig(
         material_name='CeO2', lattice_parameters=5.41153, sgnum=225)
-    peak_energies: conlist(item_type=confloat(gt=0), min_items=2)
+    peak_energies: conlist(min_length=2, item_type=confloat(gt=0))
     max_peak_index: conint(ge=0)
     fit_index_ranges: Optional[
         conlist(
-            min_items=1,
+            min_length=1,
             item_type=conlist(
-                item_type=conint(ge=0),
-                min_items=2,
-                max_items=2))]
+                min_length=2,
+                max_length=2,
+                item_type=conint(ge=0)))] = None
 
-    @root_validator(pre=True)
-    def validate_config(cls, values):
+    @model_validator(mode='before')
+    @classmethod
+    def validate_config(cls, data):
         """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`.
+        :param data: Pydantic validator data object.
+        :type data: MCAEnergyCalibrationConfig,
+            pydantic_core._pydantic_core.ValidationInfo
+        :return: The currently validated list of class properties.
         :rtype: dict
         """
-        inputdir = values.get('inputdir')
+        inputdir = data.get('inputdir')
         if inputdir is not None:
-            flux_file = values.get('flux_file')
+            flux_file = data.get('flux_file')
             if flux_file is not None and not os.path.isabs(flux_file):
-                values['flux_file'] = os.path.join(inputdir, flux_file)
+                data['flux_file'] = os.path.join(inputdir, flux_file)
 
-        return values
+        return data
 
-    @validator('scan_step_indices', pre=True, always=True)
-    def validate_scan_step_indices(cls, scan_step_indices, values):
+    @field_validator('scan_step_indices', mode='before')
+    @classmethod
+    def validate_scan_step_indices(cls, scan_step_indices):
         """Validate the specified list of scan numbers.
 
         :ivar scan_step_indices: Optional scan step indices 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_indices: list[int], optional
-        :param values: Dictionary of validated class field values.
-        :type values: dict
-        :raises ValueError: If a specified scan number is not found in
-            the SPEC file.
+        :raises ValueError: Invalid experiment type.
         :return: List of step indices.
         :rtype: list of int
         """
@@ -894,21 +892,22 @@ class MCAEnergyCalibrationConfig(MCAScanDataConfig):
                 scan_step_indices, raise_error=True)
         return scan_step_indices
 
-    @validator('max_peak_index')
-    def validate_max_peak_index(cls, max_peak_index, values):
+    @field_validator('max_peak_index')
+    @classmethod
+    def validate_max_peak_index(cls, max_peak_index, info):
         """Validate the specified index of the XRF peak with the
         highest amplitude.
 
         :ivar max_peak_index: The index of the XRF peak with the
             highest amplitude.
         :type max_peak_index: int
-        :param values: Dictionary of validated class field values.
-        :type values: dict
+        :param info: Pydantic validator info object.
+        :type info: pydantic_core._pydantic_core.ValidationInfo
         :raises ValueError: Invalid max_peak_index.
         :return: The validated value of `max_peak_index`.
         :rtype: int
         """
-        peak_energies = values.get('peak_energies')
+        peak_energies = info.data.get('peak_energies')
         if not 0 <= max_peak_index < len(peak_energies):
             raise ValueError('max_peak_index out of bounds')
         return max_peak_index
@@ -925,31 +924,6 @@ class MCAEnergyCalibrationConfig(MCAScanDataConfig):
         energies = flux[:,0]/1.e3
         return energies.min(), energies.max()
 
-    def mca_data(self, detector_config):
-        """Get the array of MCA data to use for calibration.
-
-        :param detector_config: Detector for which data is returned.
-        :type detector_config: MCAElementConfig
-        :return: The current detectors's MCA data.
-        :rtype: np.ndarray
-        """
-        if self.scan_step_indices is None:
-            data = super().mca_data(detector_config)
-            if self.scanparser.spec_scan_npts > 1:
-                data = np.average(data, axis=0)
-            else:
-                data = data[0]
-        elif len(self.scan_step_indices) == 1:
-            data = super().mca_data(
-                detector_config, scan_step_index=self.scan_step_indices[0])
-        else:
-            data = []
-            for scan_step_index in self.scan_step_indices:
-                data.append(super().mca_data(
-                    detector_config, scan_step_index=scan_step_index))
-            data = np.average(data, axis=0)
-        return data
-
     def flux_correction_interpolation_function(self):
         """
         Get an interpolation function to correct MCA data for the
@@ -966,6 +940,18 @@ class MCAEnergyCalibrationConfig(MCAScanDataConfig):
         interpolation_function = interp1d(energies, relative_intensities)
         return interpolation_function
 
+    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.
+        :rtype: dict
+        """
+        d = super().dict(*args, **kwargs)
+        if 'inputdir' in d:
+            del d['inputdir']
+        return d
+
 
 class MCATthCalibrationConfig(MCAEnergyCalibrationConfig):
     """
@@ -1011,22 +997,11 @@ class StrainAnalysisConfig(BaseModel):
     strain analysis.
 
     :ivar inputdir: Input directory, used only if any file in the
-            configuration is not an absolute path.
+        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 dataset_id: Integer ID of the SMB-style EDD dataset.
-    :type dataset_id: int, 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]
+        analysis configurations, defaults to `None` (use all detectors).
+    :type detectors: list[MCAElementStrainAnalysisConfig], optional
     :ivar materials: Sample material configurations.
     :type materials: list[MaterialConfig]
     :ivar flux_file: File name of the csv flux file containing station
@@ -1035,247 +1010,122 @@ class StrainAnalysisConfig(BaseModel):
     :ivar sum_axes: Whether to sum over the fly axis or not
         for EDD scan types not 0, defaults to `True`.
     :type sum_axes: bool, optional
+    :ivar oversampling: FIX
+    :type oversampling: FIX
     """
-    inputdir: Optional[DirectoryPath]
-    map_config: Optional[MapConfig]
-    par_file: Optional[FilePath]
-    dataset_id: Optional[int]
-    par_dims: Optional[list[dict[str,str]]]
-    other_dims: Optional[list[dict[str,str]]]
-    detectors: conlist(min_items=1, item_type=MCAElementStrainAnalysisConfig)
+    inputdir: Optional[DirectoryPath] = None
+    detectors: Optional[conlist(
+        min_length=1, item_type=MCAElementStrainAnalysisConfig)] = None
     materials: list[MaterialConfig]
-    flux_file: Optional[FilePath]
-    sum_axes: Optional[list[str]]
-    oversampling: Optional[dict] = {'num': 10}
-
-    _parfile: Optional[ParFile]
-
-    @root_validator(pre=True)
-    def validate_config(cls, values):
+    flux_file: Optional[FilePath] = None
+    sum_axes: Optional[bool] = True
+    oversampling: Optional[
+        Annotated[dict, Field(validate_default=True)]] = {'num': 10}
+
+    @model_validator(mode='before')
+    @classmethod
+    def validate_config(cls, data):
         """Ensure that a valid configuration was provided and finalize
-        input filepaths.
+        flux_file filepath.
 
-        :param values: Dictionary of class field values.
-        :type values: dict
-        :raises ValueError: Missing par_dims value.
-        :return: The validated list of `values`.
+        :param data: Pydantic validator data object.
+        :type data: MCAEnergyCalibrationConfig,
+            pydantic_core._pydantic_core.ValidationInfo
+        :return: The currently validated list of class properties.
         :rtype: dict
         """
-        inputdir = values.get('inputdir')
-        flux_file = values.get('flux_file')
-        par_file = values.get('par_file')
-        if (inputdir is not None and flux_file 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 'dataset_id' in values:
-                from CHAP.edd import EddMapReader
-                values['_parfile'] = ParFile(values['par_file'])
-                values['map_config'] = EddMapReader().read(
-                    values['par_file'], values['dataset_id'])
-            elif 'par_dims' in values:
-                values['_parfile'] = ParFile(values['par_file'])
-                values['map_config'] = values['_parfile'].get_map(
-                    'EDD', 'id1a3', values['par_dims'],
-                    other_dims=values.get('other_dims', []))
-            else:
-                raise ValueError(
-                    'dataset_id or par_dims is required when using par_file')
-        map_config = values.get('map_config')
-        if isinstance(map_config, dict):
-            for i, scans in enumerate(map_config.get('spec_scans')):
-                spec_file = scans.get('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
-
-    @validator('detectors', pre=True, each_item=True)
-    def validate_tth_file(cls, detector, values):
+        inputdir = data.get('inputdir')
+        if inputdir is not None:
+            flux_file = data.get('flux_file')
+            if flux_file is not None and not os.path.isabs(flux_file):
+                data['flux_file'] = os.path.join(inputdir, flux_file)
+
+        return data
+
+    @field_validator('detectors', mode='before')
+    @classmethod
+    def validate_tth_file(cls, detectors, info):
         """Finalize value for tth_file for each detector"""
-        inputdir = values.get('inputdir')
-        tth_file = detector.get('tth_file')
-        if tth_file:
-            if not os.path.isabs(tth_file):
-                detector['tth_file'] = os.path.join(inputdir, tth_file)
-        return detector
-
-    @validator('detectors', each_item=True)
-    def validate_tth(cls, detector, values):
-        """Validate detector element tth_file field. It may only be
-        used if StrainAnalysisConfig used par_file.
-        """
-        if detector.tth_file is not None:
-            if not values.get('par_file'):
-                raise ValueError(
-                    'variable tth angles may only be used with a '
-                    + 'StrainAnalysisConfig that uses par_file.')
-            else:
-                try:
-                    detector.tth_map = ParFile(values['par_file']).map_values(
-                        values['map_config'], np.loadtxt(detector.tth_file))
-                except Exception as e:
-                    raise ValueError(
-                        'Could not get map of tth angles from '
-                        + f'{detector.tth_file}') from e
-        return detector
-
-    @validator('sum_axes', always=True)
-    def validate_sum_axes(cls, value, values):
-        """Validate the sum_axes field.
-
-        :param value: Field value to validate (`sum_axes`).
-        :type value: bool
-        :param values: Dictionary of validated class field values.
-        :type values: dict
-        :return: The validated value for sum_axes.
-        :rtype: bool
-        """
-        if value is None:
-            map_config = values.get('map_config')
-            if map_config is not None:
-                if map_config.attrs['scan_type'] < 3:
-                    value = value
-                else:
-                    value = map_config.attrs.get('fly_axis_labels', [])
-        return value
-
-    @validator('oversampling', always=True)
-    def validate_oversampling(cls, value, values):
+        inputdir = info.data.get('inputdir')
+        for detector in detectors:
+            tth_file = detector.get('tth_file')
+            if tth_file is not None:
+                if not os.path.isabs(tth_file):
+                    detector['tth_file'] = os.path.join(inputdir, tth_file)
+        return detectors
+
+# FIX tth_file/tth_map not updated
+#    @field_validator('detectors')
+#    @classmethod
+#    def validate_tth(cls, detectors, info):
+#        """Validate detector element tth_file field. It may only be
+#        used if StrainAnalysisConfig used par_file.
+#        """
+#        for detector in detectors:
+#            tth_file = detector.tth_file
+#            if tth_file is not None:
+#                if not info.data.get('par_file'):
+#                    raise ValueError(
+#                        'variable tth angles may only be used with a '
+#                        'StrainAnalysisConfig that uses par_file.')
+#                else:
+#                    try:
+#                        detector.tth_map = ParFile(
+#                            info.data['par_file']).map_values(
+#                                info.data['map_config'],
+#                                np.loadtxt(tth_file))
+#                    except Exception as e:
+#                        raise ValueError(
+#                            'Could not get map of tth angles from '
+#                            f'{tth_file}') from e
+#        return detectors
+
+    @field_validator('oversampling')
+    @classmethod
+    def validate_oversampling(cls, oversampling, info):
         """Validate the oversampling field.
 
-        :param value: Field value to validate (`oversampling`).
-        :type value: bool
-        :param values: Dictionary of validated class field values.
-        :type values: dict
+        :param oversampling: The value of `oversampling` to validate.
+        :type oversampling: dict
+        :param info: Pydantic validator info object.
+        :type info: StrainAnalysisConfig,
+            pydantic_core._pydantic_core.ValidationInfo
         :return: The validated value for oversampling.
         :rtype: bool
         """
         # Local modules
         from CHAP.utils.general import is_int
 
-        map_config = values.get('map_config')
+        raise ValueError('oversampling not updated yet')
+        map_config = info.data.get('map_config')
         if map_config is None or map_config.attrs['scan_type'] < 3:
             return None
-        if value is None:
+        if oversampling is None:
             return {'num': 10}
-        if 'start' in value and not is_int(value['start'], ge=0):
+        if 'start' in oversampling and not is_int(oversampling['start'], ge=0):
             raise ValueError('Invalid "start" parameter in "oversampling" '
-                             f'field ({value["start"]})')
-        if 'end' in value and not is_int(value['end'], gt=0):
+                             f'field ({oversampling["start"]})')
+        if 'end' in oversampling and not is_int(oversampling['end'], gt=0):
             raise ValueError('Invalid "end" parameter in "oversampling" '
-                             f'field ({value["end"]})')
-        if 'width' in value and not is_int(value['width'], gt=0):
+                             f'field ({oversampling["end"]})')
+        if 'width' in oversampling and not is_int(oversampling['width'], gt=0):
             raise ValueError('Invalid "width" parameter in "oversampling" '
-                             f'field ({value["width"]})')
-        if 'stride' in value and not is_int(value['stride'], gt=0):
+                             f'field ({oversampling["width"]})')
+        if ('stride' in oversampling
+                and not is_int(oversampling['stride'], gt=0)):
             raise ValueError('Invalid "stride" parameter in "oversampling" '
-                             f'field ({value["stride"]})')
-        if 'num' in value and not is_int(value['num'], gt=0):
+                             f'field ({oversampling["stride"]})')
+        if 'num' in oversampling and not is_int(oversampling['num'], gt=0):
             raise ValueError('Invalid "num" parameter in "oversampling" '
-                             f'field ({value["num"]})')
-        if 'mode' in value and 'mode' not in ('valid', 'full'):
+                             f'field ({oversampling["num"]})')
+        if 'mode' in oversampling and 'mode' not in ('valid', 'full'):
             raise ValueError('Invalid "mode" parameter in "oversampling" '
-                             f'field ({value["mode"]})')
-        if not ('width' in value or 'stride' in value or 'num' in value):
+                             f'field ({oversampling["mode"]})')
+        if not ('width' in oversampling or 'stride' in oversampling
+                or 'num' in oversampling):
             raise ValueError('Invalid input parameters, specify at least one '
                              'of "width", "stride" or "num"')
-        return value
-
-    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))
-                mca_data = np.reshape(
-                    mca_data, (*self.map_config.shape, len(mca_data[0])))
-                if self.sum_axes:
-                    scan_type = self.map_config.attrs['scan_type']
-                    if self.map_config.map_type == 'structured':
-                        sum_axis_indices = []
-                        for axis in self.sum_axes:
-                            sum_axis_indices.append(
-                                self.map_config.dims.index(axis))
-                        mca_data = np.sum(
-                            mca_data, tuple(sorted(sum_axis_indices)))
-                        if scan_type == 4:
-                            raise NotImplementedError(
-                                'Oversampling scan types not tested yet.')
-                            from CHAP.edd.utils import get_rolling_sum_spectra
-                            mca_data = get_rolling_sum_spectra(
-                                mca_data,
-                                self.map_config.dims.index(fly_axis_labels[0]),
-                                self.oversampling.get('start', 0),
-                                self.oversampling.get('end'),
-                                self.oversampling.get('width'),
-                                self.oversampling.get('stride'),
-                                self.oversampling.get('num'),
-                                self.oversampling.get('mode', 'valid'))
-                        elif scan_type not in (0, 1, 2, 3, 5):
-                            raise ValueError(
-                                f'scan_type {scan_type} not implemented yet '
-                                'in StrainAnalysisConfig.mca_data()')
-                    else:
-                        # Perform summing along axes of an unstructured map
-                        map_dims = self.map_config.dims
-                        map_coords = self.map_config.coords
-                        map_length = len(map_coords[map_dims[0]])
-                        for sum_axis in self.sum_axes:
-                            axis_index = map_dims.index(sum_axis)
-                            sum_map_indices = {}
-                            for i in range(map_length):
-                                coord = tuple(
-                                    v[i] for k, v in map_coords.items() \
-                                    if k != sum_axis)
-                                if coord not in sum_map_indices:
-                                    sum_map_indices[coord] = []
-                                sum_map_indices[coord].append(i)
-                            map_dims = (*map_dims[:axis_index],
-                                        *map_dims[axis_index + 1:])
-                            sum_indices_list = sum_map_indices.values()
-                            map_coords = {
-                                dim: [map_coords[dim][sum_indices[0]] \
-                                      for sum_indices in sum_indices_list] \
-                                for dim in map_dims}
-                            map_length = len(map_coords[map_dims[0]])
-                            mca_data = np.asarray(
-                                [np.sum(mca_data[sum_indices], axis=0) \
-                                 for sum_indices in sum_indices_list])
-                    return mca_data
-                else:
-                    return np.asarray(mca_data)
-            else:
-                return self.map_config.get_detector_data(
-                    detector_config.detector_name, map_index)
+        return oversampling
 
     def dict(self, *args, **kwargs):
         """Return a representation of this configuration in a
@@ -1285,9 +1135,9 @@ class StrainAnalysisConfig(BaseModel):
         :rtype: dict
         """
         d = super().dict(*args, **kwargs)
-        for k,v in d.items():
+        for k, v in d.items():
             if isinstance(v, PosixPath):
                 d[k] = str(v)
-        if '_scanparser' in d:
-            del d['_scanparser']
+        if 'inputdir' in d:
+            del d[k]
         return d