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

CHAP/common/models/map.py

@@ -15,16 +15,17 @@ from typing import (
 import numpy as np
 from pydantic import (
     BaseModel,
+    Field,
+    FilePath,
+    PrivateAttr,
     conint,
     conlist,
     constr,
-    FilePath,
-    PrivateAttr,
-    root_validator,
-    validator,
+    field_validator,
+    model_validator,
 )
 from pyspec.file.spec import FileSpec
-
+from typing_extensions import Annotated
 
 class Sample(BaseModel):
     """Class representing a sample metadata configuration.
@@ -35,7 +36,7 @@ class Sample(BaseModel):
     :type description: str, optional
     """
     name: constr(min_length=1)
-    description: Optional[str]
+    description: Optional[str] = ''
 
 
 class SpecScans(BaseModel):
@@ -44,22 +45,23 @@ class SpecScans(BaseModel):
     :ivar spec_file: Path to the SPEC file.
     :type spec_file: str
     :ivar scan_numbers: List of scan numbers to use.
-    :type scan_numbers: list[int]
+    :type scan_numbers: Union(int, list[int], str)
     :ivar par_file: Path to a non-default SMB par file.
     :type par_file: str, optional
     """
     spec_file: FilePath
-    scan_numbers: conlist(item_type=conint(gt=0), min_items=1)
-    par_file: Optional[FilePath]
+    scan_numbers: conlist(item_type=conint(gt=0), min_length=1)
+    par_file: Optional[FilePath] = None
 
-    @validator('spec_file', allow_reuse=True)
-    def validate_spec_file(cls, spec_file, values):
+    @field_validator('spec_file')
+    @classmethod
+    def validate_spec_file(cls, spec_file):
         """Validate the specified SPEC file.
 
         :param spec_file: Path to the SPEC file.
         :type spec_file: str
         :raises ValueError: If the SPEC file is invalid.
-        :return: Absolute path to the SPEC file, if it is valid.
+        :return: Absolute path to the SPEC file.
         :rtype: str
         """
         try:
@@ -69,26 +71,29 @@ class SpecScans(BaseModel):
             raise ValueError(f'Invalid SPEC file {spec_file}')
         return spec_file
 
-    @validator('scan_numbers', pre=True, allow_reuse=True)
-    def validate_scan_numbers(cls, scan_numbers, values):
+    @field_validator('scan_numbers', mode='before')
+    @classmethod
+    def validate_scan_numbers(cls, scan_numbers, info):
         """Validate the specified list of scan numbers.
 
         :param scan_numbers: List of scan numbers.
-        :type scan_numbers: list of int
-        :param values: Dictionary of values for all fields of the model.
-        :type values: dict
+        :type scan_numbers: Union(int, list[int], str)
+        :param info: Pydantic validator info object.
+        :type info: pydantic_core._pydantic_core.ValidationInfo
         :raises ValueError: If a specified scan number is not found in
             the SPEC file.
         :return: List of scan numbers.
-        :rtype: list of int
+        :rtype: list[int]
         """
-        if isinstance(scan_numbers, str):
+        if isinstance(scan_numbers, int):
+            scan_numbers = [scan_numbers]
+        elif isinstance(scan_numbers, str):
             # Local modules
             from CHAP.utils.general import string_to_list
 
             scan_numbers = string_to_list(scan_numbers)
 
-        spec_file = values.get('spec_file')
+        spec_file = info.data.get('spec_file')
         if spec_file is not None:
             spec_scans = FileSpec(spec_file)
             for scan_number in scan_numbers:
@@ -98,14 +103,15 @@ class SpecScans(BaseModel):
                         f'No scan number {scan_number} in {spec_file}')
         return scan_numbers
 
-    @validator('par_file', allow_reuse=True)
-    def validate_par_file(cls, par_file, values):
+    @field_validator('par_file')
+    @classmethod
+    def validate_par_file(cls, par_file):
         """Validate the specified SMB par file.
 
         :param par_file: Path to a non-default SMB par file.
         :type par_file: str
         :raises ValueError: If the SMB par file is invalid.
-        :return: Absolute path to the SMB par file, if it is valid.
+        :return: Absolute path to the SMB par file.
         :rtype: str
         """
         if par_file is None or not par_file:
@@ -157,7 +163,8 @@ class SpecScans(BaseModel):
             coordinate_index = list(
                 map_config.coords[independent_dimension.label]).index(
                     independent_dimension.get_value(
-                        self, scan_number, scan_step_index))
+                        self, scan_number, scan_step_index,
+                        map_config.scalar_data))
             index = (coordinate_index, *index)
         return index
 
@@ -235,10 +242,12 @@ class PointByPointScanData(BaseModel):
     """
     label: constr(min_length=1)
     units: constr(strip_whitespace=True, min_length=1)
-    data_type: Literal['spec_motor', 'scan_column', 'smb_par']
+    data_type: Literal['spec_motor', 'spec_motor_absolute', 'scan_column',
+                       'smb_par', 'expression']
     name: constr(strip_whitespace=True, min_length=1)
 
-    @validator('label')
+    @field_validator('label')
+    @classmethod
     def validate_label(cls, label):
         """Validate that the supplied `label` does not conflict with
         any of the values for `label` reserved for certain data needed
@@ -247,8 +256,7 @@ class PointByPointScanData(BaseModel):
         :param label: The value of `label` to validate.
         :type label: str
         :raises ValueError: If `label` is one of the reserved values.
-        :return: The original supplied value `label`, if it is
-            allowed.
+        :return: The originally supplied value `label`.
         :rtype: str
         """
         if ((not issubclass(cls,CorrectionsData))
@@ -309,8 +317,49 @@ class PointByPointScanData(BaseModel):
                             f'for index {index} '
                             f'in spec file {scans.spec_file}')
 
-    def get_value(self, spec_scans:SpecScans,
-                  scan_number:int, scan_step_index:int=0):
+    def validate_for_scalar_data(self, scalar_data):
+        """Used for `PointByPointScanData` objects with a `data_type`
+        of `'expression'`. Validate that the `scalar_data` field of a
+        `MapConfig` object contains all the items necessary for
+        evaluating the expression.
+
+        :param scalar_data: the `scalar_data` field of a `MapConfig`
+            that this `PointByPointScanData` object will be validated
+            against
+        :type scalar_data: list[PointByPointScanData]
+        :raises ValueError: if `scalar_data` does not contain items
+           needed for evaluating the expression.
+        :return: None
+        """
+        # Third party modules
+        from ast import parse
+        from asteval import get_ast_names
+
+        labels = get_ast_names(parse(self.name))
+        for label in ('round', 'np', 'numpy'):
+            try:
+                labels.remove(label)
+            except:
+                pass
+        for l in labels:
+            if l == 'round':
+                symtable[l] = round
+                continue
+            if l in ('np', 'numpy'):
+                symtable[l] = np
+                continue
+            label_found = False
+            for s_d in scalar_data:
+                if s_d.label == l:
+                    label_found = True
+                    break
+            if not label_found:
+                raise ValueError(
+                    f'{l} is not the label of an item in scalar_data')
+
+    def get_value(
+            self, spec_scans:SpecScans, scan_number:int, scan_step_index:int=0,
+            scalar_data=[], relative=True, ndigits=None):
         """Return the value recorded for this instance of
         `PointByPointScanData` at a specific scan step.
 
@@ -320,18 +369,32 @@ class PointByPointScanData(BaseModel):
         :param scan_number: The number of the scan in which the
             requested scan step occurs.
         :type scan_number: int
-        :param scan_step_index: The index of the requested scan step.
-        :type scan_step_index: int
+        :param scan_step_index: The index of the requested scan step,
+            defaults to `0`.
+        :type scan_step_index: int, optional
+        :param scalar_data: list of scalar data configurations used to
+            get values for `PointByPointScanData` objects with
+            `data_type == 'expression'`, defaults to `[]`.
+        :type scalar_data: list[PointByPointScanData], optional
+        :param relative: Whether to return a relative value or not,
+            defaults to `True` (only applies to SPEC motor values).
+        :type relative: bool, optional
+        :params ndigits: Round SPEC motor values to the specified
+            number of decimals if set, defaults to `None`.
+        :type ndigits: int, optional
         :return: The value recorded of the data represented by this
             instance of `PointByPointScanData` at the scan step
             requested.
         :rtype: float
         """
-        if self.data_type == 'spec_motor':
+        if 'spec_motor' in self.data_type:
+            if 'absolute' in self.data_type:
+                relative = False
             return get_spec_motor_value(spec_scans.spec_file,
                                         scan_number,
                                         scan_step_index,
-                                        self.name)
+                                        self.name,
+                                        relative, ndigits)
         if self.data_type == 'scan_column':
             return get_spec_counter_value(spec_scans.spec_file,
                                           scan_number,
@@ -341,12 +404,19 @@ class PointByPointScanData(BaseModel):
             return get_smb_par_value(spec_scans.spec_file,
                                      scan_number,
                                      self.name)
+        if self.data_type == 'expression':
+            return get_expression_value(spec_scans,
+                                        scan_number,
+                                        scan_step_index,
+                                        self.name,
+                                        scalar_data)
         return None
 
 
 @cache
 def get_spec_motor_value(spec_file:str, scan_number:int,
-                         scan_step_index:int, spec_mnemonic:str):
+                         scan_step_index:int, spec_mnemonic:str,
+                         relative=True, ndigits=None):
     """Return the value recorded for a SPEC motor at a specific scan
     step.
 
@@ -360,6 +430,12 @@ def get_spec_motor_value(spec_file:str, scan_number:int,
     :type scan_step_index: int
     :param spec_mnemonic: The menmonic of a SPEC motor.
     :type spec_mnemonic: str
+    :param relative: Whether to return a relative value or not,
+        defaults to `True`.
+    :type relative: bool, optional
+    :params ndigits: Round SPEC motor values to the specified
+        number of decimals if set, defaults to `None`.
+    :type ndigits: int, optional
     :return: The value of the motor at the scan step requested.
     :rtype: float
     """
@@ -373,11 +449,15 @@ def get_spec_motor_value(spec_file:str, scan_number:int,
                 scanparser.spec_scan_shape,
                 order='F')
             motor_value = \
-                scanparser.spec_scan_motor_vals[motor_i][scan_step[motor_i]]
+                scanparser.get_spec_scan_motor_vals(
+                    relative)[motor_i][scan_step[motor_i]]
         else:
-            motor_value = scanparser.spec_scan_motor_vals[motor_i]
+            motor_value = scanparser.get_spec_scan_motor_vals(
+                relative)[motor_i]
     else:
         motor_value = scanparser.get_spec_positioner_value(spec_mnemonic)
+    if ndigits is not None:
+        motor_value = round(motor_value, 3)
     return motor_value
 
 
@@ -426,24 +506,74 @@ def get_smb_par_value(spec_file:str, scan_number:int, par_name:str):
     return scanparser.pars[par_name]
 
 
-def validate_data_source_for_map_config(data_source, values):
+def get_expression_value(spec_scans:SpecScans, scan_number:int,
+                         scan_step_index:int, expression:str,
+                         scalar_data:list[PointByPointScanData]):
+    """Return the value of an evaluated expression of other sources of
+    point-by-point scalar scan data for a single point.
+
+    :param spec_scans: An instance of `SpecScans` in which the
+        requested scan step occurs.
+    :type spec_scans: SpecScans
+    :param scan_number: The number of the scan in which the requested
+        scan step occurs.
+    :type scan_number: int
+    :param scan_step_index: The index of the requested scan step.
+    :type scan_step_index: int
+    :param expression: the string expression to evaluate
+    :type expression: str
+    :param scalar_data: the `scalar_data` field of a `MapConfig`
+        object (used to provide values for variables used in
+        `expression`)
+    :type scalar_data: list[PointByPointScanData]
+    :return: The value of the .par file value for  the scan requested.
+    :rtype: float
+    """
+    # Third party modules
+    from ast import parse
+    from asteval import get_ast_names, Interpreter
+
+    labels = get_ast_names(parse(expression))
+    symtable = {}
+    for l in labels:
+        if l == 'round':
+            symtable[l] = round
+        for s_d in scalar_data:
+            if s_d.label == l:
+                symtable[l] = s_d.get_value(
+                    spec_scans, scan_number, scan_step_index, scalar_data)
+    aeval = Interpreter(symtable=symtable)
+    return aeval(expression)
+
+def validate_data_source_for_map_config(data_source, info):
     """Confirm that an instance of PointByPointScanData is valid for
     the station and scans provided by a map configuration dictionary.
 
     :param data_source: The input object to validate.
-    :type data_source: PintByPointScanData
-    :param values: The map configuration dictionary.
-    :type values: dict
-    :raises Exception: If `data_source` cannot be validated for
-        `values`.
-    :return: `data_source`, if it is valid.
+    :type data_source: PointByPointScanData
+    :param info: Pydantic validator info object.
+    :type info: pydantic_core._pydantic_core.ValidationInfo
+    :raises Exception: If `data_source` cannot be validated.
+    :return: the validated `data_source` instance.
     :rtype: PointByPointScanData
     """
-    if data_source is not None:
-        import_scanparser(values.get('station'), values.get('experiment_type'))
-        data_source.validate_for_station(values.get('station'))
-        data_source.validate_for_spec_scans(values.get('spec_scans'))
-    return data_source
+    def _validate_data_source_for_map_config(
+            data_source, info, parent_list=None):
+        if isinstance(data_source, list):
+            return [_validate_data_source_for_map_config(
+                d_s, info, parent_list=data_source) for d_s in data_source]
+        if data_source is not None:
+            values = info.data
+            if data_source.data_type == 'expression':
+                data_source.validate_for_scalar_data(values['scalar_data'])
+            else:
+                import_scanparser(
+                    values['station'], values['experiment_type'])
+                data_source.validate_for_station(values['station'])
+                data_source.validate_for_spec_scans(values['spec_scans'])
+        return data_source
+
+    return _validate_data_source_for_map_config(data_source, info)
 
 
 class IndependentDimension(PointByPointScanData):
@@ -476,11 +606,20 @@ class IndependentDimension(PointByPointScanData):
     end: Optional[int] = None
     step: Optional[conint(gt=0)] = 1
 
-#    @validator('step')
-#    def validate_step(cls, value):
-#        if value == 0 :
+#    @field_validator('step')
+#    @classmethod
+#    def validate_step(cls, step):
+#        """Validate that the supplied value of `step`.
+#
+#        :param step: The value of `step` to validate.
+#        :type step: str
+#        :raises ValueError: If `step` is zero.
+#        :return: The originally supplied value `step`.
+#        :rtype: int
+#        """
+#        if step == 0 :
 #            raise ValueError('slice step cannot be zero')
-#        return value
+#        return step
 
 
 class CorrectionsData(PointByPointScanData):
@@ -516,7 +655,7 @@ class CorrectionsData(PointByPointScanData):
         :return: A list of reserved labels.
         :rtype: list[str]
         """
-        return list(cls.__fields__['label'].type_.__args__)
+        return list((*cls.model_fields['label'].annotation.__args__, 'round'))
 
 
 class PresampleIntensity(CorrectionsData):
@@ -588,52 +727,68 @@ class SpecConfig(BaseModel):
     :type spec_scans: list[SpecScans]
     """
     station: Literal['id1a3', 'id3a', 'id3b']
-    experiment_type: Literal['SAXSWAXS', 'EDD', 'XRF', 'TOMO']
-    spec_scans: conlist(item_type=SpecScans, min_items=1)
+    experiment_type: Literal['EDD', 'GIWAXS', 'SAXSWAXS', 'TOMO', 'XRF']
+    spec_scans: conlist(item_type=SpecScans, min_length=1)
 
-    @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
         spec_file filepaths.
 
-        :param values: Dictionary of class field values.
-        :type values: dict
-        :return: The validated list of `values`.
+        :param data: Pydantic validator data object.
+        :type data: SpecConfig, 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:
-            spec_scans = values.get('spec_scans')
+            spec_scans = data.get('spec_scans')
             for i, scans in enumerate(deepcopy(spec_scans)):
-                spec_file = scans['spec_file']
-                if not os.path.isabs(spec_file):
-                    spec_scans[i]['spec_file'] = os.path.join(
-                        inputdir, spec_file)
-                spec_scans[i] = SpecScans(**spec_scans[i], **values)
-            values['spec_scans'] = spec_scans
-        return values
-
-    @validator('experiment_type')
-    def validate_experiment_type(cls, value, values):
+                if isinstance(scans, dict):
+                    spec_file = scans['spec_file']
+                    if not os.path.isabs(spec_file):
+                        spec_scans[i]['spec_file'] = os.path.join(
+                            inputdir, spec_file)
+                else:
+                    spec_file = scans.spec_file
+                    if not os.path.isabs(spec_file):
+                        spec_scans[i].spec_file = os.path.join(
+                            inputdir, spec_file)
+            data['spec_scans'] = spec_scans
+        return data
+
+    @field_validator('experiment_type')
+    @classmethod
+    def validate_experiment_type(cls, experiment_type, info):
         """Ensure values for the station and experiment_type fields are
         compatible
+
+        :param experiment_type: The value of `experiment_type` to
+            validate.
+        :type experiment_type: str
+        :param info: Pydantic validator info object.
+        :type info: pydantic_core._pydantic_core.ValidationInfo
+        :raises ValueError: Invalid experiment type.
+        :return: The validated field for `experiment_type`.
+        :rtype: str
         """
-        station = values.get('station')
+        station = info.data.get('station')
         if station == 'id1a3':
-            allowed_experiment_types = ['SAXSWAXS', 'EDD', 'TOMO']
+            allowed_experiment_types = ['EDD', 'SAXSWAXS', 'TOMO']
         elif station == 'id3a':
             allowed_experiment_types = ['EDD', 'TOMO']
         elif station == 'id3b':
-            allowed_experiment_types = ['SAXSWAXS', 'XRF', 'TOMO']
+            allowed_experiment_types = ['GIWAXS', 'SAXSWAXS', 'TOMO', 'XRF']
         else:
             allowed_experiment_types = []
-        if value not in allowed_experiment_types:
+        if experiment_type not in allowed_experiment_types:
             raise ValueError(
                 f'For station {station}, allowed experiment types are '
                 f'{", ".join(allowed_experiment_types)}. '
-                f'Supplied experiment type {value} is not allowed.')
-        import_scanparser(station, value)
-        return value
+                f'Supplied experiment type {experiment_type} is not allowed.')
+        import_scanparser(station, experiment_type)
+        return experiment_type
 
 
 class MapConfig(BaseModel):
@@ -659,144 +814,159 @@ class MapConfig(BaseModel):
         times for SPEC scans. Required when applying a
         CorrectionConfig tool.
     :type dwell_time_actual: DwellTimeActual, optional
-    :ivar presample_intensity: A source of point-by-point postsample
+    :ivar postsample_intensity: A source of point-by-point postsample
         beam intensity data. Required when applying a CorrectionConfig
         tool with `correction_type='flux_absorption'` or
         `correction_type='flux_absorption_background'`.
-    :type presample_intensity: PresampleIntensity, optional
+    :type postsample_intensity: PresampleIntensity, optional
     :ivar scalar_data: A list of the sources of data representing
         other scalar raw data values collected at each point on the
         map. In the NeXus file representation of the map, datasets for
         these values will be included, defaults to `[]`.
     :type scalar_data: list[PointByPointScanData], optional
-    :ivar map_type: Type of map, structured or unstructured,
-        defaults to `'structured'`.
-    :type map_type: Literal['structured', 'unstructured'], optional
     """
     title: constr(strip_whitespace=True, min_length=1)
     station: Literal['id1a3', 'id3a', 'id3b']
-    experiment_type: Literal['SAXSWAXS', 'EDD', 'XRF', 'TOMO']
+    experiment_type: Literal['EDD', 'GIWAXS', 'SAXSWAXS', 'TOMO', 'XRF']
     sample: Sample
-    spec_scans: conlist(item_type=SpecScans, min_items=1)
-    independent_dimensions: conlist(
-        item_type=IndependentDimension, min_items=1)
-    presample_intensity: Optional[PresampleIntensity]
-    dwell_time_actual: Optional[DwellTimeActual]
-    postsample_intensity: Optional[PostsampleIntensity]
+    spec_scans: conlist(item_type=SpecScans, min_length=1)
     scalar_data: Optional[list[PointByPointScanData]] = []
-    map_type: Optional[Literal['structured', 'unstructured']] = 'structured'
-    _coords: dict = PrivateAttr()
+    independent_dimensions: conlist(
+        item_type=IndependentDimension, min_length=1)
+    presample_intensity: Optional[PresampleIntensity] = None
+    dwell_time_actual: Optional[DwellTimeActual] = None
+    postsample_intensity: Optional[PostsampleIntensity] = None
+    attrs: Optional[Annotated[dict, Field(validate_default=True)]] = {}
+#    _coords: dict = PrivateAttr()
     _dims: tuple = PrivateAttr()
-    _scan_step_indices: list = PrivateAttr()
-    _shape: tuple = PrivateAttr()
-
-    _validate_independent_dimensions = validator(
-        'independent_dimensions',
-        each_item=True,
-        allow_reuse=True)(validate_data_source_for_map_config)
-    _validate_presample_intensity = validator(
-        'presample_intensity',
-        allow_reuse=True)(validate_data_source_for_map_config)
-    _validate_dwell_time_actual = validator(
-        'dwell_time_actual',
-        allow_reuse=True)(validate_data_source_for_map_config)
-    _validate_postsample_intensity = validator(
-        'postsample_intensity',
-        allow_reuse=True)(validate_data_source_for_map_config)
-    _validate_scalar_data = validator(
-        'scalar_data',
-        each_item=True,
-        allow_reuse=True)(validate_data_source_for_map_config)
-
-    @root_validator(pre=True)
-    def validate_config(cls, values):
+#    _scan_step_indices: list = PrivateAttr()
+#    _shape: tuple = PrivateAttr()
+
+    _validate_independent_dimensions = field_validator(
+        'independent_dimensions')(validate_data_source_for_map_config)
+    _validate_presample_intensity = field_validator(
+        'presample_intensity')(validate_data_source_for_map_config)
+    _validate_dwell_time_actual = field_validator(
+        'dwell_time_actual')(validate_data_source_for_map_config)
+    _validate_postsample_intensity = field_validator(
+        'postsample_intensity')(validate_data_source_for_map_config)
+    _validate_scalar_data = field_validator(
+        'scalar_data')(validate_data_source_for_map_config)
+
+    @model_validator(mode='before')
+    @classmethod
+    def validate_config(cls, data):
         """Ensure that a valid configuration was provided and finalize
         spec_file filepaths.
 
-        :param values: Dictionary of class field values.
-        :type values: dict
-        :return: The validated list of `values`.
+        :param data: Pydantic validator data object.
+        :type data:
+            MapConfig, 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:
-            spec_scans = values.get('spec_scans')
+            spec_scans = data.get('spec_scans')
             for i, scans in enumerate(deepcopy(spec_scans)):
                 spec_file = scans['spec_file']
                 if not os.path.isabs(spec_file):
                     spec_scans[i]['spec_file'] = os.path.join(
                         inputdir, spec_file)
-                spec_scans[i] = SpecScans(**spec_scans[i], **values)
-            values['spec_scans'] = spec_scans
-        return values
-
-    @validator('map_type', pre=True, always=True)
-    def validate_map_type(cls, map_type, values):
-        """Validate the map_type field.
-
-        :param map_type: Type of map, structured or unstructured,
-            defaults to `'structured'`.
-        :type map_type: Literal['structured', 'unstructured']]
-        :param values: Dictionary of values for all fields of the model.
-        :type values: dict
-        :return: The validated value for map_type.
-        :rtype: str
-        """
-        dims = {}
-        spec_scans = values.get('spec_scans')
-        independent_dimensions = values.get('independent_dimensions')
-        import_scanparser(values.get('station'), values.get('experiment_type'))
-        for i, dim in enumerate(deepcopy(independent_dimensions)):
-            dims[dim.label] = []
-            for scans in 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):
-                        dims[dim.label].append(dim.get_value(
-                                scans, scan_number, scan_step_index))
-            dims[dim.label] = np.unique(dims[dim.label])
-            if dim.end is None:
-                dim.end = len(dims[dim.label])
-            dims[dim.label] = dims[dim.label][slice(
-                dim.start, dim.end, dim.step)]
-            independent_dimensions[i] = dim
-
-        coords = np.zeros([v.size for v in dims.values()], dtype=np.int64)
-        for scans in 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[tuple([
-                        list(dims[dim.label]).index(
-                            dim.get_value(scans, scan_number, scan_step_index))
-                        for dim in independent_dimensions])] += 1
-        if any(True for v in coords.flatten() if v == 0 or v > 1):
-            return 'unstructured'
-        else:
-            return 'structured'
+                spec_scans[i] = SpecScans(**spec_scans[i], **data)
+            data['spec_scans'] = spec_scans
+        return data
 
-
-    @validator('experiment_type')
-    def validate_experiment_type(cls, value, values):
+    @field_validator('experiment_type')
+    @classmethod
+    def validate_experiment_type(cls, experiment_type, info):
         """Ensure values for the station and experiment_type fields are
-        compatible
+        compatible.
+
+        :param experiment_type: The value of `experiment_type` to
+            validate.
+        :type experiment_type: dict
+        :param info: Pydantic validator info object.
+        :type info: pydantic_core._pydantic_core.ValidationInfo
+        :raises ValueError: Invalid experiment type.
+        :return: The validated field for `experiment_type`.
+        :rtype: str
         """
-        station = values.get('station')
+        station = info.data['station']
         if station == 'id1a3':
-            allowed_experiment_types = ['SAXSWAXS', 'EDD', 'TOMO']
+            allowed_experiment_types = ['EDD', 'SAXSWAXS', 'TOMO']
         elif station == 'id3a':
             allowed_experiment_types = ['EDD', 'TOMO']
         elif station == 'id3b':
-            allowed_experiment_types = ['SAXSWAXS', 'XRF', 'TOMO']
+            allowed_experiment_types = ['GIWAXS', 'SAXSWAXS', 'TOMO', 'XRF']
         else:
             allowed_experiment_types = []
-        if value not in allowed_experiment_types:
+        if experiment_type not in allowed_experiment_types:
             raise ValueError(
                 f'For station {station}, allowed experiment types are '
                 f'{", ".join(allowed_experiment_types)}. '
-                f'Supplied experiment type {value} is not allowed.')
-        return value
+                f'Supplied experiment type {experiment_type} is not allowed.')
+        return experiment_type
+
+    #RV maybe better to use model_validator, see v2 docs?
+    @field_validator('attrs')
+    @classmethod
+    def validate_attrs(cls, attrs, info):
+        """Read any additional attributes depending on the values for
+        the station and experiment_type fields.
+
+        :param attrs: Any additional attributes to the MapConfig class.
+        :type attrs: dict
+        :param info: Pydantic validator info object.
+        :type info: pydantic_core._pydantic_core.ValidationInfo
+        :raises ValueError: Invalid attribute.
+        :return: The validated field for `attrs`.
+        :rtype: dict
+        """
+        # Get the map's scan_type for EDD experiments
+        values = info.data
+        station = values['station']
+        experiment_type = values['experiment_type']
+        if station in ['id1a3', 'id3a'] and experiment_type == 'EDD':
+            attrs['scan_type'] = cls.get_smb_par_attr(values, 'scan_type')
+            attrs['config_id'] = cls.get_smb_par_attr(values, 'config_id')
+            attrs['dataset_id'] = cls.get_smb_par_attr(values, 'dataset_id')
+            axes_labels = {1: 'fly_labx', 2: 'fly_laby', 3: 'fly_labz',
+                           4: 'fly_ometotal'}
+            if attrs['scan_type'] is None:
+                return attrs
+            if attrs['scan_type'] != 0:
+                attrs['fly_axis_labels'] = [
+                    axes_labels[cls.get_smb_par_attr(values, 'fly_axis0')]]
+            if attrs['scan_type'] in (2, 3, 5):
+                attrs['fly_axis_labels'].append(
+                    axes_labels[cls.get_smb_par_attr(values, 'fly_axis1')])
+        return attrs
+
+    @staticmethod
+    def get_smb_par_attr(class_fields, label, units='-', name=None):
+        """Read an SMB par file attribute."""
+        if name is None:
+            name = label
+        scalar_data = PointByPointScanData(
+            label=label, data_type='smb_par', units=units, name=name)
+        values = []
+        for scans in class_fields.get('spec_scans'):
+            for scan_number in scans.scan_numbers:
+                scanparser = scans.get_scanparser(scan_number)
+                try:
+                    values.append(scanparser.pars[name])
+                except:
+                    print(
+                        f'Warning: No value found for .par file value "{name}"'
+                        f' on scan {scan_number} in spec file '
+                        f'{scans.spec_file}.')
+                    values.append(None)
+        values = list(set(values))
+        if len(values) != 1:
+            raise ValueError(f'More than one {name} in map not allowed '
+                             f'({values})')
+        return values[0]
 
     @property
     def all_scalar_data(self):
@@ -817,9 +987,18 @@ class MapConfig(BaseModel):
         """Return a dictionary of the values of each independent
         dimension across the map.
         """
+        raise RuntimeError(f'property coords not implemented')
         if not hasattr(self, '_coords'):
+            scan_type = self.attrs.get('scan_type', -1)
+            fly_axis_labels = self.attrs.get('fly_axis_labels', [])
             coords = {}
             for dim in self.independent_dimensions:
+                if dim.label in fly_axis_labels:
+                    relative = True
+                    ndigits = 3
+                else:
+                    relative = False
+                    ndigits = None
                 coords[dim.label] = []
                 for scans in self.spec_scans:
                     for scan_number in scans.scan_numbers:
@@ -827,7 +1006,8 @@ class MapConfig(BaseModel):
                         for scan_step_index in range(
                                 scanparser.spec_scan_npts):
                             coords[dim.label].append(dim.get_value(
-                                    scans, scan_number, scan_step_index))
+                                    scans, scan_number, scan_step_index,
+                                    self.scalar_data, relative, ndigits))
                 if self.map_type == 'structured':
                     coords[dim.label] = np.unique(coords[dim.label])
             self._coords = coords
@@ -839,8 +1019,7 @@ class MapConfig(BaseModel):
         map.
         """
         if not hasattr(self, '_dims'):
-            self._dims = [
-                dim.label for dim in self.independent_dimensions[::-1]]
+            self._dims = [dim.label for dim in self.independent_dimensions]
         return self._dims
 
     @property
@@ -849,6 +1028,7 @@ class MapConfig(BaseModel):
         object, the scan number, and scan step index for every point
         on the map.
         """
+        raise RuntimeError(f'property scan_step_indices not implemented')
         if not hasattr(self, '_scan_step_indices'):
             scan_step_indices = []
             for scans in self.spec_scans:
@@ -865,10 +1045,10 @@ class MapConfig(BaseModel):
         """Return the shape of the map -- a tuple representing the
         number of unique values of each dimension across the map.
         """
+        raise RuntimeError(f'property shape not implemented')
         if not hasattr(self, '_shape'):
             if self.map_type == 'structured':
-                self._shape = tuple(
-                    [len(v) for k, v in self.coords.items()][::-1])
+                self._shape = tuple([len(v) for k, v in self.coords.items()])
             else:
                 self._shape =  (len(self.scan_step_indices),) 
         return self._shape
@@ -882,7 +1062,16 @@ class MapConfig(BaseModel):
         :return: A list of coordinate values.
         :rtype: dict
         """
+        raise RuntimeError(f'get_coords not implemented')
         if self.map_type == 'structured':
+            scan_type = self.attrs.get('scan_type', -1)
+            fly_axis_labels = self.attrs.get('fly_axis_labels', [])
+            if (scan_type in (3, 5)
+                    and len(self.dims) == 
+                        len(map_index) + len(fly_axis_labels)):
+                dims = [dim for dim in self.dims if dim not in fly_axis_labels]
+                return {dim:self.coords[dim][i]
+                        for dim, i in zip(dims, map_index)}
             return {dim:self.coords[dim][i]
                     for dim, i in zip(self.dims, map_index)}
         else:
@@ -901,6 +1090,7 @@ class MapConfig(BaseModel):
         :return: One frame of raw detector data.
         :rtype: np.ndarray
         """
+        raise RuntimeError(f'get_detector_data not implemented')
         scans, scan_number, scan_step_index = \
             self.get_scan_step_index(map_index)
         scanparser = scans.get_scanparser(scan_number)
@@ -917,12 +1107,22 @@ class MapConfig(BaseModel):
             step index.
         :rtype: tuple[SpecScans, int, int]
         """
+        raise RuntimeError(f'get_scan_step_index not implemented')
+        scan_type = self.attrs.get('scan_type', -1)
+        fly_axis_labels = self.attrs.get('fly_axis_labels', [])
         if self.map_type == 'structured':
             map_coords = self.get_coords(map_index)
             for scans, scan_number, scan_step_index in self.scan_step_indices:
-                coords = {dim.label:dim.get_value(
-                               scans, scan_number, scan_step_index)
-                           for dim in self.independent_dimensions}
+                coords = {dim.label:(
+                              dim.get_value(
+                                  scans, scan_number, scan_step_index,
+                                  self.scalar_data, True, 3)
+                              if dim.label in fly_axis_labels
+                              else
+                              dim.get_value(
+                                  scans, scan_number, scan_step_index,
+                                  self.scalar_data))
+                          for dim in self.independent_dimensions}
                 if coords == map_coords:
                     return scans, scan_number, scan_step_index
             raise RuntimeError(f'Unable to match coordinates {coords}')
@@ -940,9 +1140,11 @@ class MapConfig(BaseModel):
         :type map_index: tuple
         :return: Raw data value.
         """
+        raise RuntimeError(f'get_value not implemented')
         scans, scan_number, scan_step_index = \
             self.get_scan_step_index(map_index)
-        return data.get_value(scans, scan_number, scan_step_index)
+        return data.get_value(scans, scan_number, scan_step_index,
+                              self.scalar_data)
 
 
 def import_scanparser(station, experiment):
@@ -954,40 +1156,9 @@ def import_scanparser(station, experiment):
     :type station: str
     :param experiment: The experiment type.
     :type experiment: Literal[
-        'SAXSWAXS', 'EDD', 'XRF', 'Tomo', 'Powder']
+        'EDD', 'GIWAXS', 'SAXSWAXS', 'TOMO', 'XRF']
     """
-
-    station = station.lower()
-    experiment = experiment.lower()
-
     # Local modules
-    if station in ('id1a3', 'id3a'):
-        if experiment in ('saxswaxs', 'powder'):
-            from CHAP.utils.scanparsers \
-                import SMBLinearScanParser as ScanParser
-        elif experiment == 'edd':
-            from CHAP.utils.scanparsers \
-                import SMBMCAScanParser as ScanParser
-        elif experiment == 'tomo':
-            from CHAP.utils.scanparsers \
-                import SMBRotationScanParser as ScanParser
-        else:
-            raise ValueError(
-                f'Invalid experiment type for station {station}: {experiment}')
-    elif station == 'id3b':
-        if experiment == 'saxswaxs':
-            from CHAP.utils.scanparsers \
-                import FMBSAXSWAXSScanParser as ScanParser
-        elif experiment == 'tomo':
-            from CHAP.utils.scanparsers \
-                import FMBRotationScanParser as ScanParser
-        elif experiment == 'xrf':
-            from CHAP.utils.scanparsers \
-                import FMBXRFScanParser as ScanParser
-        else:
-            raise ValueError(
-                f'Invalid experiment type for station {station}: {experiment}')
-    else:
-        raise ValueError(f'Invalid station: {station}')
+    from chess_scanparsers import choose_scanparser
 
-    globals()['ScanParser'] = ScanParser
+    globals()['ScanParser'] = choose_scanparser(station, experiment)