def test_rw_raw():
"""Test read a project to workspace and write in the scope of raw data
Returns
-------
"""
raw_project_name = os.path.join(os.getcwd(), 'data/HZB_Raw_Project.h5')
# Read to workspace
source_project = HidraProjectFile(raw_project_name, 'r')
# To the workspace
source_workspace = workspaces.HidraWorkspace('Source HZB')
source_workspace.load_hidra_project(source_project,
load_raw_counts=True,
load_reduced_diffraction=False)
# Export
target_project = HidraProjectFile('HZB_HiDra_Test.h5', 'w')
# Experiment data
source_workspace.save_experimental_data(target_project,
sub_runs=range(1, 41))
# Instrument
detector_setup = source_workspace.get_instrument_setup()
instrument_setup = HidraSetup(detector_setup=detector_setup)
target_project.write_instrument_geometry(instrument_setup)
# Save
target_project.save(True)
return
def save_fit_result(self, out_file_name=''):
"""Save the fit result, including a copy of the rest of the file if it does not exist at the specified path.
If out_file_name is empty or if it matches the parent's current file, this updates the file.
Otherwise, the parent's file is copied to out_file_name and
then the updated peak fit data is written to the copy.
:param out_file_name: string absolute fill path for the place to save the file
"""
fit_result = self.parent.fit_result
if fit_result is None:
return
if out_file_name is not None and self.parent._curr_file_name != out_file_name:
copyfile(self.parent._curr_file_name, out_file_name)
current_project_file = out_file_name
else:
current_project_file = self.parent._curr_file_name
project_h5_file = HidraProjectFile(current_project_file,
mode=HidraProjectFileMode.READWRITE)
peakcollections = fit_result.peakcollections
for peak in peakcollections:
project_h5_file.write_peak_parameters(peak)
project_h5_file.save(False)
project_h5_file.close()
def test_mask(self):
"""Test methods to read and write mask file
Returns
-------
None
"""
# Generate a HiDRA project file
test_project_file = HidraProjectFile('test_mask.hdf',
HidraProjectFileMode.OVERWRITE)
# Create a detector mask
pixel_mask = np.zeros(shape=(1024**2, ), dtype='int')
pixel_mask += 1
pixel_mask[123:345] = 0
pixel_mask[21000:21019] = 0
# Create a solid angle mask
solid_mask = np.array([-20, -15, -10, -5, 5, 10, 15, 20])
# Write detector mask: default and etc
test_project_file.write_mask_detector_array(None, pixel_mask)
test_project_file.write_mask_detector_array('test', pixel_mask)
# Write solid angle mask
test_project_file.write_mask_solid_angle('test', solid_mask)
# Close file
test_project_file.save(True)
# Open file again
verify_project_file = HidraProjectFile('test_mask.hdf',
HidraProjectFileMode.READONLY)
# Read detector default mask
default_pixel_mask = verify_project_file.read_default_masks()
assert np.allclose(pixel_mask, default_pixel_mask, 1.E-12)
# Read detector mask & compare
verify_pixel_mask = verify_project_file.read_mask_detector_array(
'test')
assert np.allclose(pixel_mask, verify_pixel_mask, 1.E-12)
# Test to read all user detector mask
user_mask_dict = dict()
verify_project_file.read_user_masks(user_mask_dict)
assert list(user_mask_dict.keys())[0] == 'test'
# Read solid angle mask & compare
verify_solid_mask = verify_project_file.read_mask_solid_angle('test')
assert np.allclose(solid_mask, verify_solid_mask, 1.E-2)
# check name
assert verify_project_file.name.endswith('test_mask.hdf')
# Clean
os.remove('test_mask.hdf')
def save_fit_result(self, out_file_name=''):
fit_result = self.parent.fit_result
if fit_result is None:
return
current_project_file = self.parent._curr_file_name
project_h5_file = HidraProjectFile(current_project_file,
mode=HidraProjectFileMode.READWRITE)
peakcollections = fit_result.peakcollections
for peak in peakcollections:
project_h5_file.write_peak_fit_result(peak)
project_h5_file.save(False)
project_h5_file.close()
def test_wave_length_rw():
"""Test writing and reading for wave length
Returns
-------
"""
# Set up for testing
test_file_name = 'test_wave_length.h5'
# Create a detector mask
gold_wave_length = 1.23456
# Generate a HiDRA project file
test_project_file = HidraProjectFile(test_file_name,
HidraProjectFileMode.OVERWRITE)
test_project_file.save(True)
test_project_file.close()
# Open file
verify_project_file = HidraProjectFile(test_file_name,
HidraProjectFileMode.READONLY)
# Read wave length (not exist)
wave_length_test = verify_project_file.read_wavelengths()
assert np.isnan(wave_length_test), 'No wave length read out'
# Close
verify_project_file.close()
# Generate a HiDRA project file
test_project_file = HidraProjectFile(test_file_name,
HidraProjectFileMode.READWRITE)
# Write wave length
test_project_file.write_wavelength(gold_wave_length)
# Save and close
test_project_file.save(True)
test_project_file.close()
# Open file again to verify
verify_project_file2 = HidraProjectFile(test_file_name,
HidraProjectFileMode.READONLY)
# Read wave length (not exist)
wave_length_test = verify_project_file2.read_wavelengths()
assert wave_length_test == gold_wave_length
# Clean
os.remove(test_file_name)
def main():
"""
Main method to convert diffraction data in the old HDF5 format
:return:
"""
# Load source data in 'old' format
source_h5 = 'tests/testdata/16-1_TD.cor_Log.h5'
reader = rs_scan_io.DiffractionDataFile()
diff_data_dict, sample_logs = reader.load_rs_file(source_h5)
# Create a Hidra project
target_project_file_name = 'tests/testdata/Hydra_16-1_cor_log.h5'
target_file = HidraProjectFile(target_project_file_name, 'w')
# Create sub runs
target_file.write_sub_runs(sorted(diff_data_dict.keys()))
# Add (reduced) diffraction data
two_theta_vector = None
diff_data_matrix = None
# construct the matrix of intensities
for sub_run_index, sub_run_number in enumerate(
sorted(diff_data_dict.keys())):
two_theta_vector_i, intensity_vector_i = diff_data_dict[sub_run_index]
# create data set
if two_theta_vector is None:
two_theta_vector = two_theta_vector_i
diff_data_matrix = numpy.ndarray(shape=(len(
diff_data_dict.keys()), intensity_vector_i.shape[0]),
dtype='float')
# END-IF
# set vector
diff_data_matrix[sub_run_index] = intensity_vector_i
# END-FOR
# Add data
target_file.write_reduced_diffraction_data_set(two_theta_vector,
{None: diff_data_matrix})
# Save
target_file.save(verbose=True)
return
def save_reduced_diffraction(self, session_name, output_name):
"""
Save the reduced diffraction data to file
:param session_name:
:param output_name:
:return:
"""
checkdatatypes.check_file_name(output_name, False, True, False,
'Output reduced file')
workspace = self._session_dict[session_name]
# Open
if os.path.exists(output_name):
io_mode = HidraProjectFileMode.READWRITE
else:
io_mode = HidraProjectFileMode.OVERWRITE
project_file = HidraProjectFile(output_name, io_mode)
# Save
workspace.save_reduced_diffraction_data(project_file)
# Close
project_file.save()
def test_strain_io():
"""Test PeakCollection writing and reading with *D reference*
Returns
-------
"""
# Generate a unique test file
now = datetime.datetime.now()
test_file_name = 'test_strain_io_{}.h5'.format(now.toordinal())
test_ref_d = 1.23454321
test_ref_d2 = np.array([1.23, 1.24, 1.25])
peak_tag = 'Fake Peak D'
peak_tag_2 = 'Fake Peak D Diff'
# Generate a HiDRA project file
test_project_file = HidraProjectFile(test_file_name,
HidraProjectFileMode.OVERWRITE)
# Create a ND array for output parameters
param_names = PeakShape.PSEUDOVOIGT.native_parameters + BackgroundFunction.LINEAR.native_parameters
data_type = list()
for param_name in param_names:
data_type.append((param_name, np.float32))
test_error_array = np.zeros(3, dtype=data_type)
test_params_array = np.zeros(3, dtype=data_type)
for i in range(3):
# sub run
for j, par_name in enumerate(param_names):
test_params_array[par_name][i] = 2**i + 0.1 * 3**j
test_error_array[par_name][i] = np.sqrt(
abs(test_params_array[par_name][i]))
# END-FOR
chi2_array = np.array([0.323, 0.423, 0.523])
# Add test data to output
peaks = PeakCollection(peak_tag, PeakShape.PSEUDOVOIGT,
BackgroundFunction.LINEAR)
peaks.set_peak_fitting_values(np.array([1, 2, 3]), test_params_array,
test_error_array, chi2_array)
peaks.set_d_reference(test_ref_d)
# Add 2nd peak
peaks2 = PeakCollection(peak_tag_2, PeakShape.PSEUDOVOIGT,
BackgroundFunction.LINEAR)
peaks2.set_peak_fitting_values(np.array([1, 2, 3]), test_params_array,
test_error_array, chi2_array)
peaks2.set_d_reference(test_ref_d2)
# Write
test_project_file.write_peak_parameters(peaks)
test_project_file.write_peak_parameters(peaks2)
# Save
test_project_file.save(verbose=False)
# Verify
assert os.path.exists(test_file_name), 'Test project file for peak fitting result {} cannot be found.' \
''.format(test_file_name)
# import
verify_project_file = HidraProjectFile(test_file_name,
HidraProjectFileMode.READONLY)
# check tags
peak_tags = verify_project_file.read_peak_tags()
assert peak_tag in peak_tags and peak_tag_2 in peak_tags
assert len(peak_tags) == 2
# Get d-reference of peak 1 to check
peak_info = verify_project_file.read_peak_parameters(peak_tag)
verify_d_ref = peak_info.get_d_reference()
gold_ref_d = np.array([test_ref_d] * 3)
np.testing.assert_allclose(verify_d_ref, gold_ref_d)
# Get d-reference of peak 2 to check
peak_info2 = verify_project_file.read_peak_parameters(peak_tag_2)
verify_d_ref_2 = peak_info2.get_d_reference()
np.testing.assert_allclose(verify_d_ref_2, test_ref_d2)
# Clean
os.remove(test_file_name)
return
def test_peak_fitting_result_io():
"""Test peak fitting result's writing and reading
Returns
-------
"""
# Generate a unique test file
now = datetime.datetime.now()
test_file_name = 'test_peak_io_{}.hdf'.format(now.toordinal())
# Generate a HiDRA project file
test_project_file = HidraProjectFile(test_file_name,
HidraProjectFileMode.OVERWRITE)
# Create a ND array for output parameters
param_names = PeakShape.PSEUDOVOIGT.native_parameters + BackgroundFunction.LINEAR.native_parameters
data_type = list()
for param_name in param_names:
data_type.append((param_name, np.float32))
test_error_array = np.zeros(3, dtype=data_type)
test_params_array = np.zeros(3, dtype=data_type)
for i in range(3):
# sub run
for j, par_name in enumerate(param_names):
test_params_array[par_name][i] = 2**i + 0.1 * 3**j
test_error_array[par_name][i] = np.sqrt(
abs(test_params_array[par_name][i]))
# END-FOR
chi2_array = np.array([0.323, 0.423, 0.523])
# Add test data to output
peaks = PeakCollection('test fake', PeakShape.PSEUDOVOIGT,
BackgroundFunction.LINEAR)
peaks.set_peak_fitting_values(np.array([1, 2, 3]), test_params_array,
test_error_array, chi2_array)
test_project_file.write_peak_parameters(peaks)
test_project_file.save(False)
# Check
assert os.path.exists(test_file_name), 'Test project file for peak fitting result {} cannot be found.' \
''.format(test_file_name)
print('[INFO] Peak parameter test project file: {}'.format(test_file_name))
# Import
verify_project_file = HidraProjectFile(test_file_name,
HidraProjectFileMode.READONLY)
# get the tags
peak_tags = verify_project_file.read_peak_tags()
assert 'test fake' in peak_tags
assert len(peak_tags) == 1
# get the parameter of certain
peak_info = verify_project_file.read_peak_parameters('test fake')
# peak profile
assert peak_info.peak_profile == str(PeakShape.PSEUDOVOIGT)
assert peak_info.background_type == str(BackgroundFunction.LINEAR)
# sub runs
assert np.allclose(peak_info.sub_runs, np.array([1, 2, 3]))
# parameter values
# print('DEBUG:\n Expected: {}\n Found: {}'.format(test_params_array, peak_info[3]))
peak_values, peak_errors = peak_info.get_native_params()
assert_allclose_structured_numpy_arrays(test_params_array, peak_values)
# np.testing.assert_allclose(peak_info[3], test_params_array, atol=1E-12)
# parameter values
# assert np.allclose(peak_info[4], test_error_array, 1E-12)
assert_allclose_structured_numpy_arrays(test_error_array, peak_errors)
# Clean
os.remove(test_file_name)
return