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

CHAP/tomo/processor.py

@@ -19,15 +19,17 @@ import numpy as np
 # Local modules
 from CHAP.utils.general import (
     is_num,
+    is_num_series,
     is_int_pair,
     input_int,
     input_num,
+    input_num_list,
     input_yesno,
     select_image_indices,
     select_roi_1d,
     select_roi_2d,
-    quick_plot,
     quick_imshow,
+    nxcopy,
 )
 from CHAP.utils.fit import Fit
 from CHAP.processor import Processor
@@ -112,6 +114,7 @@ class TomoCHESSMapConverter(Processor):
             NXdetector,
             NXentry,
             NXinstrument,
+            NXlink,
             NXroot,
             NXsample,
             NXsource,
@@ -119,18 +122,26 @@ class TomoCHESSMapConverter(Processor):
 
         # Local modules
         from CHAP.common.models.map import MapConfig
+        from CHAP.utils.general import index_nearest
 
         darkfield = get_nxroot(data, 'darkfield')
         brightfield = get_nxroot(data, 'brightfield')
         tomofields = get_nxroot(data, 'tomofields')
         detector_config = self.get_config(data, 'tomo.models.Detector')
 
-        if darkfield is not None and not isinstance(darkfield, NXentry):
-            raise ValueError('Invalid parameter darkfield ({darkfield})')
+        if darkfield is not None:
+            if isinstance(darkfield, NXroot):
+                darkfield = darkfield[darkfield.default]
+            if not isinstance(darkfield, NXentry):
+                raise ValueError(f'Invalid parameter darkfield ({darkfield})')
+        if isinstance(brightfield, NXroot):
+            brightfield = brightfield[brightfield.default]
         if not isinstance(brightfield, NXentry):
-            raise ValueError('Invalid parameter brightfield ({brightfield})')
+            raise ValueError(f'Invalid parameter brightfield ({brightfield})')
+        if isinstance(tomofields, NXroot):
+            tomofields = tomofields[tomofields.default]
         if not isinstance(tomofields, NXentry):
-            raise ValueError('Invalid parameter tomofields {tomofields})')
+            raise ValueError(f'Invalid parameter tomofields {tomofields})')
 
         # Construct NXroot
         nxroot = NXroot()
@@ -148,7 +159,7 @@ class TomoCHESSMapConverter(Processor):
                              '(available independent dimensions: '
                              f'{independent_dimensions})')
         rotation_angles_index = \
-            tomofields.data.attrs['rotation_angles_indices']
+            tomofields.data.axes.index('rotation_angles')
         rotation_angle_data_type = \
             tomofields.data.rotation_angles.attrs['data_type']
         if rotation_angle_data_type != 'scan_column':
@@ -157,7 +168,7 @@ class TomoCHESSMapConverter(Processor):
         matched_dimensions.pop(matched_dimensions.index('rotation_angles'))
         if 'x_translation' in independent_dimensions:
             x_translation_index = \
-                tomofields.data.attrs['x_translation_indices']
+                tomofields.data.axes.index('x_translation')
             x_translation_data_type = \
                 tomofields.data.x_translation.attrs['data_type']
             x_translation_name = \
@@ -170,7 +181,7 @@ class TomoCHESSMapConverter(Processor):
             x_translation_data_type = None
         if 'z_translation' in independent_dimensions:
             z_translation_index = \
-                tomofields.data.attrs['z_translation_indices']
+                tomofields.data.axes.index('z_translation')
             z_translation_data_type = \
                 tomofields.data.z_translation.attrs['data_type']
             z_translation_name = \
@@ -188,9 +199,11 @@ class TomoCHESSMapConverter(Processor):
                              '"rotation_angles"}')
 
         # Construct base NXentry and add to NXroot
-        nxentry = NXentry()
-        nxroot[map_config.title] = nxentry
-        nxroot.attrs['default'] = map_config.title
+        nxentry = NXentry(name=map_config.title)
+        nxroot[nxentry.nxname] = nxentry
+        nxentry.set_default()
+
+        # Add configuration fields
         nxentry.definition = 'NXtomo'
         nxentry.map_config = tomofields.map_config
 
@@ -214,12 +227,12 @@ class TomoCHESSMapConverter(Processor):
         # Add an NXdetector to the NXinstrument
         # (do not fill in data fields yet)
         detector_prefix = detector_config.prefix
-        detectors = list(set(tomofields.data.entries)
-                         - set(independent_dimensions))
+        detectors = list(
+            set(tomofields.data.entries) - set(independent_dimensions))
         if detector_prefix not in detectors:
             raise ValueError(f'Data for detector {detector_prefix} is '
                              f'unavailable (available detectors: {detectors})')
-        tomo_stacks = np.asarray(tomofields.data[detector_prefix])
+        tomo_stacks = tomofields.data[detector_prefix]
         tomo_stack_shape = tomo_stacks.shape
         assert len(tomo_stack_shape) == 2+len(independent_dimensions)
         assert tomo_stack_shape[-2] == detector_config.rows
@@ -272,8 +285,8 @@ class TomoCHESSMapConverter(Processor):
                     num_image = data_shape[0]
                     image_keys += num_image*[2]
                     sequence_numbers += list(range(num_image))
-                    image_stacks.append(np.asarray(
-                        nxcollection.data[detector_prefix]))
+                    image_stacks.append(
+                        nxcollection.data[detector_prefix])
                     rotation_angles += num_image*[0.0]
                     if (x_translation_data_type == 'spec_motor' or
                             z_translation_data_type == 'spec_motor'):
@@ -312,8 +325,8 @@ class TomoCHESSMapConverter(Processor):
                 num_image = data_shape[0]
                 image_keys += num_image*[1]
                 sequence_numbers += list(range(num_image))
-                image_stacks.append(np.asarray(
-                    nxcollection.data[detector_prefix]))
+                image_stacks.append(
+                    nxcollection.data[detector_prefix])
                 rotation_angles += num_image*[0.0]
                 if (x_translation_data_type == 'spec_motor' or
                         z_translation_data_type == 'spec_motor'):
@@ -347,10 +360,11 @@ class TomoCHESSMapConverter(Processor):
                 z_trans = [0.0]
                 tomo_stacks = np.reshape(tomo_stacks, (1,1,*tomo_stacks.shape))
             else:
-                if len(list(tomofields.data.z_translation)):
-                    z_trans = list(tomofields.data.z_translation)
-                else:
-                    z_trans = [float(tomofields.data.z_translation)]
+                z_trans = tomofields.data.z_translation.nxdata
+#                if len(list(tomofields.data.z_translation)):
+#                    z_trans = list(tomofields.data.z_translation)
+#                else:
+#                    z_trans = [float(tomofields.data.z_translation)]
                 if rotation_angles_index < z_translation_index:
                     tomo_stacks = np.swapaxes(
                         tomo_stacks, rotation_angles_index,
@@ -363,14 +377,16 @@ class TomoCHESSMapConverter(Processor):
                     tomo_stacks, rotation_angles_index, x_translation_index)
             tomo_stacks = np.expand_dims(tomo_stacks, 0)
         else:
-            if len(list(tomofields.data.x_translation)):
-                x_trans = list(tomofields.data.x_translation)
-            else:
-                x_trans = [float(tomofields.data.x_translation)]
-            if len(list(tomofields.data.z_translation)):
-                z_trans = list(tomofields.data.z_translation)
-            else:
-                z_trans = [float(tomofields.data.z_translation)]
+            x_trans = tomofields.data.x_translation.nxdata
+            z_trans = tomofields.data.z_translation.nxdata
+            #if tomofields.data.x_translation.size > 1:
+            #    x_trans = list(tomofields.data.x_translation)
+            #else:
+            #    x_trans = [float(tomofields.data.x_translation)]
+            #if len(list(tomofields.data.z_translation)):
+            #    z_trans = list(tomofields.data.z_translation)
+            #else:
+            #    z_trans = [float(tomofields.data.z_translation)]
             if (rotation_angles_index
                     < max(x_translation_index, z_translation_index)):
                 tomo_stacks = np.swapaxes(
@@ -380,10 +396,8 @@ class TomoCHESSMapConverter(Processor):
                 tomo_stacks = np.swapaxes(
                     tomo_stacks, x_translation_index, z_translation_index)
         # Restrict to 180 degrees set of data for now to match old code
-        thetas = np.asarray(tomofields.data.rotation_angles)
-#RV        num_image = len(tomofields.data.rotation_angles)
+        thetas = tomofields.data.rotation_angles.nxdata
         assert len(thetas) > 2
-        from CHAP.utils.general import index_nearest
         delta_theta = thetas[1]-thetas[0]
         if thetas[-1]-thetas[0] > 180-delta_theta:
             image_end = index_nearest(thetas, thetas[0]+180)
@@ -395,10 +409,8 @@ class TomoCHESSMapConverter(Processor):
             for j, x in enumerate(x_trans):
                 image_keys += num_image*[0]
                 sequence_numbers += list(range(num_image))
-                image_stacks.append(np.asarray(
-                    tomo_stacks[i,j][:image_end,:,:]))
+                image_stacks.append(tomo_stacks[i,j,:image_end,:,:])
                 rotation_angles += list(thetas)
-#RV                rotation_angles += list(tomofields.data.rotation_angles)
                 x_translations += num_image*[x]
                 z_translations += num_image*[z]
 
@@ -416,18 +428,12 @@ class TomoCHESSMapConverter(Processor):
         nxsample.z_translation.units = 'mm'
 
         # Add an NXdata to NXentry
-        nxdata = NXdata()
-        nxentry.data = nxdata
-        nxdata.makelink(nxentry.instrument.detector.data, name='data')
-        nxdata.makelink(nxentry.instrument.detector.image_key)
-        nxdata.makelink(nxentry.sample.rotation_angle)
-        nxdata.makelink(nxentry.sample.x_translation)
-        nxdata.makelink(nxentry.sample.z_translation)
-        nxdata.attrs['signal'] = 'data'
-#        nxdata.attrs['axes'] = ['field', 'row', 'column']
-#        nxdata.attrs['field_indices'] = 0
-#        nxdata.attrs['row_indices'] = 1
-#        nxdata.attrs['column_indices'] = 2
+        nxentry.data = NXdata(NXlink(nxentry.instrument.detector.data))
+        nxentry.data.makelink(nxentry.instrument.detector.image_key)
+        nxentry.data.makelink(nxentry.sample.rotation_angle)
+        nxentry.data.makelink(nxentry.sample.x_translation)
+        nxentry.data.makelink(nxentry.sample.z_translation)
+        nxentry.data.set_default()
 
         return nxroot
 
@@ -440,9 +446,9 @@ class TomoDataProcessor(Processor):
     """
 
     def process(
-            self, data, interactive=False, reduce_data=False,
-            find_center=False, reconstruct_data=False, combine_data=False,
-            output_folder='.', save_figs='no', **kwargs):
+            self, data, outputdir='.', interactive=False, reduce_data=False,
+            find_center=False, calibrate_center=False, reconstruct_data=False,
+            combine_data=False, save_figs='no'):
         """
         Process the input map or configuration with the step specific
         instructions and return either a dictionary or a
@@ -451,23 +457,26 @@ class TomoDataProcessor(Processor):
         :param data: Input configuration and specific step instructions
             for tomographic image reduction.
         :type data: list[PipelineData]
+        :param outputdir: Output folder name, defaults to '.'.
+        :type outputdir:: str, optional
         :param interactive: Allows for user interactions,
             defaults to False.
         :type interactive: bool, optional
         :param reduce_data: Generate reduced tomography images,
             defaults to False.
         :type reduce_data: bool, optional
-        :param find_center: Find the calibrated center axis info,
+        :param find_center: Generate calibrated center axis info,
             defaults to False.
         :type find_center: bool, optional
+        :param calibrate_center: Calibrate the rotation axis,
+            defaults to False.
+        :type calibrate_center: bool, optional
         :param reconstruct_data: Reconstruct the tomography data,
             defaults to False.
         :type reconstruct_data: bool, optional
         :param combine_data: Combine the reconstructed tomography
             stacks, defaults to False.
         :type combine_data: bool, optional
-        :param output_folder: Output folder name, defaults to '.'.
-        :type output_folder:: str, optional
         :param save_figs: Safe figures to file ('yes' or 'only') and/or
             display figures ('yes' or 'no'), defaults to 'no'.
         :type save_figs: Literal['yes', 'no', 'only'], optional
@@ -478,10 +487,7 @@ class TomoDataProcessor(Processor):
         :rtype: Union[dict, nexusformat.nexus.NXroot]
         """
         # Local modules
-        from nexusformat.nexus import (
-            nxsetconfig,
-            NXroot,
-        )
+        from nexusformat.nexus import nxsetconfig
         from CHAP.pipeline import PipelineItem
         from CHAP.tomo.models import (
             TomoReduceConfig,
@@ -494,6 +500,9 @@ class TomoDataProcessor(Processor):
             raise ValueError(f'Invalid parameter reduce_data ({reduce_data})')
         if not isinstance(find_center, bool):
             raise ValueError(f'Invalid parameter find_center ({find_center})')
+        if not isinstance(calibrate_center, bool):
+            raise ValueError(
+                f'Invalid parameter calibrate_center ({calibrate_center})')
         if not isinstance(reconstruct_data, bool):
             raise ValueError(
                 f'Invalid parameter reconstruct_data ({reconstruct_data})')
@@ -524,19 +533,41 @@ class TomoDataProcessor(Processor):
         nxroot = get_nxroot(data)
 
         tomo = Tomo(
-            interactive=interactive, output_folder=output_folder,
-            save_figs=save_figs)
+            logger=self.logger, interactive=interactive,
+            outputdir=outputdir, save_figs=save_figs)
 
         nxsetconfig(memory=100000)
 
+        # Calibrate the rotation axis
+        if calibrate_center:
+            if (reduce_data or find_center 
+                    or reconstruct_data or reconstruct_data_config is not None
+                    or combine_data or combine_data_config is not None):
+                self.logger.warning('Ignoring any step specific instructions '
+                                    'during center calibration')
+            if nxroot is None:
+                raise RuntimeError('Map info required to calibrate the '
+                                   'rotation axis')
+            if find_center_config is None:
+                find_center_config = TomoFindCenterConfig()
+                calibrate_center_rows = True
+            else:
+                calibrate_center_rows = find_center_config.center_rows
+                if calibrate_center_rows == None:
+                    calibrate_center_rows = True
+            nxroot, calibrate_center_rows = tomo.reduce_data(
+                nxroot, reduce_data_config, calibrate_center_rows)
+            return tomo.find_centers(
+                nxroot, find_center_config, calibrate_center_rows)
+
         # Reduce tomography images
         if reduce_data or reduce_data_config is not None:
             if nxroot is None:
                 raise RuntimeError('Map info required to reduce the '
                                    'tomography images')
-            nxroot = tomo.reduce_data(nxroot, reduce_data_config)
+            nxroot, _ = tomo.reduce_data(nxroot, reduce_data_config)
 
-        # Find rotation axis centers for the tomography stacks
+        # Find calibrated center axis info for the tomography stacks
         center_config = None
         if find_center or find_center_config is not None:
             run_find_centers = False
@@ -561,7 +592,7 @@ class TomoDataProcessor(Processor):
 
         # Reconstruct tomography stacks
         # RV pass reconstruct_data_config and center_config directly to
-        #     tomo.reconstruct_data?
+        # tomo.reconstruct_data?
         if reconstruct_data or reconstruct_data_config is not None:
             if reconstruct_data_config is None:
                 reconstruct_data_config = TomoReconstructConfig()
@@ -579,49 +610,6 @@ class TomoDataProcessor(Processor):
             return center_config
         return nxroot
 
-def nxcopy(nxobject, exclude_nxpaths=None, nxpath_prefix=''):
-    """
-    Function that returns a copy of a nexus object, optionally exluding
-    certain child items.
-
-    :param nxobject: The input nexus object to "copy".
-    :type nxobject: nexusformat.nexus.NXobject
-    :param exlude_nxpaths: A list of paths to child nexus objects that
-        should be excluded from the returned "copy", defaults to `[]`.
-    :type exclude_nxpaths: list[str], optional
-    :param nxpath_prefix: For use in recursive calls from inside this
-        function only.
-    :type nxpath_prefix: str
-    :return: Copy of the input `nxobject` with some children optionally
-        exluded.
-    :rtype: nexusformat.nexus.NXobject
-    """
-    # Third party modules
-    from nexusformat.nexus import NXgroup
-
-    nxobject_copy = nxobject.__class__()
-    if not nxpath_prefix:
-        if 'default' in nxobject.attrs:
-            nxobject_copy.attrs['default'] = nxobject.attrs['default']
-    else:
-        for k, v in nxobject.attrs.items():
-            nxobject_copy.attrs[k] = v
-
-    if exclude_nxpaths is None:
-        exclude_nxpaths = []
-    for k, v in nxobject.items():
-        nxpath = os_path.join(nxpath_prefix, k)
-        if nxpath in exclude_nxpaths:
-            continue
-        if isinstance(v, NXgroup):
-            nxobject_copy[k] = nxcopy(
-                v, exclude_nxpaths=exclude_nxpaths,
-                nxpath_prefix=os_path.join(nxpath_prefix, k))
-        else:
-            nxobject_copy[k] = v
-
-    return nxobject_copy
-
 
 class SetNumexprThreads:
     """
@@ -667,8 +655,8 @@ class Tomo:
     """Reconstruct a set of tomographic images."""
 
     def __init__(
-            self, interactive=False, num_core=-1, output_folder='.',
-            save_figs='no', test_mode=False):
+            self, logger=None, outputdir='.', interactive=False, num_core=-1,
+            save_figs='no'):
         """
         Initialize Tomo.
 
@@ -677,42 +665,32 @@ class Tomo:
         :type interactive: bool, optional
         :param num_core: Number of processors.
         :type num_core: int
-        :param output_folder: Output folder name, defaults to '.'.
-        :type output_folder:: str, optional
+        :param outputdir: Output folder name, defaults to '.'.
+        :type outputdir:: str, optional
         :param save_figs: Safe figures to file ('yes' or 'only') and/or
             display figures ('yes' or 'no'), defaults to 'no'.
         :type save_figs: Literal['yes', 'no', 'only'], optional
-        :param test_mode: Run in test mode (non-interactively), defaults
-            to False.
-        :type test_mode: bool, optional
         :raises ValueError: Invalid input parameter.
         """
         # System modules
-        from logging import getLogger
         from multiprocessing import cpu_count
 
         self.__name__ = self.__class__.__name__
-        self._logger = getLogger(self.__name__)
-        self._logger.propagate = False
+        if logger is None:
+            # System modules
+            from logging import getLogger
+
+            self._logger = getLogger(self.__name__)
+            self._logger.propagate = False
+        else:
+            self._logger = logger
 
         if not isinstance(interactive, bool):
             raise ValueError(f'Invalid parameter interactive ({interactive})')
+        self._outputdir = outputdir
         self._interactive = interactive
         self._num_core = num_core
-        self._output_folder = os_path.abspath(output_folder)
-        if not os_path.isdir(self._output_folder):
-            mkdir(self._output_folder)
-        if self._interactive:
-            self._test_mode = False
-        else:
-            if not isinstance(test_mode, bool):
-                raise ValueError(f'Invalid parameter test_mode ({test_mode})')
-            self._test_mode = test_mode
         self._test_config = {}
-        if self._test_mode:
-            if save_figs != 'only':
-                self._logger.warning('Ignoring save_figs in test mode')
-            save_figs = 'only'
         if save_figs == 'only':
             self._save_only = True
             self._save_figs = True
@@ -737,8 +715,15 @@ class Tomo:
                 f'num_core = {self._num_core} is larger than the number '
                 f'of available processors and reduced to {cpu_count()}')
             self._num_core = cpu_count()
+        # Tompy py uses numexpr with NUMEXPR_MAX_THREADS = 64
+        if self._num_core > 64:
+            self._logger.warning(
+                f'num_core = {self._num_core} is larger than the number '
+                f'of processors suitable to Tomopy and reduced to 64')
+            self._num_core = 64
 
-    def reduce_data(self, nxroot, tool_config=None):
+    def reduce_data(
+            self, nxroot, tool_config=None, calibrate_center_rows=False):
         """
         Reduced the tomography images.
 
@@ -760,8 +745,9 @@ class Tomo:
 
         self._logger.info('Generate the reduced tomography images')
 
+        # Validate input parameter
         if isinstance(nxroot, NXroot):
-            nxentry = nxroot[nxroot.attrs['default']]
+            nxentry = nxroot[nxroot.default]
         else:
             raise ValueError(
                 f'Invalid parameter nxroot {type(nxroot)}:\n{nxroot}')
@@ -770,14 +756,22 @@ class Tomo:
             img_row_bounds = None
         else:
             delta_theta = tool_config.delta_theta
-            img_row_bounds = tool_config.img_row_bounds
-
+            img_row_bounds = tuple(tool_config.img_row_bounds)
+            if img_row_bounds is not None:
+                if (nxentry.instrument.source.attrs['station']
+                        in ('id1a3', 'id3a')):
+                    self._logger.warning('Ignoring parameter img_row_bounds '
+                                        'for id1a3 and id3a')
+                    img_row_bounds = None
+                elif calibrate_center_rows:
+                    self._logger.warning('Ignoring parameter img_row_bounds '
+                                        'during rotation axis calibration')
+                    img_row_bounds = None
         image_key = nxentry.instrument.detector.get('image_key', None)
         if image_key is None or 'data' not in nxentry.instrument.detector:
             raise ValueError(f'Unable to find image_key or data in '
                              'instrument.detector '
                              f'({nxentry.instrument.detector.tree})')
-        image_key = np.asarray(image_key)
 
         # Create an NXprocess to store data reduction (meta)data
         reduced_data = NXprocess()
@@ -788,7 +782,7 @@ class Tomo:
         # Generate bright field
         reduced_data = self._gen_bright(nxentry, reduced_data, image_key)
 
-        # Get rotation angles for image stacks
+        # Get rotation angles for image stacks (in degrees)
         thetas = self._gen_thetas(nxentry, image_key)
 
         # Get the image stack mask to remove bad images from stack
@@ -798,13 +792,13 @@ class Tomo:
             if delta_theta is not None:
                 delta_theta = None
                 self._logger.warning(
-                    'Ignore delta_theta when an image mask is used')
+                    'Ignoring delta_theta when an image mask is used')
             np.random.seed(0)
             image_mask = np.where(np.random.rand(
                 len(thetas)) < drop_fraction/100, 0, 1).astype(bool)
 
         # Set zoom and/or rotation angle interval to reduce memory
-        #     requirement
+        # requirement
         if image_mask is None:
             zoom_perc, delta_theta = self._set_zoom_or_delta_theta(
                 thetas, delta_theta)
@@ -820,55 +814,66 @@ class Tomo:
             self._logger.debug(f'image_mask = {image_mask}')
             reduced_data.image_mask = image_mask
             thetas = thetas[image_mask]
-        self._logger.debug(f'thetas = {thetas}')
-        reduced_data.rotation_angle = thetas
-        reduced_data.rotation_angle.units = 'degrees'
 
-        # Set vertical detector bounds for image stack
+        # Set vertical detector bounds for image stack or rotation
+        # axis calibration rows
         img_row_bounds = self._set_detector_bounds(
             nxentry, reduced_data, image_key, thetas[0],
-            img_row_bounds=img_row_bounds)
-        self._logger.info(f'img_row_bounds = {img_row_bounds}')
+            img_row_bounds, calibrate_center_rows)
+        self._logger.debug(f'img_row_bounds = {img_row_bounds}')
+        if calibrate_center_rows:
+            calibrate_center_rows = tuple(sorted(img_row_bounds))
+            img_row_bounds = None
+        if img_row_bounds is None:
+            tbf_shape = reduced_data.data.bright_field.shape
+            img_row_bounds = (0, tbf_shape[0])
         reduced_data.img_row_bounds = img_row_bounds
         reduced_data.img_row_bounds.units = 'pixels'
+        reduced_data.img_row_bounds.attrs['long_name'] = \
+            'image row boundaries in detector frame of reference'
+
+        # Store rotation angles for image stacks
+        self._logger.debug(f'thetas = {thetas}')
+        reduced_data.rotation_angle = thetas
+        reduced_data.rotation_angle.units = 'degrees'
 
         # Generate reduced tomography fields
-        reduced_data = self._gen_tomo(nxentry, reduced_data, image_key)
+        reduced_data = self._gen_tomo(
+            nxentry, reduced_data, image_key, calibrate_center_rows)
 
         # Create a copy of the input Nexus object and remove raw and
-        #     any existing reduced data
-        if isinstance(nxroot, NXroot):
-            exclude_items = [
-                f'{nxentry.nxname}/reduced_data/data',
-                f'{nxentry.nxname}/instrument/detector/data',
-                f'{nxentry.nxname}/instrument/detector/image_key',
-                f'{nxentry.nxname}/instrument/detector/sequence_number',
-                f'{nxentry.nxname}/sample/rotation_angle',
-                f'{nxentry.nxname}/sample/x_translation',
-                f'{nxentry.nxname}/sample/z_translation',
-                f'{nxentry.nxname}/data/data',
-                f'{nxentry.nxname}/data/image_key',
-                f'{nxentry.nxname}/data/rotation_angle',
-                f'{nxentry.nxname}/data/x_translation',
-                f'{nxentry.nxname}/data/z_translation',
-            ]
-            nxroot = nxcopy(nxroot, exclude_nxpaths=exclude_items)
-            nxentry = nxroot[nxroot.attrs['default']]
+        # any existing reduced data
+        exclude_items = [
+            f'{nxentry.nxname}/reduced_data/data',
+            f'{nxentry.nxname}/instrument/detector/data',
+            f'{nxentry.nxname}/instrument/detector/image_key',
+            f'{nxentry.nxname}/instrument/detector/sequence_number',
+            f'{nxentry.nxname}/sample/rotation_angle',
+            f'{nxentry.nxname}/sample/x_translation',
+            f'{nxentry.nxname}/sample/z_translation',
+            f'{nxentry.nxname}/data/data',
+            f'{nxentry.nxname}/data/image_key',
+            f'{nxentry.nxname}/data/rotation_angle',
+            f'{nxentry.nxname}/data/x_translation',
+            f'{nxentry.nxname}/data/z_translation',
+        ]
+        nxroot = nxcopy(nxroot, exclude_nxpaths=exclude_items)
 
         # Add the reduced data NXprocess
+        nxentry = nxroot[nxroot.default]
         nxentry.reduced_data = reduced_data
 
         if 'data' not in nxentry:
             nxentry.data = NXdata()
+            nxentry.data.set_default()
         nxentry.data.makelink(
             nxentry.reduced_data.data.tomo_fields, name='reduced_data')
-        nxentry.data.makelink(
-            nxentry.reduced_data.rotation_angle, name='rotation_angle')
+        nxentry.data.makelink(nxentry.reduced_data.rotation_angle)
         nxentry.data.attrs['signal'] = 'reduced_data'
 
-        return nxroot
+        return nxroot, calibrate_center_rows
 
-    def find_centers(self, nxroot, tool_config):
+    def find_centers(self, nxroot, tool_config, calibrate_center_rows=False):
         """
         Find the calibrated center axis info
 
@@ -883,106 +888,83 @@ class Tomo:
         :rtype: dict
         """
         # Third party modules
-        from nexusformat.nexus import (
-            NXentry,
-            NXroot,
-        )
+        from nexusformat.nexus import NXroot
         from yaml import safe_dump
 
         self._logger.info('Find the calibrated center axis info')
 
         if isinstance(nxroot, NXroot):
-            nxentry = nxroot[nxroot.attrs['default']]
+            nxentry = nxroot[nxroot.default]
         else:
             raise ValueError(f'Invalid parameter nxroot ({nxroot})')
-        center_rows = tool_config.center_rows
-        center_stack_index = tool_config.center_stack_index
-        if (center_stack_index is not None
-                and (not isinstance(center_stack_index, int)
-                     or center_stack_index < 0)):
-            raise ValueError(
-                'Invalid parameter center_stack_index '
-                f'({center_stack_index})')
 
         # Check if reduced data is available
-        if ('reduced_data' not in nxentry
-                or 'reduced_data' not in nxentry.data):
+        if 'reduced_data' not in nxentry:
             raise ValueError(f'Unable to find valid reduced data in {nxentry}.')
 
-        # Get full bright field
-        tbf = np.asarray(nxentry.reduced_data.data.bright_field)
-        tbf_shape = tbf.shape
-
-        # Get image bounds
-        img_row_bounds = tuple(
-            nxentry.reduced_data.get('img_row_bounds', (0, tbf_shape[0])))
-        img_column_bounds = tuple(
-            nxentry.reduced_data.get('img_column_bounds', (0, tbf_shape[1])))
-
-        # Select the image stack to calibrate the center axis
-        #     reduced data axes order: stack,theta,row,column
+        # Select the image stack to find the calibrated center axis
+        # reduced data axes order: stack,theta,row,column
         # Note: Nexus can't follow a link if the data it points to is
-        #     too big get the data from the actual place, not from
-        #     nxentry.data
+        # too big get the data from the actual place, not from
+        # nxentry.data
         num_tomo_stacks = nxentry.reduced_data.data.tomo_fields.shape[0]
-        img_shape = nxentry.reduced_data.data.bright_field.shape
-        num_row = int(img_row_bounds[1] - img_row_bounds[0])
+        self._logger.debug(f'num_tomo_stacks = {num_tomo_stacks}')
         if num_tomo_stacks == 1:
             center_stack_index = 0
-            default = 'n'
         else:
-            if self._test_mode:
-                # Convert input value to offset 0
-                center_stack_index = self._test_config['center_stack_index']
+            center_stack_index = tool_config.center_stack_index
+            if calibrate_center_rows:
+                center_stack_index = num_tomo_stacks//2
             elif self._interactive:
                 if center_stack_index is None:
                     center_stack_index = input_int(
                         '\nEnter tomography stack index to calibrate the '
                         'center axis', ge=0, lt=num_tomo_stacks,
-                        default=int(num_tomo_stacks/2))
+                        default=num_tomo_stacks//2)
             else:
                 if center_stack_index is None:
-                    center_stack_index = int(num_tomo_stacks/2)
+                    center_stack_index = num_tomo_stacks//2
                     self._logger.warning(
                         'center_stack_index unspecified, use stack '
-                        f'{center_stack_index} to find centers')
-            default = 'y'
+                        f'{center_stack_index} to find center axis info')
 
         # Get thetas (in degrees)
-        thetas = np.asarray(nxentry.reduced_data.rotation_angle)
-
-        # Get effective pixel_size
-        if 'zoom_perc' in nxentry.reduced_data:
-            eff_pixel_size = float(
-                100. * (nxentry.instrument.detector.row_pixel_size
-                         / nxentry.reduced_data.attrs['zoom_perc']))
-        else:
-            eff_pixel_size = float(nxentry.instrument.detector.row_pixel_size)
-
-        # Get cross sectional diameter
-        cross_sectional_dim = img_shape[1]*eff_pixel_size
-        self._logger.debug(f'cross_sectional_dim = {cross_sectional_dim}')
-
-        # Determine center offset at sample row boundaries
-        self._logger.info('Determine center offset at sample row boundaries')
+        thetas = nxentry.reduced_data.rotation_angle.nxdata
 
         # Select center rows
-        if self._test_mode:
-            center_rows = tuple(self._test_config['center_rows'])
+        if calibrate_center_rows:
+            center_rows = calibrate_center_rows
+            offset_center_rows = (0, 1)
         else:
             # Third party modules
             import matplotlib.pyplot as plt
 
+            # Get full bright field
+            tbf = nxentry.reduced_data.data.bright_field.nxdata
+            tbf_shape = tbf.shape
+
+            # Get image bounds
+            img_row_bounds = nxentry.reduced_data.get(
+                'img_row_bounds', (0, tbf_shape[0]))
+            img_row_bounds = (int(img_row_bounds[0]), int(img_row_bounds[1]))
+            img_column_bounds = nxentry.reduced_data.get(
+                'img_column_bounds', (0, tbf_shape[1]))
+            img_column_bounds = (
+                int(img_column_bounds[0]), int(img_column_bounds[1]))
+
+            center_rows = tool_config.center_rows
             if center_rows is None:
                 if num_tomo_stacks == 1:
                     # Add a small margin to avoid edge effects
-                    offset = min(5, int(0.1*num_row))
-                    center_rows = (offset, num_row-1-offset)
+                    offset = min(
+                        5, int(0.1*(img_row_bounds[1] - img_row_bounds[0])))
+                    center_rows = (
+                        img_row_bounds[0]+offset, img_row_bounds[1]-1-offset)
                 else:
                     if not self._interactive:
                         self._logger.warning('center_rows unspecified, find '
                                              'centers at reduced data bounds')
-                    center_rows = (0, num_row-1)
+                    center_rows = (img_row_bounds[0], img_row_bounds[1]-1)
             fig, center_rows = select_image_indices(
                 nxentry.reduced_data.data.tomo_fields[
                     center_stack_index,0,:,:],
@@ -990,38 +972,60 @@ class Tomo:
                 b=tbf[img_row_bounds[0]:img_row_bounds[1],
                       img_column_bounds[0]:img_column_bounds[1]], 
                 preselected_indices=center_rows,
-                title='Select or adjust two detector image row indices to '
-                    f'find center axis (in range [0, {num_row-1}])',
+                axis_index_offset=img_row_bounds[0],
+                title='Select two detector image row indices to find center '
+                    f'axis (in range [{img_row_bounds[0]}, '
+                    f'{img_row_bounds[1]-1}])',
                 title_a=r'Tomography image at $\theta$ = '
                         f'{round(thetas[0], 2)+0}',
                 title_b='Bright field', interactive=self._interactive)
-            if center_rows[1] == num_row:
+            if center_rows[1] == img_row_bounds[1]:
                 center_rows = (center_rows[0], center_rows[1]-1)
+            offset_center_rows = (
+                center_rows[0] - img_row_bounds[0],
+                center_rows[1] - img_row_bounds[0])
             # Plot results
             if self._save_figs:
                 fig.savefig(
-                    os_path.join(
-                        self._output_folder, 'center_finding_rows.png'))
+                    os_path.join(self._outputdir, 'center_finding_rows.png'))
             plt.close()
 
+        # Get effective pixel_size
+        if 'zoom_perc' in nxentry.reduced_data:
+            eff_pixel_size = float(
+                100. * (nxentry.instrument.detector.row_pixel_size
+                         / nxentry.reduced_data.attrs['zoom_perc']))
+        else:
+            eff_pixel_size = float(nxentry.instrument.detector.row_pixel_size)
+        self._logger.debug(f'eff_pixel_size = {eff_pixel_size}')
+
+        # Get cross sectional diameter
+        cross_sectional_dim = \
+            eff_pixel_size * nxentry.reduced_data.data.bright_field.shape[1]
+        self._logger.debug(f'cross_sectional_dim = {cross_sectional_dim}')
+
         # Find the center offsets at each of the center rows
+        prev_center_offset = None
         center_offsets = []
-        for i, center_row in enumerate(center_rows):
+        for row, offset_row in zip(center_rows, offset_center_rows):
             t0 = time()
             center_offsets.append(
                 self._find_center_one_plane(
-                    nxentry.reduced_data.data.tomo_fields[
-                        center_stack_index,:,center_row,:],
-                    center_row, thetas, eff_pixel_size, cross_sectional_dim,
-                    path=self._output_folder, num_core=self._num_core,
-                    search_range=tool_config.search_range,
-                    search_step=tool_config.search_step,
+                    nxentry.reduced_data.data.tomo_fields, center_stack_index,
+                    row, offset_row, np.radians(thetas), eff_pixel_size,
+                    cross_sectional_dim, path=self._outputdir,
+                    num_core=self._num_core,
+                    center_offset_min=tool_config.center_offset_min,
+                    center_offset_max=tool_config.center_offset_max,
+                    center_search_range=tool_config.center_search_range,
                     gaussian_sigma=tool_config.gaussian_sigma,
-                    ring_width=tool_config.ring_width))
+                    ring_width=tool_config.ring_width,
+                    prev_center_offset=prev_center_offset))
             self._logger.info(
-                f'Finding center {i} took {time()-t0:.2f} seconds')
-            self._logger.debug(f'center_row {i} = {center_rows[i]:.2f}')
-            self._logger.debug(f'center_offset {i} = {center_offsets[i]:.2f}')
+                f'Finding center row {row} took {time()-t0:.2f} seconds')
+            self._logger.debug(f'center_row = {row:.2f}')
+            self._logger.debug(f'center_offset = {center_offsets[-1]:.2f}')
+            prev_center_offset = center_offsets[-1]
 
         center_config = {
             'center_rows': list(center_rows),
@@ -1029,12 +1033,14 @@ class Tomo:
         }
         if num_tomo_stacks > 1:
             center_config['center_stack_index'] = center_stack_index
-
-        # Save test data to file
-        if self._test_mode:
-            with open(f'{self._output_folder}/center_config.yaml', 'w',
-                      encoding='utf8') as f:
-                safe_dump(center_config, f)
+        if tool_config.center_offset_min is not None:
+            center_config['center_offset_min'] = tool_config.center_offset_min
+        if tool_config.center_offset_max is not None:
+            center_config['center_offset_max'] = tool_config.center_offset_max
+        if tool_config.gaussian_sigma is not None:
+            center_config['gaussian_sigma'] = tool_config.gaussian_sigma
+        if tool_config.ring_width is not None:
+            center_config['ring_width'] = tool_config.ring_width
 
         return center_config
 
@@ -1056,9 +1062,8 @@ class Tomo:
         """
         # Third party modules
         from nexusformat.nexus import (
-            nxgetconfig,
             NXdata,
-            NXentry,
+            NXfield,
             NXprocess,
             NXroot,
         )
@@ -1066,21 +1071,20 @@ class Tomo:
         self._logger.info('Reconstruct the tomography data')
 
         if isinstance(nxroot, NXroot):
-            nxentry = nxroot[nxroot.attrs['default']]
+            nxentry = nxroot[nxroot.default]
         else:
             raise ValueError(f'Invalid parameter nxroot ({nxroot})')
         if not isinstance(center_info, dict):
             raise ValueError(f'Invalid parameter center_info ({center_info})')
 
         # Check if reduced data is available
-        if ('reduced_data' not in nxentry
-                or 'reduced_data' not in nxentry.data):
+        if 'reduced_data' not in nxentry:
             raise ValueError(f'Unable to find valid reduced data in {nxentry}.')
 
         # Create an NXprocess to store image reconstruction (meta)data
         nxprocess = NXprocess()
 
-        # Get rotation axis rows and centers
+        # Get calibrated center axis rows and centers
         center_rows = center_info.get('center_rows')
         center_offsets = center_info.get('center_offsets')
         if center_rows is None or center_offsets is None:
@@ -1091,35 +1095,28 @@ class Tomo:
             / (center_rows[1]-center_rows[0])
 
         # Get thetas (in degrees)
-        thetas = np.asarray(nxentry.reduced_data.rotation_angle)
+        thetas = nxentry.reduced_data.rotation_angle.nxdata
 
         # Reconstruct tomography data
-        #     reduced data axes order: stack,theta,row,column
-        #     reconstructed data: row/-z,y,x
+        # - reduced data axes order: stack,theta,row,column
+        # - reconstructed data axes order: row/-z,y,x
         # Note: Nexus can't follow a link if the data it points to is
-        #     too big get the data from the actual place, not from
-        #     nxentry.data
+        # too big get the data from the actual place, not from
+        # nxentry.data
         if 'zoom_perc' in nxentry.reduced_data:
             res_title = f'{nxentry.reduced_data.attrs["zoom_perc"]}p'
         else:
             res_title = 'fullres'
-        tomo_stacks = np.asarray(nxentry.reduced_data.data.tomo_fields)
+        tomo_stacks = nxentry.reduced_data.data.tomo_fields
         num_tomo_stacks = tomo_stacks.shape[0]
-        tomo_recon_stacks = num_tomo_stacks*[np.array([])]
+        tomo_recon_stacks = []
+        img_row_bounds = tuple(nxentry.reduced_data.get(
+            'img_row_bounds', (0, tomo_stacks.shape[2])))
+        center_rows -= img_row_bounds[0]
         for i in range(num_tomo_stacks):
             # Convert reduced data stack from theta,row,column to
-            #     row,theta,column
-            t0 = time()
-            tomo_stack = tomo_stacks[i]
-            self._logger.info(
-                f'Reading reduced data stack {i} took {time()-t0:.2f} '
-                'seconds')
-            if (len(tomo_stack.shape) != 3
-                    or any(True for dim in tomo_stack.shape if not dim)):
-                raise RuntimeError(
-                    f'Unable to load tomography stack {i} for '
-                    'reconstruction')
-            tomo_stack = np.swapaxes(tomo_stack, 0, 1)
+            # row,theta,column
+            tomo_stack = np.swapaxes(tomo_stacks[i,:,:,:], 0, 1)
             assert len(thetas) == tomo_stack.shape[1]
             assert 0 <= center_rows[0] < center_rows[1] < tomo_stack.shape[0]
             center_offsets = [
@@ -1129,46 +1126,42 @@ class Tomo:
             ]
             t0 = time()
             tomo_recon_stack = self._reconstruct_one_tomo_stack(
-                tomo_stack, thetas, center_offsets=center_offsets,
+                tomo_stack, np.radians(thetas), center_offsets=center_offsets,
                 num_core=self._num_core, algorithm='gridrec',
                 secondary_iters=tool_config.secondary_iters,
+                gaussian_sigma=tool_config.gaussian_sigma,
                 remove_stripe_sigma=tool_config.remove_stripe_sigma,
                 ring_width=tool_config.ring_width)
             self._logger.info(
                 f'Reconstruction of stack {i} took {time()-t0:.2f} seconds')
 
             # Combine stacks
-            tomo_recon_stacks[i] = tomo_recon_stack
+            tomo_recon_stacks.append(tomo_recon_stack)
 
         # Resize the reconstructed tomography data
-        #     reconstructed data order in each stack: row/-z,y,x
+        # - reconstructed axis data order in each stack: row/-z,y,x
         tomo_recon_shape = tomo_recon_stacks[0].shape
-        if self._test_mode:
-            x_bounds = tuple(self._test_config.get('x_bounds'))
-            y_bounds = tuple(self._test_config.get('y_bounds'))
-            z_bounds = (0, tomo_recon_shape[0])
-        else:
-            x_bounds, y_bounds, z_bounds = self._resize_reconstructed_data(
-                tomo_recon_stacks, x_bounds=tool_config.x_bounds,
-                y_bounds=tool_config.y_bounds, z_bounds=tool_config.z_bounds)
+        x_bounds, y_bounds, z_bounds = self._resize_reconstructed_data(
+            tomo_recon_stacks, x_bounds=tool_config.x_bounds,
+            y_bounds=tool_config.y_bounds, z_bounds=tool_config.z_bounds)
         if x_bounds is None:
             x_range = (0, tomo_recon_shape[2])
-            x_slice = int(x_range[1]/2)
+            x_slice = x_range[1]//2
         else:
             x_range = (min(x_bounds), max(x_bounds))
-            x_slice = int((x_bounds[0]+x_bounds[1]) / 2)
+            x_slice = (x_bounds[0]+x_bounds[1])//2
         if y_bounds is None:
             y_range = (0, tomo_recon_shape[1])
-            y_slice = int(y_range[1] / 2)
+            y_slice = y_range[1]//2
         else:
             y_range = (min(y_bounds), max(y_bounds))
-            y_slice = int((y_bounds[0]+y_bounds[1]) / 2)
+            y_slice = (y_bounds[0]+y_bounds[1])//2
         if z_bounds is None:
             z_range = (0, tomo_recon_shape[0])
-            z_slice = int(z_range[1] / 2)
+            z_slice = z_range[1]//2
         else:
             z_range = (min(z_bounds), max(z_bounds))
-            z_slice = int((z_bounds[0]+z_bounds[1]) / 2)
+            z_slice = (z_bounds[0]+z_bounds[1])//2
         z_dim_org = tomo_recon_shape[0]
         for i, stack in enumerate(tomo_recon_stacks):
             tomo_recon_stacks[i] = stack[
@@ -1176,18 +1169,17 @@ class Tomo:
                 x_range[0]:x_range[1]]
         tomo_recon_stacks = np.asarray(tomo_recon_stacks)
 
-        row_pixel_size = float(
-            nxentry.instrument.detector.row_pixel_size)
-        column_pixel_size = float(
-            nxentry.instrument.detector.column_pixel_size)
+        detector = nxentry.instrument.detector
+        row_pixel_size = float(detector.row_pixel_size)
+        column_pixel_size = float(detector.column_pixel_size)
         if num_tomo_stacks == 1:
             # Convert the reconstructed tomography data from internal
-            #     coordinate frame row/-z,y,x with the origin on the
-            #     near-left-top corner to an z,y,x coordinate frame
-            #     with the origin on the par file x,z values, halfway
-            #     in the y-dimension.
-            #     Here x is to the right, y along the beam direction
-            #     and z upwards in the lab frame of reference
+            # coordinate frame row/-z,y,x with the origin on the
+            # near-left-top corner to an z,y,x coordinate frame with
+            # the origin on the par file x,z values, halfway in the
+            # y-dimension.
+            # Here x is to the right, y along the beam direction and
+            # z upwards in the lab frame of reference
             tomo_recon_stack = np.flip(tomo_recon_stacks[0], 0)
             z_range = (z_dim_org-z_range[1], z_dim_org-z_range[0])
 
@@ -1195,19 +1187,17 @@ class Tomo:
             x = column_pixel_size * (
                 np.linspace(
                     x_range[0], x_range[1], x_range[1]-x_range[0], False)
-                - 0.5*nxentry.instrument.detector.columns
-                + 0.5)
+                - 0.5*detector.columns + 0.5)
             x = np.asarray(x + nxentry.reduced_data.x_translation[0])
             y = np.asarray(
                     column_pixel_size * (
                     np.linspace(
                         y_range[0], y_range[1], y_range[1]-y_range[0], False)
-                    - 0.5*nxentry.instrument.detector.columns
-                    + 0.5))
+                    - 0.5*detector.columns + 0.5))
             z = row_pixel_size*(
                 np.linspace(
                     z_range[0], z_range[1], z_range[1]-z_range[0], False)
-                + nxentry.instrument.detector.rows
+                + detector.rows
                 - int(nxentry.reduced_data.img_row_bounds[1])
                 + 0.5)
             z = np.asarray(z + nxentry.reduced_data.z_translation[0])
@@ -1223,7 +1213,7 @@ class Tomo:
                 quick_imshow(
                     tomo_recon_stack[:,:,x_index], 
                     title=f'recon {res_title} x={x[x_index]:.4f}',
-                    origin='lower', extent=extent, path=self._output_folder,
+                    origin='lower', extent=extent, path=self._outputdir,
                     save_fig=True, save_only=True)
                 y_index = y_slice-y_range[0]
                 extent = (
@@ -1234,7 +1224,7 @@ class Tomo:
                 quick_imshow(
                     tomo_recon_stack[:,y_index,:],
                     title=f'recon {res_title} y={y[y_index]:.4f}',
-                    origin='lower', extent=extent, path=self._output_folder,
+                    origin='lower', extent=extent, path=self._outputdir,
                     save_fig=True, save_only=True)
                 z_index = z_slice-z_range[0]
                 extent = (
@@ -1245,16 +1235,8 @@ class Tomo:
                 quick_imshow(
                     tomo_recon_stack[z_index,:,:],
                     title=f'recon {res_title} z={z[z_index]:.4f}',
-                    origin='lower', extent=extent, path=self._output_folder,
+                    origin='lower', extent=extent, path=self._outputdir,
                     save_fig=True, save_only=True)
-
-            # Save test data to file
-            #     reconstructed data order in each stack: z,y,x
-            if self._test_mode:
-                np.savetxt(
-                    f'{self._output_folder}/recon_stack.txt',
-                    tomo_recon_stacks[z_slice-z_range[0],:,:],
-                    fmt='%.6e')
         else:
             # Plot a few reconstructed image slices
             if self._save_figs:
@@ -1263,94 +1245,84 @@ class Tomo:
                     title = f'{basetitle} {res_title} xslice{x_slice}'
                     quick_imshow(
                         tomo_recon_stacks[i,:,:,x_slice-x_range[0]],
-                        title=title, path=self._output_folder,
-                        save_fig=True, save_only=True)
+                        title=title, path=self._outputdir, save_fig=True,
+                        save_only=True)
                     title = f'{basetitle} {res_title} yslice{y_slice}'
                     quick_imshow(
                         tomo_recon_stacks[i,:,y_slice-y_range[0],:],
-                        title=title, path=self._output_folder,
-                        save_fig=True, save_only=True)
+                        title=title, path=self._outputdir, save_fig=True,
+                        save_only=True)
                     title = f'{basetitle} {res_title} zslice{z_slice}'
                     quick_imshow(
                         tomo_recon_stacks[i,z_slice-z_range[0],:,:],
-                        title=title, path=self._output_folder,
-                        save_fig=True, save_only=True)
-
-            # Save test data to file
-            #     reconstructed data order in each stack: row/-z,y,x
-            if self._test_mode:
-                for i in range(tomo_recon_shape[0]):
-                    np.savetxt(
-                        f'{self._output_folder}/recon_stack_{i}.txt',
-                        tomo_recon_stacks[i,z_slice-z_range[0],:,:],
-                        fmt='%.6e')
+                        title=title, path=self._outputdir, save_fig=True,
+                        save_only=True)
 
         # Add image reconstruction to reconstructed data NXprocess
-        #     reconstructed data order:
-        #     - for one stack: z,y,x
-        #     - for multiple stacks: row/-z,y,x
-        nxprocess.data = NXdata()
-        nxprocess.attrs['default'] = 'data'
+        # reconstructed axis data order:
+        # - for one stack: z,y,x
+        # - for multiple stacks: row/-z,y,x
         for k, v in center_info.items():
             nxprocess[k] = v
             if k == 'center_rows' or k == 'center_offsets':
                 nxprocess[k].units = 'pixels'
+            if k == 'center_rows':
+                nxprocess[k].attrs['long_name'] = \
+                    'center row indices in detector frame of reference'
         if x_bounds is not None:
             nxprocess.x_bounds = x_bounds
             nxprocess.x_bounds.units = 'pixels'
+            nxprocess.x_bounds.attrs['long_name'] = \
+                'x range indices in reduced data frame of reference'
         if y_bounds is not None:
             nxprocess.y_bounds = y_bounds
             nxprocess.y_bounds.units = 'pixels'
+            nxprocess.y_bounds.attrs['long_name'] = \
+                'y range indices in reduced data frame of reference'
         if z_bounds is not None:
             nxprocess.z_bounds = z_bounds
             nxprocess.z_bounds.units = 'pixels'
-        nxprocess.data.attrs['signal'] = 'reconstructed_data'
+            nxprocess.z_bounds.attrs['long_name'] = \
+                'z range indices in reduced data frame of reference'
         if num_tomo_stacks == 1:
-            nxprocess.data.reconstructed_data = tomo_recon_stack
-            nxprocess.data.attrs['axes'] = ['z', 'y', 'x']
-            nxprocess.data.attrs['x_indices'] = 2
-            nxprocess.data.attrs['y_indices'] = 1
-            nxprocess.data.attrs['z_indices'] = 0
-            nxprocess.data.x = x
-            nxprocess.data.x.units = \
-                nxentry.instrument.detector.column_pixel_size.units
-            nxprocess.data.y = y
-            nxprocess.data.y.units = \
-                nxentry.instrument.detector.column_pixel_size.units
-            nxprocess.data.z = z
-            nxprocess.data.z.units = \
-                nxentry.instrument.detector.row_pixel_size.units
+            nxprocess.data = NXdata(
+                NXfield(tomo_recon_stack, 'reconstructed_data'),
+                (NXfield(
+                     z, 'z', attrs={'units': detector.row_pixel_size.units}),
+                 NXfield(
+                     y, 'y',
+                     attrs={'units': detector.column_pixel_size.units}),
+                 NXfield(
+                     x, 'x',
+                     attrs={'units': detector.column_pixel_size.units}),))
         else:
-            nxprocess.data.reconstructed_data = tomo_recon_stacks
+            nxprocess.data = NXdata(
+                NXfield(tomo_recon_stacks, 'reconstructed_data'))
 
         # Create a copy of the input Nexus object and remove reduced
-        #     data
+        # data
         exclude_items = [
             f'{nxentry.nxname}/reduced_data/data',
             f'{nxentry.nxname}/data/reduced_data',
             f'{nxentry.nxname}/data/rotation_angle',
         ]
-        nxroot_copy = nxcopy(nxroot, exclude_nxpaths=exclude_items)
+        nxroot = nxcopy(nxroot, exclude_nxpaths=exclude_items)
 
         # Add the reconstructed data NXprocess to the new Nexus object
-        nxentry_copy = nxroot_copy[nxroot_copy.attrs['default']]
-        nxentry_copy.reconstructed_data = nxprocess
-        if 'data' not in nxentry_copy:
-            nxentry_copy.data = NXdata()
-        nxentry_copy.attrs['default'] = 'data'
-        nxentry_copy.data.makelink(
-            nxprocess.data.reconstructed_data, name='reconstructed_data')
-        nxentry_copy.data.attrs['signal'] = 'reconstructed_data'
+        nxentry = nxroot[nxroot.default]
+        nxentry.reconstructed_data = nxprocess
+        if 'data' not in nxentry:
+            nxentry.data = NXdata()
+            nxentry.data.set_default()
+        nxentry.data.makelink(nxprocess.data.reconstructed_data)
         if num_tomo_stacks == 1:
-            nxentry_copy.data.attrs['axes'] = ['z', 'y', 'x']
-            nxentry_copy.data.attrs['x_indices'] = 2
-            nxentry_copy.data.attrs['y_indices'] = 1
-            nxentry_copy.data.attrs['z_indices'] = 0
-            nxentry_copy.data.makelink(nxprocess.data.x, name='x')
-            nxentry_copy.data.makelink(nxprocess.data.y, name='y')
-            nxentry_copy.data.makelink(nxprocess.data.z, name='z')
+            nxentry.data.attrs['axes'] = ['z', 'y', 'x']
+            nxentry.data.makelink(nxprocess.data.x)
+            nxentry.data.makelink(nxprocess.data.y)
+            nxentry.data.makelink(nxprocess.data.z)
+        nxentry.data.attrs['signal'] = 'reconstructed_data'
 
-        return nxroot_copy
+        return nxroot
 
     def combine_data(self, nxroot, tool_config):
         """Combine the reconstructed tomography stacks.
@@ -1368,7 +1340,7 @@ class Tomo:
         # Third party modules
         from nexusformat.nexus import (
             NXdata,
-            NXentry,
+            NXfield,
             NXprocess,
             NXroot,
         )
@@ -1376,50 +1348,54 @@ class Tomo:
         self._logger.info('Combine the reconstructed tomography stacks')
 
         if isinstance(nxroot, NXroot):
-            nxentry = nxroot[nxroot.attrs['default']]
+            nxentry = nxroot[nxroot.default]
         else:
             raise ValueError(f'Invalid parameter nxroot ({nxroot})')
 
         # Check if reconstructed image data is available
-        if ('reconstructed_data' not in nxentry
-                or 'reconstructed_data' not in nxentry.data):
+        if 'reconstructed_data' not in nxentry:
             raise KeyError(
                 f'Unable to find valid reconstructed image data in {nxentry}')
 
         # Create an NXprocess to store combined image reconstruction
-        #     (meta)data
+        # (meta)data
         nxprocess = NXprocess()
 
-        num_tomo_stacks = \
-            nxentry.reconstructed_data.data.reconstructed_data.shape[0]
+        if nxentry.reconstructed_data.data.reconstructed_data.ndim == 3:
+            num_tomo_stacks = 1
+        else:
+            num_tomo_stacks = \
+                nxentry.reconstructed_data.data.reconstructed_data.shape[0]
         if num_tomo_stacks == 1:
             self._logger.info('Only one stack available: leaving combine_data')
             return nxroot
 
         # Get and combine the reconstructed stacks
-        #     reconstructed data order: stack,row/-z,y,x
+        # - reconstructed axis data order: stack,row/-z,y,x
         # Note: Nexus can't follow a link if the data it points to is
-        #     too big. So get the data from the actual place, not from
-        #     nxentry.data
-        # (load one stack at a time to reduce risk of hitting Nexus
-        #     data access limit)
+        # too big. So get the data from the actual place, not from
+        # nxentry.data
+        # Also load one stack at a time to reduce risk of hitting Nexus
+        # data access limit
         t0 = time()
         tomo_recon_combined = \
             nxentry.reconstructed_data.data.reconstructed_data[0,:,:,:]
+# RV check this out more
+#        tomo_recon_combined = np.concatenate(
+#            [tomo_recon_combined]
+#            + [nxentry.reconstructed_data.data.reconstructed_data[i,:,:,:]
+#               for i in range(1, num_tomo_stacks)])
         tomo_recon_combined = np.concatenate(
             [nxentry.reconstructed_data.data.reconstructed_data[i,:,:,:]
-               for i in range(num_tomo_stacks-1,0,-1)]
+               for i in range(num_tomo_stacks-1, 0, -1)]
             + [tomo_recon_combined])
         self._logger.info(
             f'Combining the reconstructed stacks took {time()-t0:.2f} seconds')
+        tomo_shape = tomo_recon_combined.shape
 
         # Resize the combined tomography data stacks
-        #     combined data order: row/-z,y,x
-        if self._test_mode:
-            x_bounds = None
-            y_bounds = None
-            z_bounds = tuple(self._test_config.get('z_bounds'))
-        elif self._interactive:
+        # - combined axis data order: row/-z,y,x
+        if self._interactive:
             x_bounds, y_bounds, z_bounds = self._resize_reconstructed_data(
                 tomo_recon_combined, combine_data=True)
         else:
@@ -1428,76 +1404,73 @@ class Tomo:
                 self._logger.warning(
                     'x_bounds unspecified, reconstruct data for full x-range')
             elif not is_int_pair(
-                    x_bounds, ge=0, le=tomo_recon_combined.shape[2]):
+                    x_bounds, ge=0, le=tomo_shape[2]):
                 raise ValueError(f'Invalid parameter x_bounds ({x_bounds})')
             y_bounds = tool_config.y_bounds
             if y_bounds is None:
                 self._logger.warning(
                     'y_bounds unspecified, reconstruct data for full y-range')
             elif not is_int_pair(
-                    y_bounds, ge=0, le=tomo_recon_combined.shape[1]):
+                    y_bounds, ge=0, le=tomo_shape[1]):
                 raise ValueError(f'Invalid parameter y_bounds ({y_bounds})')
             z_bounds = tool_config.z_bounds
             if z_bounds is None:
                 self._logger.warning(
                     'z_bounds unspecified, reconstruct data for full z-range')
             elif not is_int_pair(
-                    z_bounds, ge=0, le=tomo_recon_combined.shape[0]):
+                    z_bounds, ge=0, le=tomo_shape[0]):
                 raise ValueError(f'Invalid parameter z_bounds ({z_bounds})')
         if x_bounds is None:
-            x_range = (0, tomo_recon_combined.shape[2])
-            x_slice = int(x_range[1]/2)
+            x_range = (0, tomo_shape[2])
+            x_slice = x_range[1]//2
         else:
             x_range = (min(x_bounds), max(x_bounds))
-            x_slice = int((x_bounds[0]+x_bounds[1]) / 2)
+            x_slice = (x_bounds[0]+x_bounds[1])//2
         if y_bounds is None:
-            y_range = (0, tomo_recon_combined.shape[1])
-            y_slice = int(y_range[1]/2)
+            y_range = (0, tomo_shape[1])
+            y_slice = y_range[1]//2
         else:
             y_range = (min(y_bounds), max(y_bounds))
-            y_slice = int((y_bounds[0]+y_bounds[1]) / 2)
+            y_slice = (y_bounds[0]+y_bounds[1])//2
         if z_bounds is None:
-            z_range = (0, tomo_recon_combined.shape[0])
-            z_slice = int(z_range[1]/2)
+            z_range = (0, tomo_shape[0])
+            z_slice = z_range[1]//2
         else:
             z_range = (min(z_bounds), max(z_bounds))
-            z_slice = int((z_bounds[0]+z_bounds[1]) / 2)
-        z_dim_org = tomo_recon_combined.shape[0]
+            z_slice = (z_bounds[0]+z_bounds[1])//2
+        z_dim_org = tomo_shape[0]
         tomo_recon_combined = tomo_recon_combined[
             z_range[0]:z_range[1],y_range[0]:y_range[1],x_range[0]:x_range[1]]
 
         # Convert the reconstructed tomography data from internal
-        #     coordinate frame row/-z,y,x with the origin on the
-        #     near-left-top corner to an z,y,x coordinate frame.
-        #     Here x is to the right, y along the beam direction
-        #     and z upwards in the lab frame of reference
+        # coordinate frame row/-z,y,x with the origin on the
+        # near-left-top corner to an z,y,x coordinate frame.
+        # Here x is to the right, y along the beam direction and
+        # z upwards in the lab frame of reference
         tomo_recon_combined = np.flip(tomo_recon_combined, 0)
+        tomo_shape = tomo_recon_combined.shape
         z_range = (z_dim_org-z_range[1], z_dim_org-z_range[0])
 
         # Get coordinate axes
-        row_pixel_size = float(
-            nxentry.instrument.detector.row_pixel_size)
-        column_pixel_size = float(
-            nxentry.instrument.detector.column_pixel_size)
+        detector = nxentry.instrument.detector
+        row_pixel_size = float(detector.row_pixel_size)
+        column_pixel_size = float(detector.column_pixel_size)
         x = column_pixel_size * (
             np.linspace(x_range[0], x_range[1], x_range[1]-x_range[0], False)
-            - 0.5*nxentry.instrument.detector.columns
-            + 0.5)
+            - 0.5*detector.columns + 0.5)
         if nxentry.reconstructed_data.get('x_bounds', None) is not None:
             x += column_pixel_size*nxentry.reconstructed_data.x_bounds[0]
         x = np.asarray(x + nxentry.reduced_data.x_translation[0])
         y = column_pixel_size * (
             np.linspace(y_range[0], y_range[1], y_range[1]-y_range[0], False)
-            - 0.5*nxentry.instrument.detector.columns
-            + 0.5)
+            - 0.5*detector.columns + 0.5)
         if nxentry.reconstructed_data.get('y_bounds', None) is not None:
             y += column_pixel_size*nxentry.reconstructed_data.y_bounds[0]
         y = np.asarray(y)
         z = row_pixel_size*(
             np.linspace(z_range[0], z_range[1], z_range[1]-z_range[0], False)
             - int(nxentry.reduced_data.img_row_bounds[0])
-            + 0.5*(nxentry.instrument.detector.rows)
-            -0.5)
+            + 0.5*detector.rows - 0.5)
         z = np.asarray(z + nxentry.reduced_data.z_translation[0])
 
         # Plot a few combined image slices
@@ -1507,98 +1480,82 @@ class Tomo:
                 y[-1],
                 z[0],
                 z[-1])
-            x_slice = int(tomo_recon_combined.shape[2]/2)
+            x_slice = tomo_shape[2]//2
             quick_imshow(
                 tomo_recon_combined[:,:,x_slice],
                 title=f'recon combined x={x[x_slice]:.4f}', origin='lower',
-                extent=extent, path=self._output_folder, save_fig=True,
+                extent=extent, path=self._outputdir, save_fig=True,
                 save_only=True)
             extent = (
                 x[0],
                 x[-1],
                 z[0],
                 z[-1])
-            y_slice = int(tomo_recon_combined.shape[1]/2)
+            y_slice = tomo_shape[1]//2
             quick_imshow(
                 tomo_recon_combined[:,y_slice,:],
                 title=f'recon combined y={y[y_slice]:.4f}', origin='lower',
-                extent=extent, path=self._output_folder, save_fig=True,
+                extent=extent, path=self._outputdir, save_fig=True,
                 save_only=True)
             extent = (
                 x[0],
                 x[-1],
                 y[0],
                 y[-1])
-            z_slice = int(tomo_recon_combined.shape[0]/2)
+            z_slice = tomo_shape[0]//2
             quick_imshow(
                 tomo_recon_combined[z_slice,:,:],
                 title=f'recon combined z={z[z_slice]:.4f}', origin='lower',
-                extent=extent, path=self._output_folder, save_fig=True,
+                extent=extent, path=self._outputdir, save_fig=True,
                 save_only=True)
 
-        # Save test data to file
-        #     combined data order: z,y,x
-        if self._test_mode:
-            z_slice = int(tomo_recon_combined.shape[0]/2)
-            np.savetxt(
-                f'{self._output_folder}/recon_combined.txt',
-                tomo_recon_combined[z_slice,:,:], fmt='%.6e')
-
         # Add image reconstruction to reconstructed data NXprocess
-        #     combined data order: z,y,x
-        nxprocess.data = NXdata()
-        nxprocess.attrs['default'] = 'data'
-        if x_bounds is not None:
+        # - combined axis data order: z,y,x
+        if x_bounds is not None and x_bounds != (0, tomo_shape[2]):
             nxprocess.x_bounds = x_bounds
             nxprocess.x_bounds.units = 'pixels'
-        if y_bounds is not None:
+            nxprocess.x_bounds.attrs['long_name'] = \
+                'x range indices in reconstructed data frame of reference'
+        if y_bounds is not None and y_bounds != (0, tomo_shape[1]):
             nxprocess.y_bounds = y_bounds
             nxprocess.y_bounds.units = 'pixels'
-        if z_bounds is not None:
+            nxprocess.y_bounds.attrs['long_name'] = \
+                'y range indices in reconstructed data frame of reference'
+        if z_bounds is not None and z_bounds != (0, tomo_shape[0]):
             nxprocess.z_bounds = z_bounds
             nxprocess.z_bounds.units = 'pixels'
-        nxprocess.data.combined_data = tomo_recon_combined
-        nxprocess.data.attrs['signal'] = 'combined_data'
-        nxprocess.data.attrs['axes'] = ['z', 'y', 'x']
-        nxprocess.data.attrs['x_indices'] = 2
-        nxprocess.data.attrs['y_indices'] = 1
-        nxprocess.data.attrs['z_indices'] = 0
-        nxprocess.data.x = x
-        nxprocess.data.x.units = \
-            nxentry.instrument.detector.column_pixel_size.units
-        nxprocess.data.y = y
-        nxprocess.data.y.units = \
-            nxentry.instrument.detector.column_pixel_size.units
-        nxprocess.data.z = z
-        nxprocess.data.z.units = \
-            nxentry.instrument.detector.row_pixel_size.units
+            nxprocess.z_bounds.attrs['long_name'] = \
+                'z range indices in reconstructed data frame of reference'
+        nxprocess.data = NXdata(
+            NXfield(tomo_recon_combined, 'combined_data'),
+            (NXfield(z, 'z', attrs={'units': detector.row_pixel_size.units}),
+             NXfield(
+                 y, 'y', attrs={'units': detector.column_pixel_size.units}),
+             NXfield(
+                 x, 'x', attrs={'units': detector.column_pixel_size.units}),))
 
         # Create a copy of the input Nexus object and remove
-        #     reconstructed data
+        # reconstructed data
         exclude_items = [
             f'{nxentry.nxname}/reconstructed_data/data',
             f'{nxentry.nxname}/data/reconstructed_data',
         ]
-        nxroot_copy = nxcopy(nxroot, exclude_nxpaths=exclude_items)
+        nxroot = nxcopy(nxroot, exclude_nxpaths=exclude_items)
 
         # Add the combined data NXprocess to the new Nexus object
-        nxentry_copy = nxroot_copy[nxroot_copy.attrs['default']]
-        nxentry_copy.combined_data = nxprocess
-        if 'data' not in nxentry_copy:
-            nxentry_copy.data = NXdata()
-        nxentry_copy.attrs['default'] = 'data'
-        nxentry_copy.data.makelink(
-            nxprocess.data.combined_data, name='combined_data')
-        nxentry_copy.data.attrs['signal'] = 'combined_data'
-        nxentry_copy.data.attrs['axes'] = ['z', 'y', 'x']
-        nxentry_copy.data.attrs['x_indices'] = 2
-        nxentry_copy.data.attrs['y_indices'] = 1
-        nxentry_copy.data.attrs['z_indices'] = 0
-        nxentry_copy.data.makelink(nxprocess.data.x, name='x')
-        nxentry_copy.data.makelink(nxprocess.data.y, name='y')
-        nxentry_copy.data.makelink(nxprocess.data.z, name='z')
-
-        return nxroot_copy
+        nxentry = nxroot[nxroot.default]
+        nxentry.combined_data = nxprocess
+        if 'data' not in nxentry:
+            nxentry.data = NXdata()
+            nxentry.data.set_default()
+        nxentry.data.makelink(nxprocess.data.combined_data)
+        nxentry.data.attrs['axes'] = ['z', 'y', 'x']
+        nxentry.data.makelink(nxprocess.data.x)
+        nxentry.data.makelink(nxprocess.data.y)
+        nxentry.data.makelink(nxprocess.data.z)
+        nxentry.data.attrs['signal'] = 'combined_data'
+
+        return nxroot
 
     def _gen_dark(self, nxentry, reduced_data, image_key):
         """Generate dark field."""
@@ -1609,8 +1566,7 @@ class Tomo:
         field_indices = [
             index for index, key in enumerate(image_key) if key == 2]
         if field_indices:
-            tdf_stack = np.asarray(
-                nxentry.instrument.detector.data[field_indices,:,:])
+            tdf_stack = nxentry.instrument.detector.data[field_indices,:,:]
         else:
             self._logger.warning('Dark field unavailable')
             return reduced_data
@@ -1625,7 +1581,6 @@ class Tomo:
             raise RuntimeError(f'Invalid tdf_stack shape ({tdf_stack.shape})')
 
         # Remove dark field intensities above the cutoff
-#        tdf_cutoff = None
         tdf_cutoff = tdf.min() + 2 * (np.median(tdf)-tdf.min())
         self._logger.debug(f'tdf_cutoff = {tdf_cutoff}')
         if tdf_cutoff is not None:
@@ -1646,7 +1601,7 @@ class Tomo:
         if self._save_figs:
             quick_imshow(
                 tdf, title='Dark field', name='dark_field',
-                path=self._output_folder, save_fig=True, save_only=True)
+                path=self._outputdir, save_fig=True, save_only=True)
 
         # Add dark field to reduced data NXprocess
         reduced_data.data = NXdata()
@@ -1663,8 +1618,7 @@ class Tomo:
         field_indices = [
             index for index, key in enumerate(image_key) if key == 1]
         if field_indices:
-            tbf_stack = np.asarray(
-                nxentry.instrument.detector.data[field_indices,:,:])
+            tbf_stack = nxentry.instrument.detector.data[field_indices,:,:]
         else:
             raise ValueError('Bright field unavailable')
 
@@ -1689,12 +1643,6 @@ class Tomo:
         else:
             raise RuntimeError(f'Invalid tbf_stack shape ({tbf_stack.shape})')
 
-        # Subtract dark field
-        if 'data' in reduced_data and 'dark_field' in reduced_data.data:
-            tbf -= np.asarray(reduced_data.data.dark_field)
-        else:
-            self._logger.warning('Dark field unavailable')
-
         # Set any non-positive values to one
         # (avoid negative bright field values for spikes in dark field)
         tbf[tbf < 1] = 1
@@ -1703,7 +1651,7 @@ class Tomo:
         if self._save_figs:
             quick_imshow(
                 tbf, title='Bright field', name='bright_field',
-                path=self._output_folder, save_fig=True, save_only=True)
+                path=self._outputdir, save_fig=True, save_only=True)
 
         # Add bright field to reduced data NXprocess
         if 'data' not in reduced_data:
@@ -1712,8 +1660,9 @@ class Tomo:
 
         return reduced_data
 
-    def _set_detector_bounds(self, nxentry, reduced_data, image_key, theta,
-            img_row_bounds=None):
+    def _set_detector_bounds(
+            self, nxentry, reduced_data, image_key, theta, img_row_bounds,
+            calibrate_center_rows):
         """
         Set vertical detector bounds for each image stack.Right now the
         range is the same for each set in the image stack.
@@ -1724,111 +1673,131 @@ class Tomo:
         # Local modules
         from CHAP.utils.general import is_index_range
 
-        if self._test_mode:
-            return tuple(self._test_config['img_row_bounds'])
-
         # Get the first tomography image and the reference heights
         image_mask = reduced_data.get('image_mask')
         if image_mask is None:
             first_image_index = 0
         else:
-            raise RuntimeError('image_mask not tested yet')
-            image_mask = np.asarray(image_mask)
             first_image_index = int(np.argmax(image_mask))
         field_indices_all = [
             index for index, key in enumerate(image_key) if key == 0]
         if not field_indices_all:
             raise ValueError('Tomography field(s) unavailable')
-        z_translation_all = np.asarray(
-            nxentry.sample.z_translation)[field_indices_all]
+        z_translation_all = nxentry.sample.z_translation[field_indices_all]
         z_translation_levels = sorted(list(set(z_translation_all)))
         num_tomo_stacks = len(z_translation_levels)
-        center_stack_index = int(num_tomo_stacks/2)
+        center_stack_index = num_tomo_stacks//2
         z_translation = z_translation_levels[center_stack_index]
         try:
             field_indices = [
                 field_indices_all[index]
                 for index, z in enumerate(z_translation_all)
                 if z == z_translation]
-            first_image = np.asarray(nxentry.instrument.detector.data[
-                field_indices[first_image_index]])
+            first_image = nxentry.instrument.detector.data[
+                field_indices[first_image_index]]
         except:
             raise RuntimeError('Unable to load the tomography images '
                                f'for stack {i}')
 
-        # Select image bounds
-        tbf = np.asarray(reduced_data.data.bright_field)
-        if nxentry.instrument.source.attrs['station'] in ('id1a3', 'id3a'):
-            pixel_size = float(nxentry.instrument.detector.row_pixel_size)
-            # Try to get a fit from the bright field
-            row_sum = np.sum(tbf, 1)
-            fit = Fit.fit_data(
-                row_sum, 'rectangle', x=np.array(range(len(row_sum))),
-                form='atan', guess=True)
-            parameters = fit.best_values
-            row_low_fit = parameters.get('center1', None)
-            row_upp_fit = parameters.get('center2', None)
-            sig_low = parameters.get('sigma1', None)
-            sig_upp = parameters.get('sigma2', None)
-            have_fit = (fit.success and row_low_fit is not None
-                and row_upp_fit is not None and sig_low is not None
-                and sig_upp is not None
-                and 0 <= row_low_fit < row_upp_fit <= row_sum.size
-                and (sig_low+sig_upp) / (row_upp_fit-row_low_fit) < 0.1)
-            if num_tomo_stacks == 1:
-                if have_fit:
-                    delta_z = (row_upp_fit-row_low_fit) * pixel_size
+        # Set initial image bounds or rotation calibration rows
+        tbf = reduced_data.data.bright_field.nxdata
+        if (not isinstance(calibrate_center_rows, bool)
+                and is_int_pair(calibrate_center_rows)):
+            img_row_bounds = calibrate_center_rows
+        else:
+            if nxentry.instrument.source.attrs['station'] in ('id1a3', 'id3a'):
+                pixel_size = float(nxentry.instrument.detector.row_pixel_size)
+                # Try to get a fit from the bright field
+                row_sum = np.sum(tbf, 1)
+                fit = Fit.fit_data(
+                    row_sum, 'rectangle', x=np.array(range(len(row_sum))),
+                    form='atan', guess=True)
+                parameters = fit.best_values
+                row_low_fit = parameters.get('center1', None)
+                row_upp_fit = parameters.get('center2', None)
+                sig_low = parameters.get('sigma1', None)
+                sig_upp = parameters.get('sigma2', None)
+                have_fit = (fit.success and row_low_fit is not None
+                    and row_upp_fit is not None and sig_low is not None
+                    and sig_upp is not None
+                    and 0 <= row_low_fit < row_upp_fit <= row_sum.size
+                    and (sig_low+sig_upp) / (row_upp_fit-row_low_fit) < 0.1)
+                if num_tomo_stacks == 1:
+                    if have_fit:
+                        # Add a pixel margin for roundoff effects in fit
+                        row_low_fit += 1
+                        row_upp_fit -= 1
+                        delta_z = (row_upp_fit-row_low_fit) * pixel_size
+                    else:
+                        # Set a default range of 1 mm
+                        # RV can we get this from the slits?
+                        delta_z = 1.0
                 else:
-                    # Set a default range of 1 mm
-                    # RV can we get this from the slits?
-                    delta_z = 1.0
-            else:
-                # Get the default range from the reference heights
-                delta_z = z_translation_levels[1]-z_translation_levels[0]
-                for i in range(2, num_tomo_stacks):
-                    delta_z = min(
-                        delta_z,
-                        z_translation_levels[i]-z_translation_levels[i-1])
-            self._logger.debug(f'delta_z = {delta_z}')
-            num_row_min = int((delta_z + 0.5*pixel_size) / pixel_size)
-            if num_row_min > tbf.shape[0]:
-                self._logger.warning(
-                    'Image bounds and pixel size prevent seamless '
-                    'stacking')
-                row_low = 0
-                row_upp = tbf.shape[0]
-            else:
-                self._logger.debug(f'num_row_min = {num_row_min}')
-                if have_fit:
-                    # Center the default range relative to the fitted
-                    #     window
-                    row_low = int((row_low_fit+row_upp_fit-num_row_min) / 2)
-                    row_upp = row_low+num_row_min
+                    # Get the default range from the reference heights
+                    delta_z = z_translation_levels[1]-z_translation_levels[0]
+                    for i in range(2, num_tomo_stacks):
+                        delta_z = min(
+                            delta_z,
+                            z_translation_levels[i]-z_translation_levels[i-1])
+                self._logger.debug(f'delta_z = {delta_z}')
+                num_row_min = int((delta_z + 0.5*pixel_size) / pixel_size)
+                if num_row_min > tbf.shape[0]:
+                    self._logger.warning(
+                        'Image bounds and pixel size prevent seamless '
+                        'stacking')
+                    row_low = 0
+                    row_upp = tbf.shape[0]
                 else:
-                    # Center the default range
-                    row_low = int((tbf.shape[0]-num_row_min) / 2)
-                    row_upp = row_low+num_row_min
-            img_row_bounds = (row_low, row_upp)
+                    self._logger.debug(f'num_row_min = {num_row_min}')
+                    if have_fit:
+                        # Center the default range relative to the fitted
+                        # window
+                        row_low = int((row_low_fit+row_upp_fit-num_row_min)/2)
+                        row_upp = row_low+num_row_min
+                    else:
+                        # Center the default range
+                        row_low = int((tbf.shape[0]-num_row_min)/2)
+                        row_upp = row_low+num_row_min
+                img_row_bounds = (row_low, row_upp)
+                if calibrate_center_rows:
+                    # Add a small margin to avoid edge effects
+                    offset = int(min(5, 0.1*(row_upp-row_low)))
+                    img_row_bounds = (row_low+offset, row_upp-1-offset)
+            else:
+                if num_tomo_stacks > 1:
+                    raise NotImplementedError(
+                        'Selecting image bounds or calibrating rotation axis '
+                        'for multiple stacks on FMB')
+                # For FMB: use the first tomography image to select range
+                # RV revisit if they do tomography with multiple stacks
+                if img_row_bounds is None and not self._interactive:
+                    if calibrate_center_rows:
+                        self._logger.warning(
+                            'calibrate_center_rows unspecified, find rotation '
+                            'axis at detector bounds (with a small margin)')
+                        # Add a small margin to avoid edge effects
+                        offset = min(5, 0.1*first_image.shape[0])
+                        img_row_bounds = (
+                            offset, first_image.shape[0]-1-offset)
+                    else:
+                        self._logger.warning(
+                            'img_row_bounds unspecified, reduce data for '
+                            'entire detector range')
+                        img_row_bounds = (0, first_image.shape[0])
+        if calibrate_center_rows:
+            title='Select two detector image row indices to '\
+                  'calibrate rotation axis (in range '\
+                  f'[0, {first_image.shape[0]}])'
         else:
-            if num_tomo_stacks > 1:
-                raise NotImplementedError(
-                    'Selecting image bounds for multiple stacks on FMB')
-            # For FMB: use the first tomography image to select range
-            # RV revisit if they do tomography with multiple stacks
-            if img_row_bounds is None:
-                if not self._interactive:
-                    self._logger.warning(
-                        'img_row_bounds unspecified, reduce data for entire '
-                        'detector range')
-                    img_row_bounds = (0, first_image.shape[0])
+            title='Select detector image row bounds for data '\
+                  f'reduction (in range [0, {first_image.shape[0]}])'
         fig, img_row_bounds = select_image_indices(
             first_image, 0, b=tbf, preselected_indices=img_row_bounds,
-            title='Select or adjust detector image row bounds for data '
-                  f'reduction (in range {[0, first_image.shape[0]]})',
+            title=title,
             title_a=r'Tomography image at $\theta$ = 'f'{round(theta, 2)+0}',
             title_b='Bright field',
             interactive=self._interactive)
-        if (num_tomo_stacks > 1
+        if not calibrate_center_rows and (num_tomo_stacks > 1
                 and (img_row_bounds[1]-img_row_bounds[0]+1)
                      < int((delta_z - 0.5*pixel_size) / pixel_size)):
             self._logger.warning(
@@ -1836,19 +1805,22 @@ class Tomo:
 
         # Plot results
         if self._save_figs:
-            fig.savefig(
-                os_path.join(self._output_folder, 'detector_image_bounds.png'))
+            if calibrate_center_rows:
+                fig.savefig(os_path.join(
+                    self._outputdir, 'rotation_calibration_rows.png'))
+            else:
+                fig.savefig(os_path.join(
+                    self._outputdir, 'detector_image_bounds.png'))
         plt.close()
 
         return img_row_bounds
 
     def _gen_thetas(self, nxentry, image_key):
         """Get the rotation angles for the image stacks."""
-        # Get the rotation angles
+        # Get the rotation angles (in degrees)
         field_indices_all = [
             index for index, key in enumerate(image_key) if key == 0]
-        z_translation_all = np.asarray(
-            nxentry.sample.z_translation)[field_indices_all]
+        z_translation_all = nxentry.sample.z_translation[field_indices_all]
         z_translation_levels = sorted(list(set(z_translation_all)))
         thetas = None
         for i, z_translation in enumerate(z_translation_levels):
@@ -1856,22 +1828,20 @@ class Tomo:
                 field_indices_all[index]
                 for index, z in enumerate(z_translation_all)
                 if z == z_translation]
-            sequence_numbers = np.asarray(
-                nxentry.instrument.detector.sequence_number)[field_indices]
+            sequence_numbers = \
+                nxentry.instrument.detector.sequence_number[field_indices]
             assert (list(sequence_numbers)
                     == list(range((len(sequence_numbers)))))
             if thetas is None:
-                thetas = np.asarray(
-                    nxentry.sample.rotation_angle)[
-                        field_indices][sequence_numbers]
+                thetas = nxentry.sample.rotation_angle[
+                    field_indices][sequence_numbers]
             else:
                 assert all(
-                    thetas[i] == np.asarray(
-                        nxentry.sample.rotation_angle)[
-                            field_indices[index]]
+                    thetas[i] == nxentry.sample.rotation_angle[
+                        field_indices[index]]
                     for i, index in enumerate(sequence_numbers))
 
-        return thetas
+        return np.asarray(thetas)
 
     def _set_zoom_or_delta_theta(self, thetas, delta_theta=None):
         """
@@ -1881,9 +1851,6 @@ class Tomo:
         # Local modules
         from CHAP.utils.general import index_nearest
 
-        if self._test_mode:
-            return tuple(self._test_config['delta_theta'])
-
 #        if input_yesno(
 #                '\nDo you want to zoom in to reduce memory '
 #                'requirement (y/n)?', 'n'):
@@ -1901,7 +1868,7 @@ class Tomo:
         if self._interactive:
             if delta_theta is None:
                 delta_theta = thetas[1]-thetas[0]
-            print(f'Available \u03b8 range: [{thetas[0]}, {thetas[-1]}]')
+            print(f'\nAvailable \u03b8 range: [{thetas[0]}, {thetas[-1]}]')
             print(f'Current \u03b8 interval: {delta_theta}')
             if input_yesno(
                     'Do you want to change the \u03b8 interval to reduce the '
@@ -1916,109 +1883,139 @@ class Tomo:
 
         return zoom_perc, delta_theta
 
-    def _gen_tomo(self, nxentry, reduced_data, image_key):
+    def _gen_tomo(
+            self, nxentry, reduced_data, image_key, calibrate_center_rows):
         """Generate tomography fields."""
         # Third party modules
         from numexpr import evaluate
         from scipy.ndimage import zoom
 
-        # Get full bright field
-        tbf = np.asarray(reduced_data.data.bright_field)
+        # Get dark field
+        if 'dark_field' in reduced_data.data:
+            tdf = reduced_data.data.dark_field.nxdata
+        else:
+            self._logger.warning('Dark field unavailable')
+            tdf = None
+
+        # Get bright field
+        tbf = reduced_data.data.bright_field.nxdata
         tbf_shape = tbf.shape
 
+        # Subtract dark field
+        if tdf is not None:
+            try:
+                with SetNumexprThreads(self._num_core):
+                    evaluate('tbf-tdf', out=tbf)
+            except TypeError as e:
+                sys_exit(
+                    f'\nA {type(e).__name__} occured while subtracting '
+                    'the dark field with num_expr.evaluate()'
+                    '\nTry reducing the detector range'
+                    f'\n(currently img_row_bounds = {img_row_bounds}, and '
+                    f'img_column_bounds = {img_column_bounds})\n')
+
         # Get image bounds
-        img_row_bounds = tuple(
-            reduced_data.get('img_row_bounds', (0, tbf_shape[0])))
+        img_row_bounds = tuple(reduced_data.get('img_row_bounds'))
         img_column_bounds = tuple(
             reduced_data.get('img_column_bounds', (0, tbf_shape[1])))
 
-        # Get resized dark field
-        if 'dark_field' in reduced_data.data:
-            tdf = np.asarray(
-                reduced_data.data.dark_field)[
+        # Check if this run is a rotation axis calibration
+        # and resize dark and bright fields accordingly
+        if calibrate_center_rows:
+            if tdf is not None:
+                tdf = tdf[calibrate_center_rows,:]
+            tbf = tbf[calibrate_center_rows,:]
+        else:
+            if (img_row_bounds != (0, tbf.shape[0])
+                    or img_column_bounds != (0, tbf.shape[1])):
+                if tdf is not None:
+                    tdf = tdf[
+                        img_row_bounds[0]:img_row_bounds[1],
+                        img_column_bounds[0]:img_column_bounds[1]]
+                tbf = tbf[
                     img_row_bounds[0]:img_row_bounds[1],
                     img_column_bounds[0]:img_column_bounds[1]]
-        else:
-            self._logger.warning('Dark field unavailable')
-            tdf = None
-
-        # Resize bright field
-        if (img_row_bounds != (0, tbf.shape[0])
-                or img_column_bounds != (0, tbf.shape[1])):
-            tbf = tbf[
-                img_row_bounds[0]:img_row_bounds[1],
-                img_column_bounds[0]:img_column_bounds[1]]
 
         # Get thetas (in degrees)
-        thetas = np.asarray(reduced_data.rotation_angle)
+        thetas = reduced_data.rotation_angle.nxdata
 
         # Get or create image mask
         image_mask = reduced_data.get('image_mask')
         if image_mask is None:
-            image_mask = np.ones(len(thetas), dtype=bool)
+            image_mask = [True]*len(thetas)
         else:
-            image_mask = np.asarray(image_mask)
+            image_mask = list(image_mask)
 
         # Get the tomography images
         field_indices_all = [
             index for index, key in enumerate(image_key) if key == 0]
         if not field_indices_all:
             raise ValueError('Tomography field(s) unavailable')
-        z_translation_all = np.asarray(
-            nxentry.sample.z_translation)[field_indices_all]
+        z_translation_all = nxentry.sample.z_translation[
+            field_indices_all]
         z_translation_levels = sorted(list(set(z_translation_all)))
         num_tomo_stacks = len(z_translation_levels)
+        if calibrate_center_rows:
+            center_stack_index = num_tomo_stacks//2
         tomo_stacks = num_tomo_stacks*[np.array([])]
         horizontal_shifts = []
         vertical_shifts = []
-        tomo_stacks = []
         for i, z_translation in enumerate(z_translation_levels):
+            if calibrate_center_rows and i != center_stack_index:
+                continue
             try:
                 field_indices = [
-                    field_indices_all[index]
-                    for index, z in enumerate(z_translation_all)
+                    field_indices_all[i]
+                    for i, z in enumerate(z_translation_all)
                     if z == z_translation]
-                field_indices_masked = np.asarray(field_indices)[image_mask]
-                horizontal_shift = list(set(np.asarray(
-                    nxentry.sample.x_translation)[field_indices_masked]))
+                field_indices_masked = [
+                     v for i, v in enumerate(field_indices) if image_mask[i]]
+                horizontal_shift = list(
+                    set(nxentry.sample.x_translation[field_indices_masked]))
                 assert len(horizontal_shift) == 1
                 horizontal_shifts += horizontal_shift
-                vertical_shift = list(set(np.asarray(
-                    nxentry.sample.z_translation)[field_indices_masked]))
+                vertical_shift = list(
+                    set(nxentry.sample.z_translation[field_indices_masked]))
                 assert len(vertical_shift) == 1
                 vertical_shifts += vertical_shift
-                sequence_numbers = np.asarray(
-                    nxentry.instrument.detector.sequence_number)[
-                        field_indices]
+                sequence_numbers = \
+                    nxentry.instrument.detector.sequence_number[field_indices]
                 assert (list(sequence_numbers)
                         == list(range((len(sequence_numbers)))))
-                tomo_stack = np.asarray(
-                    nxentry.instrument.detector.data)[field_indices_masked]
+                tomo_stack = nxentry.instrument.detector.data[
+                    field_indices_masked]
             except:
                 raise RuntimeError('Unable to load the tomography images '
                                    f'for stack {i}')
-            tomo_stacks.append(tomo_stack)
-            if not i:
-                tomo_stack_shape = tomo_stack.shape
-            else:
-                assert tomo_stack_shape == tomo_stack.shape
+            tomo_stacks[i] = tomo_stack
+            if not calibrate_center_rows:
+                if not i:
+                    tomo_stack_shape = tomo_stack.shape
+                else:
+                    assert tomo_stack_shape == tomo_stack.shape
 
         row_pixel_size = float(nxentry.instrument.detector.row_pixel_size)
         column_pixel_size = float(
             nxentry.instrument.detector.column_pixel_size)
-        reduced_tomo_stacks = []
+        reduced_tomo_stacks = num_tomo_stacks*[np.array([])]
+        tomo_stack_shape = None
         for i, tomo_stack in enumerate(tomo_stacks):
+            if not tomo_stack.size:
+                continue
             # Resize the tomography images
             # Right now the range is the same for each set in the stack
-            assert len(thetas) == tomo_stack.shape[0]
-            if (img_row_bounds != (0, tomo_stack.shape[1])
-                    or img_column_bounds != (0, tomo_stack.shape[2])):
-                tomo_stack = tomo_stack[
-                    :,img_row_bounds[0]:img_row_bounds[1],
-                    img_column_bounds[0]:img_column_bounds[1]].astype(
+            if calibrate_center_rows:
+                tomo_stack = tomo_stack[:,calibrate_center_rows,:].astype(
                         'float64', copy=False)
             else:
-                tomo_stack = tomo_stack.astype('float64', copy=False)
+                if (img_row_bounds != (0, tomo_stack.shape[1])
+                        or img_column_bounds != (0, tomo_stack.shape[2])):
+                    tomo_stack = tomo_stack[
+                        :,img_row_bounds[0]:img_row_bounds[1],
+                        img_column_bounds[0]:img_column_bounds[1]].astype(
+                            'float64', copy=False)
+                else:
+                    tomo_stack = tomo_stack.astype('float64', copy=False)
 
             # Subtract dark field
             if tdf is not None:
@@ -2059,7 +2056,7 @@ class Tomo:
 
             # Downsize tomography stack to smaller size
             tomo_stack = tomo_stack.astype('float32', copy=False)
-            if not self._test_mode and (self._save_figs or self._save_only):
+            if self._save_figs or self._save_only:
                 theta = round(thetas[0], 2)
                 if len(tomo_stacks) == 1:
                     title = r'Reduced data, $\theta$ = 'f'{theta}'
@@ -2069,7 +2066,7 @@ class Tomo:
                     name = f'reduced_data_stack_{i}_theta_{theta}'
                 quick_imshow(
                     tomo_stack[0,:,:], title=title, name=name,
-                    path=self._output_folder, save_fig=self._save_figs,
+                    path=self._outputdir, save_fig=self._save_figs,
                     save_only=self._save_only, block=self._block)
             zoom_perc = 100
             if zoom_perc != 100:
@@ -2081,31 +2078,31 @@ class Tomo:
                     tomo_zoom_list.append(tomo_zoom)
                 tomo_stack = np.stack(tomo_zoom_list)
                 self._logger.info(f'Zooming in took {time()-t0:.2f} seconds')
+                title = f'red stack {zoom_perc}p theta ' \
+                    f'{round(thetas[0], 2)+0}'
+                quick_imshow(
+                    tomo_stack[0,:,:], title=title, 
+                    path=self._outputdir, save_fig=self._save_figs,
+                    save_only=self._save_only, block=self._block)
                 del tomo_zoom_list
-                if not self._test_mode:
-                    title = f'red stack {zoom_perc}p theta ' \
-                        f'{round(thetas[0], 2)+0}'
-                    quick_imshow(
-                        tomo_stack[0,:,:], title=title, 
-                        path=self._output_folder, save_fig=self._save_figs,
-                        save_only=self._save_only, block=self._block)
-
-            # Save test data to file
-            if self._test_mode:
-                row_index = int(tomo_stack.shape[1]/2)
-                np.savetxt(
-                    f'{self._output_folder}/red_stack_{i}.txt',
-                    tomo_stack[:,row_index,:], fmt='%.6e')
 
             # Combine resized stacks
-            reduced_tomo_stacks.append(tomo_stack)
+            reduced_tomo_stacks[i] = tomo_stack
+            if tomo_stack_shape is None:
+                tomo_stack_shape = tomo_stack.shape
+            else:
+                assert tomo_stack_shape == tomo_stack.shape
+
+        for i, stack in enumerate(reduced_tomo_stacks):
+            if not stack.size:
+                reduced_tomo_stacks[i] = np.zeros(tomo_stack_shape)
 
         # Add tomo field info to reduced data NXprocess
-        reduced_data.x_translation = np.asarray(horizontal_shifts)
+        reduced_data.x_translation = horizontal_shifts
         reduced_data.x_translation.units = 'mm'
-        reduced_data.z_translation = np.asarray(vertical_shifts)
+        reduced_data.z_translation = vertical_shifts
         reduced_data.z_translation.units = 'mm'
-        reduced_data.data.tomo_fields = np.asarray(reduced_tomo_stacks)
+        reduced_data.data.tomo_fields = reduced_tomo_stacks
         reduced_data.data.attrs['signal'] = 'tomo_fields'
 
         if tdf is not None:
@@ -2115,235 +2112,467 @@ class Tomo:
         return reduced_data
 
     def _find_center_one_plane(
-            self, sinogram, row, thetas, eff_pixel_size, cross_sectional_dim,
-            path=None, num_core=1, search_range=None, search_step=None,
-            gaussian_sigma=None, ring_width=None):
-        """Find center for a single tomography plane."""
+            self, tomo_stacks, stack_index, row, offset_row, thetas,
+            eff_pixel_size, cross_sectional_dim, path=None, num_core=1,
+            center_offset_min=-50, center_offset_max=50,
+            center_search_range=None, gaussian_sigma=None, ring_width=None,
+            prev_center_offset=None):
+        """
+        Find center for a single tomography plane.
+
+        tomo_stacks data axes order: stack,theta,row,column
+        thetas in radians
+        """
         # Third party modules
         import matplotlib.pyplot as plt
-        from tomopy import find_center_vo
+        from tomopy import (
+#            find_center,
+            find_center_vo,
+            find_center_pc,
+        )
 
         if not gaussian_sigma:
             gaussian_sigma = None
         if not ring_width:
             ring_width = None
-        # Try automatic center finding routines for initial value
-        # sinogram index order: theta,column
-        # need column,theta for iradon, so take transpose
-        sinogram = np.asarray(sinogram)
-        sinogram_t = sinogram.T
-        center = sinogram.shape[1]/2
-
-        # Try using Nghia Vo’s method
+
+        # Get the sinogram for the selected plane
+        sinogram = tomo_stacks[stack_index,:,offset_row,:]
+        center_offset_range = sinogram.shape[1]/2
+
+        # Try Nghia Vo's method to find the center
         t0 = time()
+        if center_offset_min is None:
+            center_offset_min = -50
+        if center_offset_max is None:
+            center_offset_max = 50
         if num_core > NUM_CORE_TOMOPY_LIMIT:
             self._logger.debug(
-                f'Running find_center_vo on {NUM_CORE_TOMOPY_LIMIT} cores ...')
+                f'Running find_center_vo on {NUM_CORE_TOMOPY_LIMIT} '
+                'cores ...')
             tomo_center = find_center_vo(
-                sinogram, ncore=NUM_CORE_TOMOPY_LIMIT)
+                sinogram, ncore=NUM_CORE_TOMOPY_LIMIT, smin=center_offset_min,
+                smax=center_offset_max)
         else:
-            tomo_center = find_center_vo(sinogram, ncore=num_core)
+            tomo_center = find_center_vo(
+                sinogram, ncore=num_core, smin=center_offset_min,
+                smax=center_offset_max)
         self._logger.info(
-            f'Finding center using Nghia Vo’s method took {time()-t0:.2f} '
+            f'Finding center using Nghia Vo\'s method took {time()-t0:.2f} '
             'seconds')
-        center_offset_vo = float(tomo_center-center)
+        center_offset_vo = float(tomo_center-center_offset_range)
         self._logger.info(
-            f'Center at row {row} using Nghia Vo’s method = '
+            f'Center at row {row} using Nghia Vo\'s method = '
             f'{center_offset_vo:.2f}')
 
+        selected_center_offset = center_offset_vo
         if self._interactive or self._save_figs:
 
-            # Reconstruct the plane for Nghia Vo’s center offset
+            # Try Guizar-Sicairos's phase correlation method to find
+            # the center
             t0 = time()
-            recon_plane = self._reconstruct_one_plane(
-                sinogram_t, center_offset_vo, thetas, eff_pixel_size,
-                cross_sectional_dim, False, num_core, gaussian_sigma,
-                ring_width)
+            tomo_center = find_center_pc(
+                tomo_stacks[stack_index,0,:,:],
+                tomo_stacks[stack_index,-1,:,:])
+            self._logger.info(
+                'Finding center using Guizar-Sicairos\'s phase correlation '
+                f'method took {time()-t0:.2f} seconds')
+            center_offset_pc = float(tomo_center-center_offset_range)
             self._logger.info(
-                f'Reconstructing row {row} took {time()-t0:.2f} seconds')
-            recon_edges = [self._get_edges_one_plane(recon_plane)]
-            fig, accept, selected_center_offset = self._select_center_offset(
-                recon_edges, row, center_offset_vo)
+                f'Center at row {row} using Guizar-Sicairos\'s image entropy '
+                f'method = {center_offset_pc:.2f}')
+
+            # Try Donath's image entropy method to find the center
+# Skip this method, it seems flawed somehow or I'm doing something wrong
+#            t0 = time()
+#            tomo_center = find_center(
+#                tomo_stacks[stack_index,:,:,:], thetas,
+#                ind=offset_row)
+#            self._logger.info(
+#                'Finding center using Donath\'s image entropy method took '
+#                f'{time()-t0:.2f} seconds')
+#            center_offset_ie = float(tomo_center-center_offset_range)
+#            self._logger.info(
+#                f'Center at row {row} using Donath\'s image entropy method = '
+#                f'{center_offset_ie:.2f}')
+
+            # Reconstruct the plane for the Nghia Vo's center
+            t0 = time()
+            center_offsets = [center_offset_vo]
+            fig_titles = [f'Vo\'s method: center offset = '
+                         f'{center_offset_vo:.2f}']
+            recon_planes = [self._reconstruct_planes(
+                    sinogram, center_offset_vo, thetas, num_core=num_core,
+                    gaussian_sigma=gaussian_sigma, ring_width=ring_width)]
+            self._logger.info(
+                f'Reconstructing row {row} with center at '
+                f'{center_offset_vo} took {time()-t0:.2f} seconds')
+
+            # Reconstruct the plane for the Guizar-Sicairos's center
+            t0 = time()
+            center_offsets.append(center_offset_pc)
+            fig_titles.append(f'Guizar-Sicairos\'s method: center offset = '
+                          f'{center_offset_pc:.2f}')
+            recon_planes.append(self._reconstruct_planes(
+                    sinogram, center_offset_pc, thetas, num_core=num_core,
+                    gaussian_sigma=gaussian_sigma, ring_width=ring_width))
+            self._logger.info(
+                f'Reconstructing row {row} with center at '
+                f'{center_offset_pc} took {time()-t0:.2f} seconds')
+
+            # Reconstruct the plane for the Donath's center
+#            t0 = time()
+#            center_offsets.append(center_offset_ie)
+#            fig_titles.append(f'Donath\'s method: center offset = '
+#                              f'{center_offset_ie:.2f}')
+#            recon_planes.append(self._reconstruct_planes(
+#                sinogram, center_offset_ie, thetas, num_core=num_core,
+#                gaussian_sigma=gaussian_sigma, ring_width=ring_width))
+#            self._logger.info(
+#                f'Reconstructing row {row} with center at '
+#                f'{center_offset_ie} took {time()-t0:.2f} seconds')
+
+            # Reconstruct the plane at the previous row's center
+            if (prev_center_offset is not None
+                    and prev_center_offset not in center_offsets):
+                t0 = time()
+                center_offsets.append(prev_center_offset)
+                fig_titles.append(f'Previous row\'s: center offset = '
+                                  f'{prev_center_offset:.2f}')
+                recon_planes.append(self._reconstruct_planes(
+                    sinogram, prev_center_offset, thetas, num_core=num_core,
+                    gaussian_sigma=gaussian_sigma, ring_width=ring_width))
+                self._logger.info(
+                    f'Reconstructing row {row} with center at '
+                    f'{prev_center_offset} took {time()-t0:.2f} seconds')
+
+#            t0 = time()
+#            recon_edges = []
+#            for recon_plane in recon_planes:
+#                recon_edges.append(self._get_edges_one_plane(recon_plane))
+#            print(f'\nGetting edges for row {row} with centers at '
+#                  f'{center_offsets} took {time()-t0:.2f} seconds\n')
+
+            # Select the best center
+            fig, accept, selected_center_offset = \
+                self._select_center_offset(
+                    recon_planes, row, center_offsets, default_offset_index=0,
+                    fig_titles=fig_titles, search_button=False,
+                    include_all_bad=True)
+
             # Plot results
             if self._save_figs:
                 fig.savefig(
                     os_path.join(
-                        self._output_folder,
-                        f'edges_default_center_row_{row}.png'))
+                        self._outputdir,
+                        f'recon_row_{row}_default_centers.png'))
             plt.close()
 
-
-            # Perform center finding search
-            center_offsets = [center_offset_vo]
-            step_size = 4
-            indices = 3*[-1]
-            prev_index = None
-            up = True
-            while not accept and step_size:
-                selected_center_offset = round(selected_center_offset)
+        # Create reconstructions for a specified search range
+        if self._interactive:
+            if (center_search_range is None
+                    and input_yesno('\nDo you want to reconstruct images '
+                                    'for a range of rotation centers', 'n')):
+                center_search_range = input_num_list(
+                    'Enter up to 3 numbers (start, end, step), '
+                    '(range, step), or range', remove_duplicates=False,
+                    sort=False)
+        if center_search_range is not None:
+            if len(center_search_range) != 3:
+                search_range = center_search_range[0]
+                if len(center_search_range) == 1:
+                    step = search_range
+                else:
+                    step = center_search_range[1]
+                if selected_center_offset == 'all bad':
+                    center_search_range = [
+                        - search_range/2, search_range/2, step]
+                else:
+                    center_search_range = [
+                        selected_center_offset - search_range/2,
+                        selected_center_offset + search_range/2,
+                        step]
+            center_search_range[1] += 1 # Make upper bound inclusive
+            search_center_offsets = list(np.arange(*center_search_range))
+            search_recon_planes = self._reconstruct_planes(
+                sinogram, search_center_offsets, thetas, num_core=num_core,
+                gaussian_sigma=gaussian_sigma, ring_width=ring_width)
+            for i, center in enumerate(search_center_offsets):
+                title = f'Reconstruction for row {row}, center offset: ' \
+                        f'{center:.2f}'
+                name = f'recon_row_{row}_center_{center:.2f}.png'
+                if self._interactive:
+                    save_only = False
+                    block = True
+                else:
+                    save_only = True
+                    block = False
+                quick_imshow(
+                    search_recon_planes[i], title=title, row_label='y',
+                    column_label='x', path=self._outputdir, name=name,
+                    save_only=save_only, save_fig=True, block=block)
+                center_offsets.append(center)
+                recon_planes.append(search_recon_planes[i])
+
+        # Perform an interactive center finding search
+        calibrate_interactively = False
+        if self._interactive:
+            if selected_center_offset == 'all bad':
+                calibrate_interactively = input_yesno(
+                    '\nDo you want to perform an interactive search to '
+                    'calibrate the rotation center (y/n)?', 'n')
+            else:
+                calibrate_interactively = input_yesno(
+                    '\nDo you want to perform an interactive search to '
+                    'calibrate the rotation center around the selected value '
+                    f'of {selected_center_offset} (y/n)?', 'n')
+        if calibrate_interactively:
+            include_all_bad = True
+            low = None
+            upp = None
+            if selected_center_offset == 'all bad':
+                selected_center_offset = None
+            selected_center_offset = input_num(
+                '\nEnter the initial center offset in the center calibration '
+                'search', ge=-center_offset_range, le=center_offset_range,
+                default=selected_center_offset)
+            max_step_size = min(
+                center_offset_range+selected_center_offset,
+                center_offset_range-selected_center_offset-1)
+            max_step_size = 1 << int(np.log2(max_step_size))-1
+            step_size = input_int(
+                '\nEnter the intial step size in the center calibration '
+                'search (will be truncated to the nearest lower power of 2)',
+                ge=2, le=max_step_size, default=4)
+            step_size = 1 << int(np.log2(step_size))
+            selected_center_offset_prev = round(selected_center_offset)
+            while step_size:
                 preselected_offsets = (
-                    selected_center_offset-step_size,
-                    selected_center_offset,
-                    selected_center_offset+step_size)
+                    selected_center_offset_prev-step_size,
+                    selected_center_offset_prev,
+                    selected_center_offset_prev+step_size)
+                indices = []
                 for i, preselected_offset in enumerate(preselected_offsets):
                     if preselected_offset in center_offsets:
-                        indices[i] = center_offsets.index(preselected_offset)
+                        indices.append(
+                            center_offsets.index(preselected_offset))
                     else:
-                        recon_plane = self._reconstruct_one_plane(
-                            sinogram_t, preselected_offset, thetas,
-                            eff_pixel_size, cross_sectional_dim, False,
-                            num_core, gaussian_sigma, ring_width)
-                        indices[i] = len(center_offsets)
+                        indices.append(len(center_offsets))
                         center_offsets.append(preselected_offset)
-                        recon_edges.append(
-                            self._get_edges_one_plane(recon_plane))
+                        recon_planes.append(self._reconstruct_planes(
+                            sinogram, preselected_offset, thetas,
+                            num_core=num_core, gaussian_sigma=gaussian_sigma,
+                            ring_width=ring_width))
                 fig, accept, selected_center_offset = \
                     self._select_center_offset(
-                        [recon_edges[i] for i in indices],
-                        row, preselected_offsets, center_offset_vo)
-                index = preselected_offsets.index(selected_center_offset)
-                if index != 1 and prev_index in (None, index) and up:
-                    step_size *=2
-                else:
-                    step_size = int(step_size/2)
-                    up = False
-                prev_index = index
+                        [recon_planes[i] for i in indices],
+                        row, preselected_offsets, default_offset_index=1,
+                        include_all_bad=include_all_bad)
                 # Plot results
                 if self._save_figs:
                     fig.savefig(
                         os_path.join(
-                            self._output_folder,
-                            f'edges_center_{row}_{min(preselected_offsets)}_'\
+                            self._outputdir,
+                            f'recon_row_{row}_center_range_'
+                                f'{min(preselected_offsets)}_'\
                                 f'{max(preselected_offsets)}.png'))
                 plt.close()
+                if accept and input_yesno(
+                        f'Accept center offset {selected_center_offset} '
+                        f'for row {row}? (y/n)', 'y'):
+                    break
+                if selected_center_offset   == 'all bad':
+                    step_size *=2
+                else:
+                    if selected_center_offset == preselected_offsets[0]:
+                        upp = preselected_offsets[1]
+                    elif selected_center_offset == preselected_offsets[1]:
+                        low = preselected_offsets[0]
+                        upp = preselected_offsets[2]
+                    else:
+                        low = preselected_offsets[1]
+                    if None in (low, upp):
+                        step_size *= 2
+                    else:
+                        step_size = step_size//2
+                        include_all_bad = False
+                    selected_center_offset_prev = round(selected_center_offset)
+                if step_size > max_step_size:
+                    self._logger.warning(
+                        'Exceeding maximum step size of {max_step_size}')
+                    step_size = max_step_size
+
+            # Collect info for the currently selected center
+            recon_planes = [recon_planes[
+                center_offsets.index(selected_center_offset)]]
+            center_offsets = [selected_center_offset]
+            fig_titles = [f'Reconstruction for center offset = '
+                         f'{selected_center_offset:.2f}']
+
+            # Try Nghia Vo's method with the selected center
+            step_size = min(step_size, 10)
+            center_offset_min = selected_center_offset-step_size
+            center_offset_max = selected_center_offset+step_size
+            if num_core > NUM_CORE_TOMOPY_LIMIT:
+                self._logger.debug(
+                    f'Running find_center_vo on {NUM_CORE_TOMOPY_LIMIT} '
+                    'cores ...')
+                tomo_center = find_center_vo(
+                    sinogram, ncore=NUM_CORE_TOMOPY_LIMIT,
+                    smin=center_offset_min, smax=center_offset_max)
+            else:
+                tomo_center = find_center_vo(
+                    sinogram, ncore=num_core, smin=center_offset_min,
+                    smax=center_offset_max)
+            center_offset_vo = float(tomo_center-center_offset_range)
+            self._logger.info(
+                f'Center at row {row} using Nghia Vo\'s method = '
+                f'{center_offset_vo:.2f}')
+
+            # Reconstruct the plane for the Nghia Vo's center
+            center_offsets.append(center_offset_vo)
+            fig_titles.append(f'Vo\'s method: center offset = '
+                         f'{center_offset_vo:.2f}')
+            recon_planes.append(self._reconstruct_planes(
+                    sinogram, center_offset_vo, thetas, num_core=num_core,
+                    gaussian_sigma=gaussian_sigma, ring_width=ring_width))
+
+            # Select the best center
+            fig, accept, selected_center_offset = \
+                self._select_center_offset(
+                    recon_planes, row, center_offsets, default_offset_index=0,
+                    fig_titles=fig_titles, search_button=False)
 
-        # Select center location
-        if self._interactive:
-            center_offset = selected_center_offset
-        else:
-            center_offset = center_offset_vo
-
-        del sinogram_t
-        if recon_plane is not None:
-            del recon_plane
+            # Plot results
+            if self._save_figs:
+                fig.savefig(
+                    os_path.join(
+                        self._outputdir,
+                        f'recon_row_{row}_center_'
+                            f'{selected_center_offset:.2f}.png'))
+            plt.close()
 
-        return float(center_offset)
+        del sinogram
+        del recon_planes
 
-    def _reconstruct_one_plane(
-            self, tomo_plane_t, center_offset, thetas, eff_pixel_size,
-            cross_sectional_dim, plot_sinogram=False, num_core=1,
+        # Return the center location
+        if self._interactive:
+            if selected_center_offset == 'all bad':
+                print('\nUnable to successfully calibrate center axis')
+                selected_center_offset = input_num(
+                    'Enter the center offset for row {row}',
+                    ge=-center_offset_range, le=center_offset_range)
+            return float(selected_center_offset)
+        return float(center_offset_vo)
+
+    def _reconstruct_planes(
+            self, tomo_planes, center_offset, thetas, num_core=1,
             gaussian_sigma=None, ring_width=None):
-        """Invert the sinogram for a single tomography plane."""
+        """Invert the sinogram for a single or multiple tomography
+        planes using tomopy's recon routine."""
         # Third party modules
         from scipy.ndimage import gaussian_filter
-        from skimage.transform import iradon
-        from tomopy import misc
-
-        # tomo_plane_t index order: column,theta
-        two_offset = 2 * int(np.round(center_offset))
-        two_offset_abs = np.abs(two_offset)
-        # Add 10% slack to max_rad to avoid edge effects
-        max_rad = int(0.55 * (cross_sectional_dim/eff_pixel_size))
-        if max_rad > 0.5*tomo_plane_t.shape[0]:
-            max_rad = 0.5*tomo_plane_t.shape[0]
-        dist_from_edge = max(1, int(np.floor(
-            (tomo_plane_t.shape[0] - two_offset_abs) / 2.) - max_rad))
-        if two_offset >= 0:
-            self._logger.debug(
-                f'sinogram range = [{two_offset+dist_from_edge}, '
-                f'{-dist_from_edge}]')
-            sinogram = tomo_plane_t[
-                two_offset+dist_from_edge:-dist_from_edge,:]
-        else:
-            self._logger.debug(
-                f'sinogram range = [{dist_from_edge}, '
-                f'{two_offset-dist_from_edge}]')
-            sinogram = tomo_plane_t[dist_from_edge:two_offset-dist_from_edge,:]
-        if plot_sinogram:
-            quick_imshow(
-                sinogram.T,
-                title=f'Sinogram for a center offset of {center_offset:.2f}',
-                name=f'sinogram_center_offset{center_offset:.2f}',
-                path=self._output_folder, save_fig=self._save_figs,
-                save_only=self._save_only, block=self._block, aspect='auto')
+        from tomopy import (
+            misc,
+            recon,
+        )
 
-        # Inverting sinogram
-        t0 = time()
-        recon_sinogram = iradon(sinogram, theta=thetas, circle=True)
-        self._logger.info(f'Inverting sinogram took {time()-t0:.2f} seconds')
-        del sinogram
+        # Reconstruct the planes
+        # tomo_planes axis data order: (row,)theta,column
+        # thetas in radians
+        if isinstance(center_offset, (int, float)):
+            tomo_planes = np.expand_dims(tomo_planes, 0)
+            center_offset = center_offset + tomo_planes.shape[2]/2
+        elif is_num_series(center_offset):
+            tomo_planes = np.array([tomo_planes]*len(center_offset))
+            center_offset = np.asarray(center_offset) + tomo_planes.shape[2]/2
+        else:
+            raise ValueError(
+                f'Invalid parameter center_offset ({center_offset})')
+        recon_planes = recon(
+            tomo_planes, thetas, center=center_offset, sinogram_order=True,
+            algorithm='gridrec', ncore=num_core)
 
         # Performing Gaussian filtering and removing ring artifacts
         if gaussian_sigma is not None and gaussian_sigma:
-            recon_sinogram = gaussian_filter(
-                recon_sinogram, gaussian_sigma, mode='nearest')
-        recon_clean = np.expand_dims(recon_sinogram, axis=0)
-        del recon_sinogram
+            recon_planes = gaussian_filter(
+                recon_planes, gaussian_sigma, mode='nearest')
         if ring_width is not None and ring_width:
-            recon_clean = misc.corr.remove_ring(
-                recon_clean, rwidth=ring_width, ncore=num_core)
-
-        return recon_clean
-
-    def _get_edges_one_plane(self, recon_plane):
-        """
-        Create an "edges plot" image for a single reconstructed
-        tomography data plane.
-        """
-        # Third party modules
-        from skimage.restoration import denoise_tv_chambolle
-
-        vis_parameters = None  # self._config.get('vis_parameters')
-        if vis_parameters is None:
-            weight = 0.1
-        else:
-            weight = vis_parameters.get('denoise_weight', 0.1)
-            if not is_num(weight, ge=0.):
-                self._logger.warning(
-                    f'Invalid weight ({weight}) in _get_edges_one_plane, '
-                    'set to a default of 0.1')
-                weight = 0.1
-        return denoise_tv_chambolle(recon_plane, weight=weight)[0]
+            recon_planes = misc.corr.remove_ring(
+                recon_planes, rwidth=ring_width, ncore=num_core)
+
+        # Apply a circular mask
+        recon_planes = misc.corr.circ_mask(recon_planes, axis=0)
+
+        return np.squeeze(recon_planes)
+
+#    def _get_edges_one_plane(self, recon_plane):
+#        """
+#        Create an "edges plot" image for a single reconstructed
+#        tomography data plane.
+#        """
+#        # Third party modules
+#        from skimage.restoration import denoise_tv_chambolle
+#
+#        vis_parameters = None  # RV self._config.get('vis_parameters')
+#        if vis_parameters is None:
+#            weight = 0.1
+#        else:
+#            weight = vis_parameters.get('denoise_weight', 0.1)
+#            if not is_num(weight, ge=0.):
+#                self._logger.warning(
+#                    f'Invalid weight ({weight}) in _get_edges_one_plane, '
+#                    'set to a default of 0.1')
+#                weight = 0.1
+#        return denoise_tv_chambolle(recon_plane, weight=weight)
 
     def _select_center_offset(
-            self, recon_edges, row, preselected_offsets,
-            center_offset_vo=None):
-        """Select a center offset value from an "edges plot" image
+            self, recon_planes, row, preselected_offsets,
+            default_offset_index=0, fig_titles=None, search_button=True,
+            include_all_bad=False):
+        """Select a center offset value from reconstructed images
         for a single reconstructed tomography data plane."""
         # Third party modules
         import matplotlib.pyplot as plt
         from matplotlib.widgets import RadioButtons, Button
-        from matplotlib.widgets import Button
 
         def select_offset(offset):
             """Callback function for the "Select offset" input."""
-            selected_offset.append(
-                ((False,
-                  preselected_offsets[preselected_offsets.index(
-                      float(radio_btn.value_selected))])))
-            plt.close()
+            pass
 
-        def reject(event):
-            """Callback function for the "Reject" button."""
-            selected_offset.append((False, preselected_offsets[0]))
+        def search(event):
+            """Callback function for the "Search" button."""
+            if num_plots == 1:
+                selected_offset.append(
+                    (False, preselected_offsets[default_offset_index]))
+            else:
+                offset = radio_btn.value_selected
+                if offset in ('both bad', 'all bad'):
+                    selected_offset.append((False, 'all bad'))
+                else:
+                    selected_offset.append((False, float(offset)))
             plt.close()
 
         def accept(event):
             """Callback function for the "Accept" button."""
             if num_plots == 1:
-                selected_offset.append((True, preselected_offsets[0]))
-            else:
                 selected_offset.append(
-                    ((False,
-                      preselected_offsets[preselected_offsets.index(
-                          float(radio_btn.value_selected))])))
+                    (True, preselected_offsets[default_offset_index]))
+            else:
+                offset = radio_btn.value_selected
+                if offset in ('both bad', 'all bad'):
+                    selected_offset.append((False, 'all bad'))
+                else:
+                    selected_offset.append((True, float(offset)))
             plt.close()
 
-        if not isinstance(recon_edges, (tuple, list)):
-            recon_edges = [recon_edges]
+        if not isinstance(recon_planes, (tuple, list)):
+            recon_planes = [recon_planes]
         if not isinstance(preselected_offsets, (tuple, list)):
             preselected_offsets = [preselected_offsets]
-        assert len(recon_edges) == len(preselected_offsets)
+        assert len(recon_planes) == len(preselected_offsets)
+        if fig_titles is not None:
+            assert len(fig_titles) == len(preselected_offsets)
 
         selected_offset = []
 
@@ -2355,55 +2584,62 @@ class Tomo:
                           'horizontalalignment': 'center',
                           'verticalalignment': 'bottom'}
 
-        num_plots = len(recon_edges)
+        num_plots = len(recon_planes)
         if num_plots == 1:
             fig, axs = plt.subplots(figsize=(11, 8.5))
             axs = [axs]
-            vmax = np.max(recon_edges[0][:,:])
+            vmax = np.max(recon_planes[0][:,:])
         else:
             fig, axs = plt.subplots(ncols=num_plots, figsize=(17, 8.5))
             axs = list(axs)
-            vmax = np.max(recon_edges[1][:,:])
-        for i, (ax, recon_edge, preselected_offset) in enumerate(zip(
-                axs, recon_edges, preselected_offsets)):
-            ax.imshow(recon_edge, vmin=-vmax, vmax=vmax, cmap='gray')
-            if num_plots == 1:
-                ax.set_title(
-                    f'Reconstruction for row {row}, center offset: ' \
-                    f'{preselected_offset:.2f}', fontsize='x-large')
-            else:
-                ax.set_title(
-                    f'Center offset: {preselected_offset}',
-                    fontsize='x-large')
+            vmax = np.max(recon_planes[1][:,:])
+        for i, (ax, recon_plane, preselected_offset) in enumerate(zip(
+                axs, recon_planes, preselected_offsets)):
+            ax.imshow(recon_plane, vmin=-vmax, vmax=vmax, cmap='gray')
+            if fig_titles is None:
+                if num_plots == 1:
+                    ax.set_title(
+                        f'Reconstruction for row {row}, center offset: ' \
+                        f'{preselected_offset:.2f}', fontsize='x-large')
+                else:
+                    ax.set_title(
+                        f'Center offset: {preselected_offset}',
+                        fontsize='x-large')
             ax.set_xlabel('x', fontsize='x-large')
             if not i:
                 ax.set_ylabel('y', fontsize='x-large')
+        if fig_titles is not None:
+            for (ax, fig_title) in zip(axs, fig_titles):
+                ax.set_title(fig_title, fontsize='x-large')
 
-        if len(recon_edges) > 1:
-            fig_title = plt.figtext(
-                *title_pos,
-                f'Reconstructions for row {row} (default center offset: '
-                    f'{center_offset_vo})',
-                **title_props)
+        fig_title = plt.figtext(
+            *title_pos, f'Reconstruction for row {row}', **title_props)
+        if num_plots == 1:
             fig_subtitle = plt.figtext(
                 *subtitle_pos,
-                'Select the best offset or press "Accept" to accept the '
-                f'default value of {preselected_offsets[1]}',
+                'Press "Accept" to accept this value or "Reject" if not',
                 **subtitle_props)
         else:
-            fig_title = plt.figtext(
-                *title_pos,
-                'Press "Accept" to accept this value or "Reject" to start a '
-                    'center calibration search',
-                **title_props)
+            if search_button:
+                fig_subtitle = plt.figtext(
+                    *subtitle_pos,
+                    'Select the best offset and press "Accept" to accept or '
+                    '"Search" to continue the search',
+                    **subtitle_props)
+            else:
+                fig_subtitle = plt.figtext(
+                    *subtitle_pos,
+                    'Select the best offset and press "Accept" to accept',
+                    **subtitle_props)
 
         if not self._interactive:
 
-            selected_offset.append((True, preselected_offsets[0]))
+            selected_offset.append(
+                (True, preselected_offsets[default_offset_index]))
 
         else:
 
-            fig.subplots_adjust(bottom=0.2)
+            fig.subplots_adjust(bottom=0.25, top=0.85)
 
             if num_plots == 1:
 
@@ -2412,18 +2648,30 @@ class Tomo:
                     plt.axes([0.15, 0.05, 0.15, 0.075]), 'Reject')
                 reject_cid = reject_btn.on_clicked(reject)
 
-
             else:
 
                 # Setup RadioButtons
                 select_text = plt.figtext(
                     0.225, 0.175, 'Select offset', fontsize='x-large',
                     horizontalalignment='center', verticalalignment='center')
+                if include_all_bad:
+                    if num_plots == 2:
+                        labels = (*preselected_offsets, 'both bad')
+                    else:
+                        labels = (*preselected_offsets, 'all bad')
+                else:
+                    labels = preselected_offsets
                 radio_btn = RadioButtons(
                     plt.axes([0.175, 0.05, 0.1, 0.1]),
-                    labels = preselected_offsets, active=1)
+                    labels = labels, active=default_offset_index)
                 radio_cid = radio_btn.on_clicked(select_offset)
 
+                # Setup "Search" button
+                if search_button:
+                    search_btn = Button(
+                        plt.axes([0.4125, 0.05, 0.15, 0.075]), 'Search')
+                    search_cid = search_btn.on_clicked(search)
+
             # Setup "Accept" button
             accept_btn = Button(
                 plt.axes([0.7, 0.05, 0.15, 0.075]), 'Accept')
@@ -2439,6 +2687,9 @@ class Tomo:
             else:
                 radio_btn.disconnect(radio_cid)
                 radio_btn.ax.remove()
+                if search_button:
+                    search_btn.disconnect(search_cid)
+                    search_btn.ax.remove()
             accept_btn.disconnect(accept_cid)
             accept_btn.ax.remove()
 
@@ -2446,16 +2697,20 @@ class Tomo:
             fig_title.remove()
         else:
             fig_title.set_in_layout(True)
-            fig_subtitle.remove()
-            select_text.remove()
+            if self._interactive:
+                select_text.remove()
+        fig_subtitle.remove()
         fig.tight_layout(rect=(0, 0, 1, 0.95))
+        if not selected_offset:# and num_plots == 1:
+            selected_offset.append(
+                (True, preselected_offsets[default_offset_index]))
 
         return fig, *selected_offset[0]
 
     def _reconstruct_one_tomo_stack(
             self, tomo_stack, thetas, center_offsets=None, num_core=1,
-            algorithm='gridrec', secondary_iters=0, remove_stripe_sigma=None,
-            ring_width=None):
+            algorithm='gridrec', secondary_iters=0, gaussian_sigma=None,
+            remove_stripe_sigma=None, ring_width=None):
         """Reconstruct a single tomography stack."""
         # Third party modules
         from tomopy import (
@@ -2465,16 +2720,10 @@ class Tomo:
             recon,
         )
 
-        # tomo_stack order: row,theta,column
-        # input thetas must be in degrees
+        # tomo_stack axis data order: row,theta,column
+        # thetas in radians
         # centers_offset: tomography axis shift in pixels relative
-        #     to column center
-        # RV should we remove stripes?
-        # https://tomopy.readthedocs.io/en/latest/api/tomopy.prep.stripe.html
-        # RV should we remove rings?
-        # https://tomopy.readthedocs.io/en/latest/api/tomopy.misc.corr.html
-        # RV add an option to do (extra) secondary iterations later or
-        #     to do some sort of convergence test?
+        # to column center
         if center_offsets is None:
             centers = np.zeros((tomo_stack.shape[0]))
         elif len(center_offsets) == 2:
@@ -2488,26 +2737,10 @@ class Tomo:
             centers = center_offsets
         centers += tomo_stack.shape[2]/2
 
-#        tomo_recon_stack = []
-#        eff_pixel_size = 0.05
-#        cross_sectional_dim = 20.0 
-#        gaussian_sigma = 0.05
-#        ring_width = 1
-#        for i in range(tomo_stack.shape[0]):
-#            sinogram_t = tomo_stack[i,:,:].T
-#            recon_plane = self._reconstruct_one_plane(
-#                sinogram_t, centers[i], thetas, eff_pixel_size,
-#                cross_sectional_dim, False, num_core, gaussian_sigma,
-#                ring_width)
-#            tomo_recon_stack.append(recon_plane[0,:,:])
-#        tomo_recon_stack = np.asarray(tomo_recon_stack)
-#        return tomo_recon_stack
-
         # Remove horizontal stripe
         # RV prep.stripe.remove_stripe_fw seems flawed for hollow brick
-        #     accross multiple stacks
+        # accross multiple stacks
         if remove_stripe_sigma is not None and remove_stripe_sigma:
-            self._logger.warning('Ignoring remove_stripe_sigma')
             if num_core > NUM_CORE_TOMOPY_LIMIT:
                 tomo_stack = prep.stripe.remove_stripe_fw(
                     tomo_stack, sigma=remove_stripe_sigma,
@@ -2520,7 +2753,7 @@ class Tomo:
         self._logger.debug('Performing initial image reconstruction')
         t0 = time()
         tomo_recon_stack = recon(
-            tomo_stack, np.radians(thetas), centers, sinogram_order=True,
+            tomo_stack, thetas, centers, sinogram_order=True,
             algorithm=algorithm, ncore=num_core)
         self._logger.info(
             f'Performing initial image reconstruction took {time()-t0:.2f} '
@@ -2558,9 +2791,9 @@ class Tomo:
             }
             t0 = time()
             tomo_recon_stack = recon(
-                tomo_stack, np.radians(thetas), centers,
-                init_recon=tomo_recon_stack, options=options,
-                sinogram_order=True, algorithm=astra, ncore=num_core)
+                tomo_stack, thetas, centers, init_recon=tomo_recon_stack,
+                options=options, sinogram_order=True, algorithm=astra,
+                ncore=num_core)
             self._logger.info(
                 f'Performing secondary iterations took {time()-t0:.2f} '
                 'seconds')
@@ -2571,6 +2804,11 @@ class Tomo:
                 tomo_recon_stack, rwidth=ring_width, out=tomo_recon_stack,
                 ncore=num_core)
 
+        # Performing Gaussian filtering
+        if gaussian_sigma is not None and gaussian_sigma:
+            tomo_recon_stack = misc.corr.gaussian_filter(
+                tomo_recon_stack, sigma=gaussian_sigma, ncore=num_core)
+
         return tomo_recon_stack
 
     def _resize_reconstructed_data(
@@ -2644,7 +2882,7 @@ class Tomo:
         if self._save_figs:
             fig.savefig(
                 os_path.join(
-                    self._output_folder, 'reconstructed_data_xy_roi.png'))
+                    self._outputdir, 'reconstructed_data_xy_roi.png'))
         plt.close()
 
         # Selecting z bounds (in xy-plane)
@@ -2676,7 +2914,7 @@ class Tomo:
             if self._save_figs:
                 fig.savefig(
                     os_path.join(
-                        self._output_folder, 'reconstructed_data_z_roi.png'))
+                        self._outputdir, 'reconstructed_data_z_roi.png'))
             plt.close()
 
         return x_bounds, y_bounds, z_bounds
@@ -2689,7 +2927,7 @@ class TomoSimFieldProcessor(Processor):
     tomography detector images.
     """
 
-    def process(self, data, **kwargs):
+    def process(self, data):
         """
         Process the input configuration and return a
         `nexusformat.nexus.NXroot` object with the simulated
@@ -2743,30 +2981,30 @@ class TomoSimFieldProcessor(Processor):
                 f'({detector_size[0]*pixel_size[0]})')
 
         # Get the rotation angles (start at a arbitrarily choose angle
-        #    and add thetas for a full 360 degrees rotation series)
+        # and add thetas for a full 360 degrees rotation series)
         if station in ('id1a3', 'id3a'):
             theta_start = 0.
         else:
             theta_start = -17
-#RV        theta_end = theta_start + 360.
+# RV        theta_end = theta_start + 360.
         theta_end = theta_start + 180.
         thetas = list(
             np.arange(theta_start, theta_end+0.5*theta_step, theta_step))
 
         # Get the number of horizontal stacks bases on the diagonal
-        #     of the square and for now don't allow more than one
+        # of the square and for now don't allow more than one
         num_tomo_stack = 1 + int((sample_size[1]*np.sqrt(2)-pixel_size[1])
                                  / (detector_size[1]*pixel_size[1]))
         if num_tomo_stack > 1:
             raise ValueError('Sample is too wide for the detector')
 
         # Create the x-ray path length through a solid square
-        #     crosssection for a set of rotation angles.
+        # crosssection for a set of rotation angles.
         path_lengths_solid = self._create_pathlength_solid_square(
                 sample_size[1], thetas, pixel_size[1], detector_size[1])
 
         # Create the x-ray path length through a hollow square
-        #     crosssection for a set of rotation angles.
+        # crosssection for a set of rotation angles.
         path_lengths_hollow = None
         if sample_type in ('square_pipe', 'hollow_cube', 'hollow_brick'):
             path_lengths_hollow = path_lengths_solid \
@@ -2887,10 +3125,6 @@ class TomoSimFieldProcessor(Processor):
         nxdetector.z_translation = vertical_shifts
         nxdetector.starting_image_index = starting_image_index
         nxdetector.starting_image_offset = starting_image_offset
-#        nxdetector.path_lengths_solid = path_lengths_solid
-#        nxdetector.path_lengths_hollow = path_lengths_hollow
-#        nxdetector.intensities_solid = intensities_solid
-#        nxdetector.intensities_hollow = intensities_hollow
 
         return nxroot
 
@@ -2944,7 +3178,7 @@ class TomoDarkFieldProcessor(Processor):
     tomography data set created by TomoSimProcessor.
     """
 
-    def process(self, data, num_image=5, **kwargs):
+    def process(self, data, num_image=5):
         """
         Process the input configuration and return a
         `nexusformat.nexus.NXroot` object with the simulated
@@ -3017,7 +3251,7 @@ class TomoBrightFieldProcessor(Processor):
     tomography data set created by TomoSimProcessor.
     """
 
-    def process(self, data, num_image=5, **kwargs):
+    def process(self, data, num_image=5):
         """
         Process the input configuration and return a
         `nexusformat.nexus.NXroot` object with the simulated
@@ -3034,7 +3268,6 @@ class TomoBrightFieldProcessor(Processor):
         """
         # Third party modules
         from nexusformat.nexus import (
-            NeXusError,
             NXroot,
             NXentry,
             NXinstrument,
@@ -3070,9 +3303,9 @@ class TomoBrightFieldProcessor(Processor):
                 dtype=np.int64)
             bright_field = np.concatenate((dummy_fields, bright_field))
             num_image += num_dummy_start
-        # Add 10% to slit size to make the bright beam slightly taller
-        #     than the vertical displacements between stacks
-        slit_size = 1.10*source.slit_size
+        # Add 20% to slit size to make the bright beam slightly taller
+        # than the vertical displacements between stacks
+        slit_size = 1.2*source.slit_size
         if slit_size < float(detector.row_pixel_size*detector_size[0]):
             img_row_coords = float(detector.row_pixel_size) \
                 * (0.5 + np.asarray(range(int(detector_size[0])))
@@ -3106,7 +3339,7 @@ class TomoSpecProcessor(Processor):
     simulated tomography data set created by TomoSimProcessor.
     """
 
-    def process(self, data, scan_numbers=[1], **kwargs):
+    def process(self, data, scan_numbers=[1]):
         """
         Process the input configuration and return a list of strings
         representing a plain text SPEC file.
@@ -3124,17 +3357,14 @@ class TomoSpecProcessor(Processor):
         from json import dumps
         from datetime import datetime
 
-        # Third party modules
         from nexusformat.nexus import (
-            NeXusError,
-            NXcollection,
             NXentry,
             NXroot,
             NXsubentry,
         )
 
         # Get and validate the TomoSimField, TomoDarkField, or
-        #     TomoBrightField configuration object in data
+        # TomoBrightField configuration object in data
         configs = {}
         nxroot = get_nxroot(data, 'tomo.models.TomoDarkField')
         if nxroot is not None:
@@ -3163,7 +3393,7 @@ class TomoSpecProcessor(Processor):
                     raise ValueError('Inconsistent sample_type among scans')
             detector = nxroot.entry.instrument.detector
             if 'z_translation' in detector:
-                num_stack = np.asarray(detector.z_translation).size
+                num_stack = detector.z_translation.size
             else:
                 num_stack = 1
             data_shape = detector.data.shape
@@ -3197,9 +3427,9 @@ class TomoSpecProcessor(Processor):
         if station in ('id1a3', 'id3a'):
             spec_file.append('#O0 ramsx  ramsz')
         else:
-            #RV Fix main code to use independent dim info
+            # RV Fix main code to use independent dim info
             spec_file.append('#O0 GI_samx  GI_samz  GI_samphi')
-            spec_file.append('#o0 samx samz samphi') #RV do I need this line?
+            spec_file.append('#o0 samx samz samphi') # RV do I need this line?
         spec_file.append('')
 
         # Create the SPEC file scan info (and image and parfile data for SMB)
@@ -3211,10 +3441,10 @@ class TomoSpecProcessor(Processor):
         for schema, nxroot in configs.items():
             detector = nxroot.entry.instrument.detector
             if 'z_translation' in detector:
-                z_translations = list(np.asarray(detector.z_translation))
+                z_translations = list(detector.z_translation.nxdata)
             else:
                 z_translations = [0.]
-            thetas = np.asarray(detector.thetas)
+            thetas = detector.thetas
             num_theta = thetas.size
             if schema == 'tomo.models.TomoDarkField':
                 if station in ('id1a3', 'id3a'):
@@ -3253,9 +3483,11 @@ class TomoSpecProcessor(Processor):
                     spec_file.append('#N 1')
                     spec_file.append('#L  ome')
                     if scan_type == 'ts1':
-                        image_sets.append(np.asarray(detector.data)[n])
+                        #image_sets.append(detector.data.nxdata[n])
+                        image_sets.append(detector.data[n])
                     else:
-                        image_sets.append(np.asarray(detector.data))
+                        #image_sets.append(detector.data.nxdata)
+                        image_sets.append(detector.data)
                     par_file.append(
                         f'{datetime.now().strftime("%Y%m%d")} '
                         f'{datetime.now().strftime("%H%M%S")} '
@@ -3345,7 +3577,7 @@ class TomoSpecProcessor(Processor):
 
         nxroot = NXroot()
         nxroot[sample_type] = nxentry
-        nxroot.attrs['default'] = sample_type
+        nxroot[sample_type].set_default()
 
         return nxroot