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

CHAP/utils/scanparsers.py

@@ -2,6 +2,38 @@
 
 # -*- coding: utf-8 -*-
 
+"""Parsing data from certain CHESS SPEC scans is supported by a family
+of classes derived from the base class, `ScanParser` (defined
+below). An instance of `ScanParser` represents a single SPEC scan --
+each instance is initialized with the name of a specific spec file and
+integer scan number. Access to certain data collected by that scan
+(counter data, positioner values, scan shape, detector data, etc.) are
+made available through the properties and methods of that object.
+
+`ScanParser` is just an incomplete abstraction -- one should not
+declare or work with an instance of `ScanParser` directly. Instead,
+one must find the appropriate concrete subclass to use for the
+particular type of scan one wishes to parse, then declare an instance
+of that specific class to begin accessing data from that scan.
+
+Basic usage examples:
+1. Print out the position of a the SPEC positioner motor with mnemonic
+`'mne0'` for a SAXS/WAXS scan collected at FMB:
+    ```python
+    from CHAP.utils.scanparsers import FMBSAXSWAXSScanParser
+    sp = FMBSAXSWAXSScanParser('/path/to/fmb/saxswaxs/spec/file', 1)
+    print(sp.get_spec_positioner_value('mne0'))
+    ```
+1. Store all the detector data collected by the detector with prefix
+`'det'` over a rotation series collected at SMB in the variable
+`data`:
+    ```python
+    from CHAP.utils.scanparsers import SMBRotationScanParser
+    sp = SMBRotationScanParser('/path/to/smb/rotation/spec/file', 1)
+    data = sp.get_detector_data('det')
+    ```
+"""
+
 # System modules
 from csv import reader
 from fnmatch import filter as fnmatch_filter
@@ -15,6 +47,9 @@ import numpy as np
 from pyspec.file.spec import FileSpec
 from pyspec.file.tiff import TiffFile
 
+@cache
+def filespec(spec_file_name):
+    return FileSpec(spec_file_name)
 
 class ScanParser:
     """Partial implementation of a class representing a SPEC scan and
@@ -55,6 +90,7 @@ class ScanParser:
                     and len(scanparser.spec_args) == 5):
                 self._rams4_args = scanparser.spec_args
 
+    def __repr_(self):
         return (f'{self.__class__.__name__}'
                 f'({self.spec_file_name}, {self.scan_number}) '
                 f'-- {self.spec_command}')
@@ -64,7 +100,7 @@ class ScanParser:
         # NB This FileSpec instance is not stored as a private
         # attribute because it cannot be pickled (and therefore could
         # cause problems for parallel code that uses ScanParsers).
-        return FileSpec(self.spec_file_name)
+        return filespec(self.spec_file_name)
 
     @property
     def scan_path(self):
@@ -300,6 +336,7 @@ class SMBScanParser(ScanParser):
 
         self._pars = None
         self._par_file_pattern = f'*-*-{self.scan_name}'
+        self._par_file = None
 
     def get_scan_name(self):
         return os.path.basename(self.scan_path)
@@ -323,6 +360,10 @@ class SMBScanParser(ScanParser):
         json_files = fnmatch_filter(
             os.listdir(self.scan_path),
             f'{self._par_file_pattern}.json')
+        if not json_files:
+            json_files = fnmatch_filter(
+                os.listdir(self.scan_path),
+                f'*.json')
         if len(json_files) != 1:
             raise RuntimeError(f'{self.scan_title}: cannot find the '
                                '.json file to decode the .par file')
@@ -336,15 +377,20 @@ class SMBScanParser(ScanParser):
             raise RuntimeError(f'{self.scan_title}: cannot find scan pars '
                                'without a "SCAN_N" column in the par file')
 
-        par_files = fnmatch_filter(
-            os.listdir(self.scan_path),
-            f'{self._par_file_pattern}.par')
-        if len(par_files) != 1:
-            raise RuntimeError(f'{self.scan_title}: cannot find the .par '
-                               'file for this scan directory')
+        if getattr(self, '_par_file'):
+            par_file = self._par_file
+        else:
+            par_files = fnmatch_filter(
+                os.listdir(self.scan_path),
+                f'{self._par_file_pattern}.par')
+            if len(par_files) != 1:
+                raise RuntimeError(f'{self.scan_title}: cannot find the .par '
+                                   'file for this scan directory')
+            par_file = os.path.join(self.scan_path, par_files[0])
+            self._par_file = par_file
         par_dict = None
-        with open(os.path.join(self.scan_path, par_files[0])) as par_file:
-            par_reader = reader(par_file, delimiter=' ')
+        with open(par_file) as f:
+            par_reader = reader(f, delimiter=' ')
             for row in par_reader:
                 if len(row) == len(par_col_names):
                     row_scann = int(row[scann_col_idx])
@@ -362,22 +408,21 @@ class SMBScanParser(ScanParser):
                                 except:
                                     pass
                             par_dict[par_col_name] = par_value
-
         if par_dict is None:
             raise RuntimeError(f'{self.scan_title}: could not find scan pars '
                                f'for scan number {self.scan_number}')
         return par_dict
 
     def get_counter_gain(self, counter_name):
-        """Return the gain of a counter as recorded in the comments of
-        a scan in a SPEC file converted to nA/V.
+        """Return the gain of a counter as recorded in the user lines
+        of a scan in a SPEC file converted to nA/V.
 
         :param counter_name: the name of the counter
         :type counter_name: str
         :rtype: str
         """
         counter_gain = None
-        for comment in self.spec_scan.comments:
+        for comment in self.spec_scan.comments + self.spec_scan.user_lines:
             match = re.search(
                 f'{counter_name} gain: '  # start of counter gain comments
                 '(?P<gain_value>\d+) '  # gain numerical value
@@ -388,6 +433,7 @@ class SMBScanParser(ScanParser):
                 gain_scalar = 1 if unit_prefix == 'n' \
                     else 1e3 if unit_prefix == 'u' else 1e6
                 counter_gain = f'{float(match["gain_value"])*gain_scalar} nA/V'
+                break
 
         if counter_gain is None:
             raise RuntimeError(f'{self.scan_title}: could not get gain for '
@@ -404,6 +450,7 @@ class LinearScanParser(ScanParser):
 
         self._spec_scan_motor_mnes = None
         self._spec_scan_motor_vals = None
+        self._spec_scan_motor_vals_relative = None
         self._spec_scan_shape = None
         self._spec_scan_dwell = None
 
@@ -416,9 +463,17 @@ class LinearScanParser(ScanParser):
     @property
     def spec_scan_motor_vals(self):
         if self._spec_scan_motor_vals is None:
-            self._spec_scan_motor_vals = self.get_spec_scan_motor_vals()
+            self._spec_scan_motor_vals = self.get_spec_scan_motor_vals(
+                relative=False)
         return self._spec_scan_motor_vals
 
+    @property
+    def spec_scan_motor_vals_relative(self):
+        if self._spec_scan_motor_vals_relative is None:
+            self._spec_scan_motor_vals_relative = \
+                self.get_spec_scan_motor_vals(relative=True)
+        return self._spec_scan_motor_vals_relative
+
     @property
     def spec_scan_shape(self):
         if self._spec_scan_shape is None:
@@ -442,13 +497,17 @@ class LinearScanParser(ScanParser):
         """
         raise NotImplementedError
 
-    def get_spec_scan_motor_vals(self):
+    def get_spec_scan_motor_vals(self, relative=False):
         """Return the values visited by each of the scanned motors. If
         there is more than one motor scanned (in a "flymesh" scan, for
         example), the order of motor values in the returned tuple will
         go from the fastest moving motor's values first to the slowest
         moving motor's values last.
 
+        :param relative: If `True`, return scanned motor positions
+            *relative* to the scanned motors' positions before the scan
+            started, defaults to False.
+        :type relative: bool, optional
         :rtype: tuple
         """
         raise NotImplementedError
@@ -531,7 +590,7 @@ class FMBLinearScanParser(LinearScanParser, FMBScanParser):
     """
 
     def get_spec_scan_motor_mnes(self):
-        if self.spec_macro == 'flymesh':
+        if self.spec_macro in ('flymesh', 'mesh', 'flydmesh', 'dmesh'):
             m1_mne = self.spec_args[0]
             try:
                 # Try post-summer-2022 format
@@ -543,15 +602,15 @@ class FMBLinearScanParser(LinearScanParser, FMBScanParser):
                 m2_mne_i = 5
             m2_mne = self.spec_args[m2_mne_i]
             return (m1_mne, m2_mne)
-        if self.spec_macro in ('flyscan', 'ascan'):
+        if self.spec_macro in ('flyscan', 'ascan', 'flydscan', 'dscan'):
             return (self.spec_args[0],)
         if self.spec_macro in ('tseries', 'loopscan'):
             return ('Time',)
         raise RuntimeError(f'{self.scan_title}: cannot determine scan motors '
                            f'for scans of type {self.spec_macro}')
 
-    def get_spec_scan_motor_vals(self):
-        if self.spec_macro == 'flymesh':
+    def get_spec_scan_motor_vals(self, relative=False):
+        if self.spec_macro in ('flymesh', 'mesh', 'flydmesh', 'dmesh'):
             m1_start = float(self.spec_args[1])
             m1_end = float(self.spec_args[2])
             m1_npt = int(self.spec_args[3]) + 1
@@ -572,19 +631,27 @@ class FMBLinearScanParser(LinearScanParser, FMBScanParser):
             m2_npt = int(self.spec_args[m2_nint_i]) + 1
             fast_mot_vals = np.linspace(m1_start, m1_end, m1_npt)
             slow_mot_vals = np.linspace(m2_start, m2_end, m2_npt)
+            if relative:
+                fast_mot_vals -= self.get_spec_positioner_value(
+                    self.spec_scan_motor_mnes[0])
+                slow_mot_vals -= self.get_spec_positioner_value(
+                    self.spec_scan_motor_mnes[1])
             return (fast_mot_vals, slow_mot_vals)
-        if self.spec_macro in ('flyscan', 'ascan'):
+        if self.spec_macro in ('flyscan', 'ascan', 'flydscan', 'dscan'):
             mot_vals = np.linspace(float(self.spec_args[1]),
                                    float(self.spec_args[2]),
                                    int(self.spec_args[3])+1)
+            if relative:
+                mot_vals -= self.get_spec_positioner_value(
+                    self.spec_scan_motor_mnes[0])
             return (mot_vals,)
         if self.spec_macro in ('tseries', 'loopscan'):
-            return self.spec_scan.data[:,0]
+            return (self.spec_scan.data[:,0],)
         raise RuntimeError(f'{self.scan_title}: cannot determine scan motors '
                            f'for scans of type {self.spec_macro}')
 
     def get_spec_scan_shape(self):
-        if self.spec_macro == 'flymesh':
+        if self.spec_macro in ('flymesh', 'mesh', 'flydmesh', 'dmesh'):
             fast_mot_npts = int(self.spec_args[3]) + 1
             try:
                 # Try post-summer-2022 format
@@ -596,16 +663,16 @@ class FMBLinearScanParser(LinearScanParser, FMBScanParser):
                 m2_nint_i = 8
             slow_mot_npts = int(self.spec_args[m2_nint_i]) + 1
             return (fast_mot_npts, slow_mot_npts)
-        if self.spec_macro in ('flyscan', 'ascan'):
+        if self.spec_macro in ('flyscan', 'ascan', 'flydscan', 'dscan'):
             mot_npts = int(self.spec_args[3])+1
             return (mot_npts,)
         if self.spec_macro in ('tseries', 'loopscan'):
-            return len(np.array(self.spec_scan.data[:,0]))
+            return (len(np.array(self.spec_scan.data[:,0])),)
         raise RuntimeError(f'{self.scan_title}: cannot determine scan shape '
                            f'for scans of type {self.spec_macro}')
 
     def get_spec_scan_dwell(self):
-        if self.macro == 'flymesh':
+        if self.macro in ('flymesh', 'mesh', 'flydmesh', 'dmesh'):
             try:
                 # Try post-summer-2022 format
                 dwell = float(self.spec_args[4])
@@ -613,7 +680,7 @@ class FMBLinearScanParser(LinearScanParser, FMBScanParser):
                 # Accommodate pre-summer-2022 format
                 dwell = float(self.spec_args[8])
             return dwell
-        if self.spec_macro in ('flyscan', 'ascan'):
+        if self.spec_macro in ('flyscan', 'ascan', 'flydscan', 'dscan'):
             return float(self.spec_args[4])
         if self.spec_macro in ('tseries', 'loopscan'):
             return float(self.spec_args[1])
@@ -656,14 +723,28 @@ class FMBSAXSWAXSScanParser(FMBLinearScanParser):
     def get_detector_data_file(self, detector_prefix, scan_step_index:int):
         detector_files = list_fmb_saxswaxs_detector_files(
             self.detector_data_path, detector_prefix)
-        return os.path.join(
-            self.detector_data_path, detector_files[scan_step_index])
+        if len(detector_files) == self.spec_scan_npts:
+            return os.path.join(
+                self.detector_data_path, detector_files[scan_step_index])
+        else:
+            scan_step = self.get_scan_step(scan_step_index)
+            for f in detector_files:
+                filename, _ = os.path.splitext(f)
+                file_indices = tuple(
+                    [int(i) for i in \
+                     filename.split('_')[-len(self.spec_scan_shape):]])
+                if file_indices == scan_step:
+                    return os.path.join(self.detector_data_path, f)
+            raise RuntimeError(
+                'Could not find a matching detector data file for detector '
+                + f'{detector_prefix} at scan step index {scan_step_index}')
 
     def get_detector_data(self, detector_prefix, scan_step_index:int):
+        import fabio
         image_file = self.get_detector_data_file(detector_prefix,
                                                  scan_step_index)
-        with TiffFile(image_file) as tiff_file:
-            image_data = tiff_file.asarray()
+        with fabio.open(image_file) as det_file:
+            image_data = det_file.data
         return image_data
 
 
@@ -704,7 +785,15 @@ class SMBLinearScanParser(LinearScanParser, SMBScanParser):
     """
 
     def get_spec_scan_dwell(self):
-        if self.spec_macro in ('flymesh', 'flyscan', 'ascan'):
+        if self.spec_macro in ('flymesh', 'mesh', 'flydmesh', 'dmesh'):
+            try:
+                # Try post-summer-2022 format
+                dwell = float(self.spec_args[4])
+            except:
+                # Accommodate pre-summer-2022 format
+                dwell = float(self.spec_args[8])
+            return dwell
+        if self.spec_macro in ('flyscan', 'ascan', 'flydscan', 'dscan'):
             return float(self.spec_args[4])
         if self.spec_macro == 'tseries':
             return float(self.spec_args[1])
@@ -714,55 +803,87 @@ class SMBLinearScanParser(LinearScanParser, SMBScanParser):
                            f'for scans of type {self.spec_macro}')
 
     def get_spec_scan_motor_mnes(self):
-        if self.spec_macro == 'flymesh':
-            return (self.spec_args[0], self.spec_args[5])
-        if self.spec_macro in ('flyscan', 'ascan'):
+        if self.spec_macro in ('flymesh', 'mesh', 'flydmesh', 'dmesh'):
+            m1_mne = self.spec_args[0]
+            try:
+                # Try post-summer-2022 format
+                dwell = float(self.spec_args[4])
+            except:
+                # Accommodate pre-summer-2022 format
+                m2_mne_i = 4
+            else:
+                m2_mne_i = 5
+            m2_mne = self.spec_args[m2_mne_i]
+            return (m1_mne, m2_mne)
+        if self.spec_macro in ('flyscan', 'ascan', 'flydscan', 'dscan'):
             return (self.spec_args[0],)
         if self.spec_macro in ('tseries', 'loopscan'):
             return ('Time',)
         raise RuntimeError(f'{self.scan_title}: cannot determine scan motors '
                            f'for scans of type {self.spec_macro}')
 
-    def get_spec_scan_motor_vals(self):
-        if self.spec_macro == 'flymesh':
-            fast_mot_vals = np.linspace(float(self.spec_args[1]),
-                                        float(self.spec_args[2]),
-                                        int(self.spec_args[3])+1)
-            slow_mot_vals = np.linspace(float(self.spec_args[6]),
-                                        float(self.spec_args[7]),
-                                        int(self.spec_args[8])+1)
+    def get_spec_scan_motor_vals(self, relative=False):
+        if self.spec_macro in ('flymesh', 'mesh', 'flydmesh', 'dmesh'):
+            m1_start = float(self.spec_args[1])
+            m1_end = float(self.spec_args[2])
+            m1_npt = int(self.spec_args[3]) + 1
+            try:
+                # Try post-summer-2022 format
+                dwell = float(self.spec_args[4])
+            except:
+                # Accommodate pre-summer-2022 format
+                m2_start_i = 5
+                m2_end_i = 6
+                m2_nint_i = 7
+            else:
+                m2_start_i = 6
+                m2_end_i = 7
+                m2_nint_i = 8
+            m2_start = float(self.spec_args[m2_start_i])
+            m2_end = float(self.spec_args[m2_end_i])
+            m2_npt = int(self.spec_args[m2_nint_i]) + 1
+            fast_mot_vals = np.linspace(m1_start, m1_end, m1_npt)
+            slow_mot_vals = np.linspace(m2_start, m2_end, m2_npt)
+            if relative:
+                fast_mot_vals -= self.spec_positioner_values[
+                    self.spec_scan_motor_mnes[0]]
+                slow_mot_vals -= self.spec_positioner_values[
+                    self.spec_scan_motor_mnes[1]]
             return (fast_mot_vals, slow_mot_vals)
-        if self.spec_macro in ('flyscan', 'ascan'):
+        if self.spec_macro in ('flyscan', 'ascan', 'flydscan', 'dscan'):
             mot_vals = np.linspace(float(self.spec_args[1]),
                                    float(self.spec_args[2]),
                                    int(self.spec_args[3])+1)
+            if relative:
+                mot_vals -= self.get_spec_positioner_value(
+                    self.spec_scan_motor_mnes[0])
             return (mot_vals,)
         if self.spec_macro in ('tseries', 'loopscan'):
-            return self.spec_scan.data[:,0]
+            return (self.spec_scan.data[:,0],)
         raise RuntimeError(f'{self.scan_title}: cannot determine scan motors '
                            f'for scans of type {self.spec_macro}')
 
     def get_spec_scan_shape(self):
-        if self.spec_macro == 'flymesh':
-            fast_mot_npts = int(self.spec_args[3])+1
-            slow_mot_npts = int(self.spec_args[8])+1
+        if self.spec_macro in ('flymesh', 'mesh', 'flydmesh', 'dmesh'):
+            fast_mot_npts = int(self.spec_args[3]) + 1
+            try:
+                # Try post-summer-2022 format
+                dwell = float(self.spec_args[4])
+            except:
+                # Accommodate pre-summer-2022 format
+                m2_nint_i = 7
+            else:
+                m2_nint_i = 8
+            slow_mot_npts = int(self.spec_args[m2_nint_i]) + 1
             return (fast_mot_npts, slow_mot_npts)
-        if self.spec_macro in ('flyscan', 'ascan'):
+        if self.spec_macro in ('flyscan', 'ascan', 'flydscan', 'dscan'):
             mot_npts = int(self.spec_args[3])+1
             return (mot_npts,)
         if self.spec_macro in ('tseries', 'loopscan'):
-            return len(np.array(self.spec_scan.data[:,0]))
+            return (len(np.array(self.spec_scan.data[:,0])),)
         raise RuntimeError(f'{self.scan_title}: cannot determine scan shape '
                            f'for scans of type {self.spec_macro}')
 
-    def get_spec_scan_dwell(self):
-        if self.spec_macro == 'flymesh':
-            return float(self.spec_args[4])
-        if self.spec_macro in ('flyscan', 'ascan'):
-            return float(self.spec_args[-1])
-        raise RuntimeError(f'{self.scan_title}: cannot determine dwell time '
-                           f'for scans of type {self.spec_macro}')
-
     def get_detector_data_path(self):
         return os.path.join(self.scan_path, str(self.scan_number))
 
@@ -963,12 +1084,14 @@ class SMBRotationScanParser(RotationScanParser, SMBScanParser):
     with the typical tomography setup at SMB.
     """
 
-    def __init__(self, spec_file_name, scan_number):
+    def __init__(self, spec_file_name, scan_number, par_file=None):
         self._scan_type = None
         super().__init__(spec_file_name, scan_number)
 
         self._katefix = 0  # RV remove when no longer needed
         self._par_file_pattern = f'id*-*tomo*-{self.scan_name}'
+        if par_file is not None:
+            self._par_file = par_file
 
     @property
     def scan_type(self):
@@ -1038,7 +1161,8 @@ class SMBRotationScanParser(RotationScanParser, SMBScanParser):
         if os.path.isfile(file_name_full):
             return file_name_full
         raise RuntimeError(f'{self.scan_title}: could not find detector image '
-                           f'file for scan step ({scan_step_index})')
+                           f'file ({file_name_full}) for scan step '
+                           f'({scan_step_index})')
 
     def get_detector_data(self, detector_prefix, scan_step_index=None):
         if scan_step_index is None:
@@ -1090,10 +1214,101 @@ class SMBMCAScanParser(MCAScanParser, SMBLinearScanParser):
     """Concrete implementation of a class representing a scan taken
     with the typical EDD setup at SMB or FAST.
     """
+    detector_data_formats = ('spec', 'h5')
+    def __init__(self, spec_file_name, scan_number, detector_data_format=None):
+        """Constructor for SMBMCAScnaParser.
+
+        :param spec_file: Path to scan's SPEC file
+        :type spec_file: str
+        :param scan_number: Number of the SPEC scan
+        :type scan_number: int
+        :param detector_data_format: Format of the MCA data collected,
+            defaults to None
+        :type detector_data_format: Optional[Literal["spec", "h5"]]
+        """
+        super().__init__(spec_file_name, scan_number)
 
-    def get_detector_num_bins(self, detector_prefix):
-        with open(self.get_detector_data_file(detector_prefix)) \
-             as detector_file:
+        self.detector_data_format = None
+        if detector_data_format is None:
+            self.init_detector_data_format()
+        else:
+            if detector_data_format.lower() in self.detector_data_formats:
+                self.detector_data_format = detector_data_format.lower()
+            else:
+                raise ValueError(
+                    'Unrecognized value for detector_data_format: '
+                    + f'{detector_data_format}. Allowed values are: '
+                    + ', '.join(self.detector_data_formats))
+
+    def get_spec_scan_motor_vals(self, relative=True):
+        if not relative:
+            # The scanned motor's recorded position in the spec.log
+            # file's "#P" lines does not always give the right offset
+            # to use to obtain absolute motor postions from relative
+            # motor positions (or relative from actual). Sometimes,
+            # the labx/y/z/ometotal value from the scan's .par file is
+            # the quantity for the offset that _should_ be used, but
+            # there is currently no consistent way to determine when
+            # to use the labx/y/z/ometotal .par file value and when to
+            # use the spec file "#P" lines value. Because the relative
+            # motor values are the only ones currently used in EDD
+            # workflows, obtain them from relevant values available in
+            # the .par file, and defer implementation for absolute
+            # motor postions to later.
+            return super().get_spec_scan_motor_vals(relative=True)
+            # raise NotImplementedError('Only relative motor values are available.')
+        if self.spec_macro in ('flymesh', 'mesh', 'flydmesh', 'dmesh'):
+            mot_vals_axis0 = np.linspace(self.pars['fly_axis0_start'],
+                                         self.pars['fly_axis0_end'],
+                                         self.pars['fly_axis0_npts'])
+            mot_vals_axis1 = np.linspace(self.pars['fly_axis1_start'],
+                                         self.pars['fly_axis1_end'],
+                                         self.pars['fly_axis1_npts'])
+            return (mot_vals_axis0, mot_vals_axis1)
+        if self.spec_macro in ('flyscan', 'ascan', 'flydscan', 'dscan'):
+            mot_vals = np.linspace(self.pars['fly_axis0_start'],
+                                   self.pars['fly_axis0_end'],
+                                   self.pars['fly_axis0_npts'])
+            return (mot_vals,)
+        if self.spec_macro in ('tseries', 'loopscan'):
+            return (self.spec_scan.data[:,0],)
+        raise RuntimeError(f'{self.scan_title}: cannot determine scan motors '
+                           f'for scans of type {self.spec_macro}')
+
+    def init_detector_data_format(self):
+        """Determine and set a value for the instance variable
+        `detector_data_format` based on the presence / absence of
+        detector data files of different formats conventionally
+        associated with this scan. Also set the corresponding
+        appropriate value for `_detector_data_path`.
+        """
+        try:
+            self._detector_data_path = self.scan_path
+            detector_file = self.get_detector_data_file_spec()
+        except OSError:
+            try:
+                self._detector_data_path = os.path.join(
+                    self.scan_path, str(self.scan_number), 'edd')
+                detector_file = self.get_detector_data_file_h5()
+            except OSError:
+                raise RuntimeError(
+                    f"{self.scan_title}: Can't determine detector data format")
+            else:
+                self.detector_data_format = 'h5'
+        else:
+            self.detector_data_format = 'spec'
+
+    def get_detector_data_path(self):
+        raise NotImplementedError
+
+    def get_detector_num_bins(self, element_index=0):
+        if self.detector_data_format == 'spec':
+            return self.get_detector_num_bins_spec()
+        elif self.detector_data_format == 'h5':
+            return self.get_detector_num_bins_h5(element_index)
+
+    def get_detector_num_bins_spec(self):
+        with open(self.get_detector_data_file_spec()) as detector_file:
             lines = detector_file.readlines()
         for line in lines:
             if line.startswith('#@CHANN'):
@@ -1103,33 +1318,101 @@ class SMBMCAScanParser(MCAScanParser, SMBLinearScanParser):
                     return int(number_saved)
                 except:
                     continue
-        raise RuntimeError(f'{self.scan_title}: could not find num_bins for '
-                           f'detector {detector_prefix}')
-
-    def get_detector_data_path(self):
-        return self.scan_path
+        raise RuntimeError(f'{self.scan_title}: could not find num_bins')
 
-    def get_detector_data_file(self, detector_prefix, scan_step_index=0):
+    def get_detector_num_bins_h5(self, element_index):
+        from h5py import File
+        detector_file = self.get_detector_data_file_h5()
+        with File(detector_file) as h5_file:
+            dset_shape = h5_file['/entry/data/data'].shape
+        return dset_shape[-1]
+
+    def get_detector_data_file(self, scan_step_index=0):
+        if self.detector_data_format == 'spec':
+            return self.get_detector_data_file_spec()
+        elif self.detector_data_format == 'h5':
+            return self.get_detector_data_file_h5(
+                scan_step_index=scan_step_index)
+
+    def get_detector_data_file_spec(self):
+        """Return the filename (full absolute path) to the file
+        containing spec-formatted MCA data for this scan.
+        """
         file_name = f'spec.log.scan{self.scan_number}.mca1.mca'
         file_name_full = os.path.join(self.detector_data_path, file_name)
         if os.path.isfile(file_name_full):
             return file_name_full
-        raise RuntimeError(
-            f'{self.scan_title}: could not find detector image file')
+        raise OSError(
+            '{self.scan_title}: could not find detector image file'
+        )
+
+    def get_detector_data_file_h5(self, scan_step_index=0):
+        """Return the filename (full absolute path) to the file
+        containing h5-formatted MCA data for this scan.
+
+        :param scan_step_index:
+        """
+        scan_step = self.get_scan_step(scan_step_index)
+        if len(self.spec_scan_shape) == 1:
+            filename_index = 0
+        elif len(self.spec_scan_shape) == 2:
+            scan_step = self.get_scan_step(scan_step_index)
+            filename_index = scan_step[0]
+        else:
+            raise NotImplementedError(
+                'Cannot find detector file for scans with dimension > 2')
+        file_name = list_smb_mca_detector_files_h5(
+            self.detector_data_path)[filename_index]
+        file_name_full = os.path.join(self.detector_data_path, file_name)
+        if os.path.isfile(file_name_full):
+            return file_name_full
+        raise OSError(
+            '{self.scan_title}: could not find detector image file'
+        )
 
-    def get_all_detector_data(self, detector_prefix):
+
+    def get_all_detector_data(self, detector):
+        """Return a 2D array of all MCA spectra collected in this scan
+        by the detector element indicated with `detector`.
+
+        :param detector: For detector data collected in SPEC format,
+            this is the detector prefix as it appears in the spec MCA
+            data file. For detector data collected in H5 format, this
+            is the index of a particular detector element.
+        :type detector: Union[str, int]
+        :rtype: numpy.ndarray
+        """
+        if self.detector_data_format == 'spec':
+            return self.get_all_detector_data_spec(detector)
+        elif self.detector_data_format == 'h5':
+            try:
+                element_index = int(detector)
+            except:
+                raise TypeError(f'{detector} is not an integer element index')
+            return self.get_all_detector_data_h5(element_index)
+
+    def get_all_detector_data_spec(self, detector_prefix):
+        """Return a 2D array of all MCA spectra collected by a
+        detector in the spec MCA file format during the scan.
+
+        :param detector_prefix: Detector name at is appears in the
+            spec MCA file.
+        :type detector_prefix: str
+        :returns: 2D array of MCA spectra
+        :rtype: numpy.ndarray
+        """
         # This should be easy with pyspec, but there are bugs in
         # pyspec for MCA data.....  or is the 'bug' from a nonstandard
         # implementation of some macro on our end?  According to spec
         # manual and pyspec code, mca data should always begin w/ '@A'
-        # In example scans, it begins with '@mca1' instead
+        # In example scans, it begins with '@{detector_prefix}'
+        # instead
         data = []
 
-        with open(self.get_detector_data_file(detector_prefix)) \
-                as detector_file:
+        with open(self.get_detector_data_file_spec()) as detector_file:
             lines = [line.strip("\\\n") for line in detector_file.readlines()]
 
-        num_bins = self.get_detector_num_bins(detector_prefix)
+        num_bins = self.get_detector_num_bins()
 
         counter = 0
         for line in lines:
@@ -1156,6 +1439,106 @@ class SMBMCAScanParser(MCAScanParser, SMBLinearScanParser):
 
         return np.array(data)
 
-    def get_detector_data(self, detector_prefix, scan_step_index:int):
-        detector_data = self.get_all_detector_data(detector_prefix)
+    def get_all_detector_data_h5(self, element_index):
+        """Return a 2D array of all MCA spectra collected by a
+        detector in the h5 file format during the scan.
+
+        :param element_index: The index of a particualr MCA element to
+            return data for.
+        :type element_index: int
+        :returns: 2D array of MCA spectra
+        :rtype: numpy.ndarray
+        """
+        detector_data = np.empty(
+            (self.spec_scan_npts,
+             self.get_detector_num_bins_h5(element_index)))
+        detector_files = list_smb_mca_detector_files_h5(
+            self.detector_data_path)
+        for i, detector_file in enumerate(detector_files):
+            full_filename = os.path.join(
+                self.detector_data_path, detector_file)
+            element_data = get_all_mca_data_h5(
+                full_filename)[:,element_index,:]
+            i_0 = i * self.spec_scan_shape[0]
+            if len(self.spec_scan_shape) == 2:
+                i_f = i_0 + self.spec_scan_shape[0]
+            else:
+                i_f = self.spec_scan_npts
+            detector_data[i_0:i_f] = element_data
+        return detector_data
+
+    def get_detector_data(self, detector, scan_step_index:int):
+        """Return a single MCA spectrum for the detector indicated.
+
+        :param detector: If this scan collected MCA data in "spec"
+            format, this is the detector prefix as it appears in the
+            spec MCA data file. If this scan collected data in .h5
+            format, this is the index of the detector element of
+            interest.:type detector: typing.Union[str, int]
+        :param scan_step_index: Index of the scan step to return the
+            spectrum from.
+        :type scan_step_index: int
+        :returns: A single MCA spectrum
+        :rtype: numpy.ndarray
+        """
+        detector_data = self.get_all_detector_data(detector)
         return detector_data[scan_step_index]
+
+@cache
+def list_smb_mca_detector_files_h5(detector_data_path):
+    """Return a sorted list of all *.hdf5 files in a directory
+
+    :param detector_data_path: Directory to return *.hdf5 files from
+    :type detector_data_path: str
+    :returns: Sorted list of detector data filenames
+    :rtype: list[str]
+    """
+    return sorted(
+        [f for f in os.listdir(detector_data_path) if f.endswith('.hdf5')])
+
+@cache
+def get_all_mca_data_h5(filename):
+    """Return all data from all elements from an MCA data file
+
+    :param filename: Name of the MCA h5 data file
+    :type filename: str
+    :returns: 3D array of MCA spectra where the first axis is scan
+        step, second index is detector element, third index is channel
+        energy.
+    :rtype: numpy.ndarray
+    """
+    import os
+
+    from h5py import File
+    import numpy as np
+
+    with File(filename) as h5_file:
+        data = h5_file['/entry/data/data'][:]
+
+    # Prior to 2023-12-12, there was an issue where the XPS23 detector
+    # was capturing one or two frames of all 0s at the start of the
+    # dataset in every hdf5 file. In both cases, there is only ONE
+    # extra frame of data relative to the number of frames that should
+    # be there (based on the number of points in the spec scan). If
+    # one frame of all 0s is present: skip it and deliver only the
+    # real data. If two frames of all 0s are present: detector data
+    # will be missing for the LAST step in the scan. Skip the first
+    # two frames of all 0s in the hdf5 dataset, then add a frame of
+    # fake data (all 0-s) to the end of that real data so that the
+    # number of detector data frames matches the number of points in
+    # the spec scan.
+    check_zeros_before = 1702357200
+    file_mtime = os.path.getmtime(filename)
+    if file_mtime <= check_zeros_before:
+        if not np.any(data[0]):
+            # If present, remove first frame of blank data
+            print('Warning: removing blank first frame of detector data')
+            data = data[1:]
+            if not np.any(data[0]):
+                # If present, shift second frame of blank data to the
+                # end
+                print('Warning: shifting second frame of blank detector data '
+                      + 'to the end of the scan')
+                data = np.concatenate((data[1:], np.asarray([data[0]])))
+
+    return data