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_detector_efficiency(self):
"""
Test methods to read and write detector efficiency
Returns
-------
None
"""
# Generate a HiDRA project file
test_project_file = HidraProjectFile('test_efficient.hdf',
HidraProjectFileMode.OVERWRITE)
# Create a detector efficiency array
mock_test_run_number = 12345
efficient_array = np.random.random_sample(1024**2)
# Write to file
test_project_file.write_efficiency_correction(mock_test_run_number,
efficient_array)
# Close file
test_project_file.close()
# Open file again
verify_project_file = HidraProjectFile('test_efficient.hdf',
HidraProjectFileMode.READONLY)
# Read detector efficiency & compare
verify_eff_array = verify_project_file.read_efficiency_correction()
# Check
assert np.allclose(efficient_array, verify_eff_array, rtol=1E-12)
# Clean
os.remove('test_efficient.hdf')
def load_vanadium(self, van_project_file):
"""Load vanadium from HiDRA project file
Parameters
----------
van_project_file : str
vanadium HiDRA project file or NeXus file
Returns
-------
~numpy.narray, float
1D array as vanadium counts and duration of vanadium run (second)
"""
checkdatatypes.check_file_name(van_project_file, True, False, False,
'Vanadium project/NeXus file')
if van_project_file.endswith('.nxs.h5'):
# Input is nexus file
# reduce with PyRS/Python
converter = NeXusConvertingApp(van_project_file,
mask_file_name=None)
self._van_ws = converter.convert(use_mantid=False)
else:
# Input is HiDRA project file
self._van_ws = workspaces.HidraWorkspace(name=van_project_file)
# PyRS HDF5
project_h5_file = HidraProjectFile(
van_project_file, mode=HidraProjectFileMode.READONLY)
# Load
self._van_ws.load_hidra_project(project_h5_file,
load_raw_counts=True,
load_reduced_diffraction=False)
# Close project file
project_h5_file.close()
# Process the vanadium counts
sub_runs = self._van_ws.get_sub_runs()
assert len(
sub_runs
) == 1, 'There shall be more than 1 sub run in vanadium project file'
# get vanadium data
van_array = self._van_ws.get_detector_counts(sub_runs[0]).astype(
np.float64)
# get vanadium run duration
van_duration = self._van_ws.get_sample_log_value(
HidraConstants.SUB_RUN_DURATION, sub_runs[0])
return van_array, van_duration
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_exclude_subruns(nexusfile, projectfile):
"""Test converting NeXus to project and convert to diffraction pattern
Note: project file cannot be the same as NeXus file as the output file will be
removed by pytest
Parameters
----------
nexusfile
projectfile
Returns
-------
"""
sub_runs = [2, 4, 5]
# convert the nexus file to a project file and do the "simple" checks
converter = NeXusConvertingApp(nexusfile, None)
hidra_ws = converter.convert()
reducer = ReductionApp()
reducer.load_hidra_workspace(hidra_ws)
reducer.reduce_data(instrument_file=None,
calibration_file=None,
mask=None,
sub_runs=sub_runs,
van_file=None)
reducer.save_diffraction_data(projectfile)
reduced_ws = HidraWorkspace('test_powder_pattern')
reduced_project = HidraProjectFile(projectfile)
reduced_ws.load_hidra_project(reduced_project, load_raw_counts=False, load_reduced_diffraction=True)
assert sub_runs == reduced_ws.get_sub_runs()
reducer.reduce_data(instrument_file=None,
calibration_file=None,
mask=None,
sub_runs=[],
van_file=None)
for sub_run in sub_runs:
np.testing.assert_allclose(reducer.get_diffraction_data(sub_run),
reduced_ws.get_reduced_diffraction_data(sub_run))
# cleanup
reduced_project.close()
os.remove(projectfile)
def save_peak_fit_result(self,
project_name,
hidra_file_name,
peak_tag,
overwrite=True):
""" Save the result from peak fitting to HiDRA project file
Parameters
----------
project_name: str
name of peak fitting session
hidra_file_name: String
project file to export peaks fitting result to
peak_tag : str
peak tag
overwrite: bool
Flag to append to an existing file or overwrite it
Returns
-------
"""
if project_name is None:
optimizer = self._peak_fit_engine
else:
optimizer = self._peak_fitting_dict[project_name]
# Determine the file IO mode
if os.path.exists(hidra_file_name) and overwrite is False:
# file exists and user does not want overwrite: READWRITE mode
file_mode = HidraProjectFileMode.READWRITE
else:
# starting as a new file
file_mode = HidraProjectFileMode.OVERWRITE
# Create HiDRA project file
hidra_project_file = HidraProjectFile(hidra_file_name, file_mode)
# Export peaks
optimizer.export_to_hydra_project(hidra_project_file, peak_tag)
# Close
hidra_project_file.close()
return
def load_hidra_project(self, project_file_name, load_calibrated_instrument,
load_detectors_counts, load_reduced_diffraction):
""" Load hidra project file and then CLOSE!
:param project_file_name:
:param load_calibrated_instrument:
:param load_detectors_counts: Flag to load detector counts
:param load_reduced_diffraction: Flag to reduced diffraction data
:return: HidraWorkspace instance
"""
# check inputs
checkdatatypes.check_file_name(project_file_name, True, False, False,
'Project file to load')
# Check
if self._curr_workspace is None:
raise RuntimeError(
'Call init_session to create a ReductionWorkspace')
# PyRS HDF5
# Check permission of file to determine the RW mode of HidraProject file
if os.access(project_file_name, os.W_OK):
# Read/Write: Append mode
file_mode = HidraProjectFileMode.READWRITE
else:
# Read only
file_mode = HidraProjectFileMode.READONLY
project_h5_file = HidraProjectFile(project_file_name, mode=file_mode)
# Load
self._curr_workspace.load_hidra_project(
project_h5_file,
load_raw_counts=load_detectors_counts,
load_reduced_diffraction=load_reduced_diffraction)
# Close
project_h5_file.close()
return self._curr_workspace
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 test_powder_pattern_service(project_file_name, mask_file_name, gold_file):
"""Test the powder pattern calculator (service) with HB2B-specific reduction routine
Parameters
----------
project_file_name
mask_file_name
gold_file
Returns
-------
"""
if mask_file_name is not None:
pytest.skip('Not Ready Yet for Masking')
# load gold file
gold_data_dict = parse_gold_file(gold_file)
# Parse input file
test_ws = HidraWorkspace('test_powder_pattern')
test_project = HidraProjectFile(project_file_name)
test_ws.load_hidra_project(test_project,
load_raw_counts=True,
load_reduced_diffraction=False)
test_project.close()
# Start reduction service
pyrs_service = HB2BReductionManager()
pyrs_service.init_session(session_name='test_powder', hidra_ws=test_ws)
# Reduce raw counts
pyrs_service.reduce_diffraction_data('test_powder',
False,
1000,
sub_run_list=None,
mask=mask_file_name,
mask_id=None,
vanadium_counts=None,
normalize_by_duration=False)
# Get sub runs
sub_runs = test_ws.get_sub_runs()
for index, sub_run_i in enumerate(sub_runs):
# Get gold data of pattern (i).
gold_data_i = gold_data_dict[str(sub_run_i)]
# Get powder data of pattern (i).
pattern = pyrs_service.get_reduced_diffraction_data(
'test_powder', sub_run_i)
# data_dict[str(sub_run_i)] = pattern
# validate correct two-theta reduction
np.testing.assert_allclose(pattern[0],
gold_data_dict[str(sub_run_i)][0],
rtol=1E-8)
# remove NaN intensity arrays
pattern[1][np.where(np.isnan(pattern[1]))] = 0.
gold_data_i[1][np.where(np.isnan(gold_data_i[1]))] = 0.
# validate correct intesnity reduction
np.testing.assert_allclose(pattern[1],
gold_data_i[1],
rtol=1E-8,
equal_nan=True)
def test_powder_pattern_engine(project_file_name, mask_file_name, gold_file):
"""Test the powder pattern calculator (service) with HB2B-specific reduction routine
Parameters
----------
project_file_name
mask_file_name
gold_file
Returns
-------
"""
if mask_file_name is not None:
pytest.skip('Masking is not implemented yet')
# Parse input file
test_ws = HidraWorkspace('test_powder_pattern')
test_project = HidraProjectFile(project_file_name)
test_ws.load_hidra_project(test_project,
load_raw_counts=True,
load_reduced_diffraction=False)
test_project.close()
# Sub runs
sub_runs = test_ws.get_sub_runs()
# Import gold file
gold_pattern = parse_gold_file(gold_file)
data_dict = dict()
# Start reduction service
pyrs_service = HB2BReductionManager()
pyrs_service.init_session(session_name='test_powder', hidra_ws=test_ws)
# Reduce raw counts
pyrs_service.reduce_diffraction_data('test_powder',
False,
1000,
sub_run_list=None,
mask=mask_file_name,
mask_id=None,
vanadium_counts=None,
normalize_by_duration=False)
for index, sub_run_i in enumerate(sub_runs):
# Get gold data of pattern (i).
gold_data_i = gold_pattern[str(sub_run_i)]
# Get powder data of pattern (i).
pattern = pyrs_service.get_reduced_diffraction_data(
'test_powder', sub_run_i)
# ensure NaN are removed
gold_data_i[1][np.where(np.isnan(gold_data_i[1]))] = 0.
pattern[1][np.where(np.isnan(pattern[1]))] = 0.
# Verify
np.testing.assert_allclose(pattern[1], gold_data_i[1], rtol=1E-8)
data_dict[str(sub_run_i)] = pattern
# if mask_file_name:
# name = 'data/HB2B_1017_Mask_Gold.h5'
# else:
# name = 'data/HB2B_1017_NoMask_Gold.h5'
# write_gold_file(name, data_dict)
return