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

CHAP/tomo/processor.py

@@ -8,7 +8,6 @@ Description: Module for Processors used only by tomography experiments
 """
 
 # System modules
-from os import mkdir
 from os import path as os_path
 from sys import exit as sys_exit
 from time import time
@@ -31,7 +30,6 @@ from CHAP.utils.general import (
     quick_imshow,
     nxcopy,
 )
-from CHAP.utils.fit import Fit
 from CHAP.processor import Processor
 from CHAP.reader import main
 
@@ -148,6 +146,8 @@ class TomoCHESSMapConverter(Processor):
 
         # Validate map
         map_config = MapConfig(**loads(str(tomofields.map_config)))
+        assert len(map_config.spec_scans) == 1
+        num_tomo_stack = len(map_config.spec_scans[0].scan_numbers)
 
         # Check available independent dimensions
         independent_dimensions = tomofields.data.attrs['axes']
@@ -167,8 +167,6 @@ class TomoCHESSMapConverter(Processor):
                              f'({rotation_angle_data_type})')
         matched_dimensions.pop(matched_dimensions.index('rotation_angles'))
         if 'x_translation' in independent_dimensions:
-            x_translation_index = \
-                tomofields.data.axes.index('x_translation')
             x_translation_data_type = \
                 tomofields.data.x_translation.attrs['data_type']
             x_translation_name = \
@@ -180,8 +178,6 @@ class TomoCHESSMapConverter(Processor):
         else:
             x_translation_data_type = None
         if 'z_translation' in independent_dimensions:
-            z_translation_index = \
-                tomofields.data.axes.index('z_translation')
             z_translation_data_type = \
                 tomofields.data.z_translation.attrs['data_type']
             z_translation_name = \
@@ -226,17 +222,12 @@ class TomoCHESSMapConverter(Processor):
 
         # Add an NXdetector to the NXinstrument
         # (do not fill in data fields yet)
+        detector_names = list(np.asarray(tomofields.detector_names, dtype=str))
         detector_prefix = detector_config.prefix
-        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 = 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
-        assert tomo_stack_shape[-1] == detector_config.columns
+        if detector_prefix not in detector_names:
+            raise ValueError(
+                f'Data for detector {detector_prefix} is unavailable '
+                f'(available detectors: {detector_names})')
         nxdetector = NXdetector()
         nxinstrument.detector = nxdetector
         nxdetector.local_name = detector_prefix
@@ -274,10 +265,9 @@ class TomoCHESSMapConverter(Processor):
         x_translations = []
         z_translations = []
         if darkfield is not None:
-            nxentry.dark_field_config = darkfield.spec_config
+            nxentry.dark_field_config = darkfield.config
             for scan_name, scan in darkfield.spec_scans.items():
                 for scan_number, nxcollection in scan.items():
-                    scan_columns = loads(str(nxcollection.scan_columns))
                     data_shape = nxcollection.data[detector_prefix].shape
                     assert len(data_shape) == 3
                     assert data_shape[1] == detector_config.rows
@@ -286,7 +276,7 @@ class TomoCHESSMapConverter(Processor):
                     image_keys += num_image*[2]
                     sequence_numbers += list(range(num_image))
                     image_stacks.append(
-                        nxcollection.data[detector_prefix])
+                        nxcollection.data[detector_prefix].nxdata)
                     rotation_angles += num_image*[0.0]
                     if (x_translation_data_type == 'spec_motor' or
                             z_translation_data_type == 'spec_motor'):
@@ -314,10 +304,9 @@ class TomoCHESSMapConverter(Processor):
                                 num_image*[smb_pars[z_translation_name]]
 
         # Collect bright field data
-        nxentry.bright_field_config = brightfield.spec_config
+        nxentry.bright_field_config = brightfield.config
         for scan_name, scan in brightfield.spec_scans.items():
             for scan_number, nxcollection in scan.items():
-                scan_columns = loads(str(nxcollection.scan_columns))
                 data_shape = nxcollection.data[detector_prefix].shape
                 assert len(data_shape) == 3
                 assert data_shape[1] == detector_config.rows
@@ -326,7 +315,7 @@ class TomoCHESSMapConverter(Processor):
                 image_keys += num_image*[1]
                 sequence_numbers += list(range(num_image))
                 image_stacks.append(
-                    nxcollection.data[detector_prefix])
+                    nxcollection.data[detector_prefix].nxdata)
                 rotation_angles += num_image*[0.0]
                 if (x_translation_data_type == 'spec_motor' or
                         z_translation_data_type == 'spec_motor'):
@@ -354,65 +343,46 @@ class TomoCHESSMapConverter(Processor):
                             num_image*[smb_pars[z_translation_name]]
 
         # Collect tomography fields data
-        if x_translation_data_type is None:
-            x_trans = [0.0]
-            if z_translation_data_type is None:
-                z_trans = [0.0]
-                tomo_stacks = np.reshape(tomo_stacks, (1,1,*tomo_stacks.shape))
-            else:
-                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,
-                        z_translation_index)
-                tomo_stacks = np.expand_dims(tomo_stacks, z_translation_index)
-        elif z_translation_data_type is None:
-            z_trans = [0.0]
-            if rotation_angles_index < x_translation_index:
-                tomo_stacks = np.swapaxes(
-                    tomo_stacks, rotation_angles_index, x_translation_index)
-            tomo_stacks = np.expand_dims(tomo_stacks, 0)
-        else:
-            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(
-                    tomo_stacks, rotation_angles_index,
-                    max(x_translation_index, z_translation_index))
-            if x_translation_index < z_translation_index:
-                tomo_stacks = np.swapaxes(
-                    tomo_stacks, x_translation_index, z_translation_index)
+        tomo_stacks = tomofields.data.detector_data.nxdata[
+            detector_names.index(detector_prefix)]
+        tomo_stack_shape = tomo_stacks.shape
+        assert len(tomo_stack_shape) == 3
+        assert tomo_stack_shape[-2] == detector_config.rows
+        assert tomo_stack_shape[-1] == detector_config.columns
+        assert not tomo_stack_shape[0] % num_tomo_stack
         # Restrict to 180 degrees set of data for now to match old code
-        thetas = tomofields.data.rotation_angles.nxdata
-        assert len(thetas) > 2
-        delta_theta = thetas[1]-thetas[0]
-        if thetas[-1]-thetas[0] > 180-delta_theta:
-            image_end = index_nearest(thetas, thetas[0]+180)
+        thetas_stacks = tomofields.data.rotation_angles.nxdata
+        num_theta = tomo_stack_shape[0] // num_tomo_stack
+        assert num_theta > 2
+        thetas = thetas_stacks[0:num_theta]
+        delta_theta = thetas[1] - thetas[0]
+        if thetas[num_theta-1] - thetas[0] > 180 - delta_theta:
+            image_end = index_nearest(thetas, thetas[0] + 180)
         else:
-            image_end = len(thetas)
+            image_end = thetas.size
         thetas = thetas[:image_end]
-        num_image = len(thetas)
-        for i, z in enumerate(z_trans):
-            for j, x in enumerate(x_trans):
-                image_keys += num_image*[0]
-                sequence_numbers += list(range(num_image))
-                image_stacks.append(tomo_stacks[i,j,:image_end,:,:])
-                rotation_angles += list(thetas)
-                x_translations += num_image*[x]
-                z_translations += num_image*[z]
+        num_image = thetas.size
+        n_start = 0
+        image_keys += num_tomo_stack * num_image * [0]
+        sequence_numbers += num_tomo_stack * list(range(num_image))
+        if x_translation_data_type is None:
+            x_translations += num_tomo_stack * num_image * [0.0]
+        if z_translation_data_type is None:
+            z_translations += num_tomo_stack * num_image * [0.0]
+        for i in range(num_tomo_stack):
+            image_stacks.append(tomo_stacks[n_start:n_start+num_image])
+            if not np.array_equal(
+                    thetas, thetas_stacks[n_start:n_start+num_image]):
+                raise RuntimeError(
+                    'Inconsistent thetas among tomography image stacks')
+            rotation_angles += list(thetas)
+            if x_translation_data_type is not None:
+                x_translations += list(
+                    tomofields.data.x_translation[n_start:n_start+num_image])
+            if z_translation_data_type is not None:
+                z_translations += list(
+                    tomofields.data.z_translation[n_start:n_start+num_image])
+            n_start += num_theta
 
         # Add image data to NXdetector
         nxinstrument.detector.image_key = image_keys
@@ -458,7 +428,7 @@ class TomoDataProcessor(Processor):
             for tomographic image reduction.
         :type data: list[PipelineData]
         :param outputdir: Output folder name, defaults to '.'.
-        :type outputdir:: str, optional
+        :type outputdir: str, optional
         :param interactive: Allows for user interactions,
             defaults to False.
         :type interactive: bool, optional
@@ -666,7 +636,7 @@ class Tomo:
         :param num_core: Number of processors.
         :type num_core: int
         :param outputdir: Output folder name, defaults to '.'.
-        :type outputdir:: str, optional
+        :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
@@ -1395,28 +1365,28 @@ class Tomo:
 
         # Resize the combined tomography data stacks
         # - combined axis data order: row/-z,y,x
-        if self._interactive:
+        if self._interactive or self._save_figs:
             x_bounds, y_bounds, z_bounds = self._resize_reconstructed_data(
                 tomo_recon_combined, combine_data=True)
         else:
             x_bounds = tool_config.x_bounds
             if x_bounds is None:
                 self._logger.warning(
-                    'x_bounds unspecified, reconstruct data for full x-range')
+                    'x_bounds unspecified, combine data for full x-range')
             elif not is_int_pair(
                     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')
+                    'y_bounds unspecified, combine data for full y-range')
             elif not is_int_pair(
                     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')
+                    'z_bounds unspecified, combine data for full z-range')
             elif not is_int_pair(
                     z_bounds, ge=0, le=tomo_shape[0]):
                 raise ValueError(f'Invalid parameter z_bounds ({z_bounds})')
@@ -1706,18 +1676,46 @@ class Tomo:
             img_row_bounds = calibrate_center_rows
         else:
             if nxentry.instrument.source.attrs['station'] in ('id1a3', 'id3a'):
+                # System modules
+                from sys import float_info
+
+                # Third party modules
+                from nexusformat.nexus import (
+                    NXdata,
+                    NXfield,
+                )
+
+                # Local modules
+                from CHAP.utils.fit import FitProcessor
+
                 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
+                num = len(row_sum)
+                fit = FitProcessor()
+                model = {'model': 'rectangle',
+                         'parameters': [
+                             {'name': 'amplitude',
+                              'value': row_sum.max()-row_sum.min(),
+                              'min': 0.0},
+                             {'name': 'center1', 'value': 0.25*num,
+                                 'min': 0.0, 'max': num},
+                             {'name': 'sigma1', 'value': num/7.0,
+                              'min': float_info.min},
+                             {'name': 'center2', 'value': 0.75*num,
+                              'min': 0.0, 'max': num},
+                             {'name': 'sigma2', 'value': num/7.0,
+                              'min': float_info.min}]}
+                bounds_fit = fit.process(
+                    NXdata(NXfield(row_sum, 'y'),
+                    NXfield(np.array(range(num)), 'x')),
+                    {'models': [model], 'method': 'trf'})
+                parameters = bounds_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
+                have_fit = (bounds_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
@@ -1787,7 +1785,7 @@ class Tomo:
         if calibrate_center_rows:
             title='Select two detector image row indices to '\
                   'calibrate rotation axis (in range '\
-                  f'[0, {first_image.shape[0]}])'
+                  f'[0, {first_image.shape[0]-1}])'
         else:
             title='Select detector image row bounds for data '\
                   f'reduction (in range [0, {first_image.shape[0]}])'
@@ -2052,7 +2050,7 @@ class Tomo:
                 evaluate('-log(tomo_stack)', out=tomo_stack)
 
             # Get rid of nans/infs that may be introduced by normalization
-            np.where(np.isfinite(tomo_stack), tomo_stack, 0.)
+            tomo_stack = np.where(np.isfinite(tomo_stack), tomo_stack, 0.)
 
             # Downsize tomography stack to smaller size
             tomo_stack = tomo_stack.astype('float32', copy=False)
@@ -2452,8 +2450,9 @@ class Tomo:
                             f'{selected_center_offset:.2f}.png'))
             plt.close()
 
+            del recon_planes
+
         del sinogram
-        del recon_planes
 
         # Return the center location
         if self._interactive:
@@ -2834,16 +2833,16 @@ class Tomo:
         # Selecting x an y bounds (in z-plane)
         if x_bounds is None:
             if not self._interactive:
-                self._logger.warning('x_bounds unspecified, reconstruct '
-                                     'data for full x-range')
+                self._logger.warning('x_bounds unspecified, use data for '
+                                     'full x-range')
                 x_bounds = (0, tomo_recon_stacks[0].shape[2])
         elif not is_int_pair(
                 x_bounds, ge=0, le=tomo_recon_stacks[0].shape[2]):
             raise ValueError(f'Invalid parameter x_bounds ({x_bounds})')
         if y_bounds is None:
             if not self._interactive:
-                self._logger.warning('y_bounds unspecified, reconstruct '
-                                     'data for full y-range')
+                self._logger.warning('y_bounds unspecified, use data for '
+                                     'full y-range')
                 y_bounds = (0, tomo_recon_stacks[0].shape[1])
         elif not is_int_pair(
                 y_bounds, ge=0, le=tomo_recon_stacks[0].shape[1]):
@@ -2865,11 +2864,20 @@ class Tomo:
         tomosum = 0
         for i in range(num_tomo_stacks):
             tomosum = tomosum + np.sum(tomo_recon_stacks[i], axis=0)
-        fig, roi = select_roi_2d(
+        if self._save_figs:
+            if combine_data:
+                filename = os_path.join(
+                    self._outputdir, 'combined_data_xy_roi.png')
+            else:
+                filename = os_path.join(
+                    self._outputdir, 'reconstructed_data_xy_roi.png')
+        else:
+            filename = None
+        roi = select_roi_2d(
             tomosum, preselected_roi=preselected_roi,
             title_a='Reconstructed data summed over z',
             row_label='y', column_label='x',
-            interactive=self._interactive)
+            interactive=self._interactive, filename=filename)
         if roi is None:
             x_bounds = (0, tomo_recon_stacks[0].shape[2])
             y_bounds = (0, tomo_recon_stacks[0].shape[1])
@@ -2878,12 +2886,6 @@ class Tomo:
             y_bounds = (int(roi[2]), int(roi[3]))
         self._logger.debug(f'x_bounds = {x_bounds}')
         self._logger.debug(f'y_bounds = {y_bounds}')
-        # Plot results
-        if self._save_figs:
-            fig.savefig(
-                os_path.join(
-                    self._outputdir, 'reconstructed_data_xy_roi.png'))
-        plt.close()
 
         # Selecting z bounds (in xy-plane)
         # (only valid for a single image stack or when combining a stack)
@@ -2905,17 +2907,20 @@ class Tomo:
             tomosum = 0
             for i in range(num_tomo_stacks):
                 tomosum = tomosum + np.sum(tomo_recon_stacks[i], axis=(1,2))
-            fig, z_bounds = select_roi_1d(
+            if self._save_figs:
+                if combine_data:
+                    filename = os_path.join(
+                        self._outputdir, 'combined_data_z_roi.png')
+                else:
+                    filename = os_path.join(
+                        self._outputdir, 'reconstructed_data_z_roi.png')
+            else:
+                filename = None
+            z_bounds = select_roi_1d(
                 tomosum, preselected_roi=z_bounds,
                 xlabel='z', ylabel='Reconstructed data summed over x and y',
-                interactive=self._interactive)
+                interactive=self._interactive, filename=filename)
             self._logger.debug(f'z_bounds = {z_bounds}')
-            # Plot results
-            if self._save_figs:
-                fig.savefig(
-                    os_path.join(
-                        self._outputdir, 'reconstructed_data_z_roi.png'))
-            plt.close()
 
         return x_bounds, y_bounds, z_bounds
 
@@ -2957,6 +2962,9 @@ class TomoSimFieldProcessor(Processor):
         sample_size = config.sample_size
         if len(sample_size) == 1:
             sample_size = (sample_size[0], sample_size[0])
+        if sample_type == 'hollow_pyramid' and len(sample_size) != 3:
+            raise ValueError('Invalid combindation of sample_type '
+                             f'({sample_type}) and sample_size ({sample_size}')
         wall_thickness = config.wall_thickness
         mu = config.mu
         theta_step = config.theta_step
@@ -2993,15 +3001,22 @@ class TomoSimFieldProcessor(Processor):
 
         # Get the number of horizontal stacks bases on the diagonal
         # 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 (sample_size) == 3:
+            num_tomo_stack = 1 + int(
+                (max(sample_size[1:2])*np.sqrt(2)-pixel_size[1])
+                / (detector_size[1]*pixel_size[1]))
+        else:
+            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.
-        path_lengths_solid = self._create_pathlength_solid_square(
-                sample_size[1], thetas, pixel_size[1], detector_size[1])
+        path_lengths_solid = None
+        if sample_type != 'hollow_pyramid':
+            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.
@@ -3027,7 +3042,12 @@ class TomoSimFieldProcessor(Processor):
         num_theta = len(thetas)
         vertical_shifts = []
         tomo_fields_stack = []
-        img_dim = (len(img_row_coords), path_lengths_solid.shape[1])
+        len_img_y = (detector_size[1]+1)//2
+        if len_img_y%2:
+            len_img_y = 2*len_img_y - 1
+        else:
+            len_img_y = 2*len_img_y
+        img_dim = (len(img_row_coords), len_img_y)
         intensities_solid = None
         intensities_hollow = None
         for n in range(num_tomo_stack):
@@ -3044,6 +3064,37 @@ class TomoSimFieldProcessor(Processor):
                     beam_intensity * np.exp(-mu*path_lengths_hollow)
                 for n in range(num_theta):
                     tomo_field[n,:,:] = intensities_hollow[n]
+            elif sample_type == 'hollow_pyramid':
+                outer_indices = \
+                    np.where(abs(img_row_coords) <= sample_size[0]/2)[0]
+                inner_indices = np.where(
+                    abs(img_row_coords) < sample_size[0]/2 - wall_thickness)[0]
+                wall_indices = list(set(outer_indices)-set(inner_indices))
+                ratio = abs(sample_size[1]-sample_size[2])/sample_size[0]
+                baselength = max(sample_size[1:2])
+                for i in wall_indices:
+                    path_lengths_solid = self._create_pathlength_solid_square(
+                        baselength - ratio*(
+                            img_row_coords[i] + 0.5*sample_size[0]),
+                        thetas, pixel_size[1], detector_size[1])
+                    intensities_solid = \
+                        beam_intensity * np.exp(-mu*path_lengths_solid)
+                    for n in range(num_theta):
+                        tomo_field[n,i] = intensities_solid[n]
+                for i in inner_indices:
+                    path_lengths_hollow = (
+                        self._create_pathlength_solid_square(
+                            baselength - ratio*(
+                                img_row_coords[i] + 0.5*sample_size[0]),
+                            thetas, pixel_size[1], detector_size[1])
+                        - self._create_pathlength_solid_square(
+                            baselength - 2*wall_thickness - ratio*(
+                                img_row_coords[i] + 0.5*sample_size[0]),
+                            thetas, pixel_size[1], detector_size[1]))
+                    intensities_hollow = \
+                        beam_intensity * np.exp(-mu*path_lengths_hollow)
+                    for n in range(num_theta):
+                        tomo_field[n,i] = intensities_hollow[n]
             else:
                 intensities_solid = \
                     beam_intensity * np.exp(-mu*path_lengths_solid)
@@ -3136,7 +3187,7 @@ class TomoSimFieldProcessor(Processor):
         """
         # Get the column coordinates
         img_y_coords = pixel_size * (0.5 * (1 - detector_size%2)
-            + np.asarray(range(int(0.5 * (detector_size+1)))))
+            + np.asarray(range((detector_size+1)//2)))
 
         # Get the path lenghts for position column coordinates
         lengths = np.zeros((len(thetas), len(img_y_coords)), dtype=np.float64)

CHAP/utils/__init__.py

@@ -2,3 +2,4 @@
 CHESS scan data, collecting interactive user input, and finding
 lattice properties of materials (among others).
 """
+from CHAP.utils.fit import FitProcessor