def test_reduce_with_calibration():
"""Test reduction with calibration file
Returns
-------
"""
nexus = '/HFIR/HB2B/IPTS-22731/nexus/HB2B_1017.nxs.h5'
mask = '/HFIR/HB2B/shared/CALIBRATION/HB2B_MASK_Latest.xml'
calibration = '/HFIR/HB2B/shared/CALIBRATION/HB2B_Latest.json'
project = os.path.basename(nexus).split('.')[0] + '_WL.h5'
project = os.path.join(os.getcwd(), project)
try:
# convert from NeXus to powder pattern
_ = convertNeXusToProject(nexus, project, True, mask_file_name=mask)
addPowderToProject(project, calibration_file=calibration)
# load file
verify_project = HidraProjectFile(project, HidraProjectFileMode.READONLY)
verify_workspace = HidraWorkspace('verify calib')
verify_workspace.load_hidra_project(verify_project, load_raw_counts=False, load_reduced_diffraction=True)
wave_length = verify_workspace.get_wavelength(True, True)
assert not np.isnan(wave_length)
finally:
if os.path.exists(project):
os.remove(project)
def test_set_sample_log(self):
workspace = HidraWorkspace()
subruns, vx = np.array([1, 2, 3], dtype=int), np.array([0.0, 0.1, 0.2])
workspace.set_sample_log('vx', subruns, vx)
assert workspace.get_sample_log_units('vx') == ''
workspace.set_sample_log('vx', subruns, vx, 'mm')
assert workspace.get_sample_log_units('vx') == 'mm'
def load_hidra_project_file(self, filename, direction):
try:
source_project = HidraProjectFile(
filename, mode=HidraProjectFileMode.READONLY)
ws = HidraWorkspace(direction)
ws.load_hidra_project(source_project, False, False)
peaks = dict()
for peak in source_project.read_peak_tags():
peaks[peak] = source_project.read_peak_parameters(peak)
return ws, peaks
except Exception as e:
self.failureMsg.emit(
f"Failed to load {filename}. Check that this is a Hidra Project File",
str(e), traceback.format_exc())
return None, dict()
def generate_hydra_workspace_multiple_sub_runs(ws_name, sub_run_data_dict):
"""Generate a multiple sub-run HiDRA workspace
Parameters
----------
ws_name
sub_run_data_dict
Returns
-------
pyrs.core.workspaces.HidraWorkspace
Test Hidra workspace
"""
# Create test workspace
test_workspace = HidraWorkspace(ws_name)
# Sub runs:
sub_runs_list = list(sub_run_data_dict.keys())
test_workspace.set_sub_runs(sub_runs_list)
# Add diffraction pattern
for sub_run_i in sorted(sub_runs_list):
vec_x, vec_y = sub_run_data_dict[sub_run_i]
test_workspace.set_reduced_diffraction_data(sub_run_i,
mask_id=None,
two_theta_array=vec_x,
intensity_array=vec_y)
return test_workspace
def test_leastsq():
"""Main test for the script
Returns
-------
"""
# Set up
# reduction engine
project_file_name = 'tests/data/HB2B_000.h5'
engine = HidraProjectFile(project_file_name,
mode=HidraProjectFileMode.READONLY)
# Convert HidraProjectFile into HidraWorkspace
engine_ws = HidraWorkspace('test')
engine_ws._load_sample_logs(engine)
engine_ws._load_raw_counts(engine)
t_start = time.time()
# Initalize calibration
calibrator = peakfit_calibration.PeakFitCalibration(
powder_engine=engine_ws, powder_lines=dSpace)
calibrator.UseLSQ = True
calibrator.calibrate_wave_length()
calibrator._caliberr[6] = 1e-4
calibrator._caliberr[0] = 1e-4
calibrator._calibstatus = 3
# write out
if os.path.exists('HB2B_CAL_Test.json'):
os.remove('HB2B_CAL_Test.json')
file_name = os.path.join(os.getcwd(), 'HB2B_CAL_Test.json')
calibrator.write_calibration(file_name)
t_stop = time.time()
print('Total Time: {}'.format(t_stop - t_start))
# Compare output file with gold file for test
if are_equivalent_jsons('tests/data/HB2B_CAL_Si333.json',
file_name,
atol=5E-3):
# Same: remove file generated in test
os.remove(file_name)
else:
print_out_json_diff('tests/data/HB2B_CAL_Si333.json',
'HB2B_CAL_Test.json')
assert False, 'Test output {} is different from gold file {}'.format(
file_name, 'tests/data/HB2B_CAL_Si333.json')
return
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 generate_hydra_workspace_single_subrun(peak_profile_type, min_x, max_x,
num_x, peak_centers, peak_ranges,
peak_intensities):
"""Generate HiDRAWorkspace for peak fitting test
Default:
min_x = 75
max_x = 85
num_x = 500
Parameters
----------
peak_profile_type
min_x
max_x
num_x
peak_centers
peak_ranges
peak_intensities
Returns
-------
pyrs.core.workspaces.HidraWorkspace
Test Hidra workspace
"""
# Create test workspace
test_workspace = HidraWorkspace('test')
# resolution
x_step = (max_x - min_x) / num_x
# Generate vector X
vec_x = np.arange(num_x) * x_step + min_x # from 75 to 85 degree
# Add profile
if peak_profile_type.lower() == 'gaussian':
test_fitting_function = generate_test_gaussian(vec_x, peak_centers,
peak_ranges,
peak_intensities)
elif peak_profile_type.lower() == 'pseudovoigt':
test_fitting_function = generate_test_pseudovoigt(
vec_x, peak_centers, peak_ranges, peak_intensities)
# peak_range *= 2 # PV requires larger fitting range
else:
raise NotImplementedError(
'Peak profile {} is not supported to generate testing workspace')
vec_y = test_fitting_function['values']
parameters = test_fitting_function['parameters']
# Add background
test_background_function = generate_test_background(vec_x, vec_y)
vec_y = test_background_function['values']
parameters.append(test_background_function['parameters'])
# Print out the test data
# for i in range(vec_x.shape[0]):
# print('{} {}'.format(vec_x[i], vec_y[i]))
# Add diffraction pattern
test_workspace.set_sub_runs([1])
test_workspace.set_reduced_diffraction_data(1,
mask_id=None,
two_theta_array=vec_x,
intensity_array=vec_y)
return {'workspace': test_workspace, 'parameters': parameters}
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
