def test_main():
"""
test main
:return:
"""
rs_core = pyrscore.PyRsCore()
# pre-requisite is that the data file exists
test_data = 'tests/data/Hidra_16-1_cor_log.h5'
assert os.path.exists(test_data), 'File {} does not exist'.format(
test_data)
# load data
test_hd_ws = rs_core.load_hidra_project(test_data, 'test core', False,
True)
assert test_hd_ws is not None
# Get sub runs
sub_runs = rs_core.reduction_service.get_sub_runs('test core')
assert sub_runs is not None
# Get sample logs
log_names = rs_core.reduction_service.get_sample_logs_names(
'test core', None)
assert isinstance(log_names, list)
return
def test_retrieve_fit_metadata(source_project_file, output_project_file,
peak_type, peak_info):
"""A full set of test including loading project, fitting peaks, write fitting result and exporting fitting
result and calculated peaks
Parameters
----------
source_project_file
output_project_file
peak_type
peak_info
Returns
-------
"""
if os.path.exists(source_project_file) is False:
pytest.skip('{} does not exist on Travis'.format(source_project_file))
# Create calibration control
controller = pyrscore.PyRsCore()
# Load project file to HidraWorkspace
project_name = 'Jean Peaks'
hd_ws = controller.load_hidra_project(source_project_file,
project_name=project_name,
load_detector_counts=False,
load_diffraction=True)
# set wave length
# TODO : @Jean please find out the correct value
hd_ws.set_wavelength(1.071, False)
# Set peak fitting engine
# create a controller from factory
fit_engine = PeakFitEngineFactory.getInstance(
hd_ws, peak_function_name=peak_type, background_function_name='Linear')
# Fit peak
fit_result = fit_engine.fit_peaks(peak_tag=peak_info.tag,
x_min=peak_info.left_bound,
x_max=peak_info.right_bound)
# Retrieve all effective peak parameters
peakcollection = fit_result.peakcollections[0]
eff_param_value_array, eff_param_error_array = peakcollection.get_effective_params(
)
# result file
ref_h5 = h5py.File(output_project_file, 'w')
peak_entry = ref_h5.create_group(peak_info.tag)
peak_entry.create_dataset('Center', data=eff_param_value_array['Center'])
peak_entry.create_dataset('Height', data=eff_param_value_array['Height'])
peak_entry.create_dataset('FWHM', data=eff_param_value_array['FWHM'])
peak_entry.create_dataset('Mixing', data=eff_param_value_array['Mixing'])
peak_entry.create_dataset('Intensity',
data=eff_param_value_array['Intensity'])
ref_h5.close()
def main(argv):
"""
Main
:param argv:
:return:
"""
#
# Required: HIDRA
# Optional: Instrument file
# Optional: mask files
# Optional: bins
# long-name, short-name, target name, type, default value, is mandatory, documen
args_def_dict = [('input', 'i', 'inputfile', str, None, True,
'Input HIDRA project file'),
('instrument', None, 'instrument', str, None, False,
'Path to instrument file'),
('output', 'o', 'outputfile', str, None, True,
'Output calibration in JSON format'),
('binsize', 'b', 'binsize', float, 0.01, False,
'2theta step')]
try:
param_dict = script_helper.process_arguments(argv, args_def_dict)
except RuntimeError as run_err:
print('Failed to parse inputs due to {}'.format(run_err))
return
# In case of help
if param_dict is None:
return
# Create calibration control
calib_controller = pyrscore.PyRsCore()
# Load data
project_name = 'calibration'
calib_controller.load_hidra_project(param_dict['inputfile'],
project_name=project_name)
# Reduce data
calib_controller.reduce_diffraction_data(project_name,
num_bins=args_def_dict['binsize'],
pyrs_engine=True)
# Export reduction data
calib_controller.export_diffraction_data(project_name,
param_dict['inputfile'])
# Calibration init: import ROI/Mask files
mask_file_list = parse_mask_files(param_dict['masks'])
if len(mask_file_list) < 2:
print('For X-ray case, user must specify at least 2 masks')
sys.exit(-1)
# TODO - to be continued
return
def do_launch_fit_peak_window(self):
"""
launch peak fit window
:return:
"""
# core
fit_peak_core = pyrscore.PyRsCore()
# set up interface object
# if self.peak_fit_window is None:
self.peak_fit_window = fitpeakswindow.FitPeaksWindow(self, fit_peak_core=fit_peak_core)
self.peak_fit_window.show()
def test_improve_quality():
"""This is a test to improve the quality of peak fitting.
Data are from the real HB2B data previously reported problematic
Returns
-------
"""
# Define HiDRA project file name and skip test if it does not exist (on Travis)
project_file_name = '/HFIR/HB2B/IPTS-22731/shared/autoreduce/HB2B_1060.h5'
if not os.path.exists(project_file_name):
pytest.skip('{} does not exist on Travis'.format(project_file_name))
# Create calibration control
controller = pyrscore.PyRsCore()
# Load project file to HidraWorkspace
project_name = 'Jean Peaks'
hd_ws = controller.load_hidra_project(project_file_name,
project_name=project_name,
load_detector_counts=False,
load_diffraction=True)
# set wave length
# TODO : @Jean please find out the correct value
wavelength = 1.071
hd_ws.set_wavelength(wavelength, False)
peak_type = 'Gaussian'
# Set peak fitting engine
# create a controller from factory
fit_engine = PeakFitEngineFactory.getInstance(
hd_ws,
peak_function_name=peak_type,
background_function_name='Linear',
wavelength=wavelength)
# Fit peak @ left
peak_info_left = PeakInfo(91.7, 87., 93., 'Left Peak')
fit_result = fit_engine.fit_peaks(peak_tag=peak_info_left.tag,
x_min=peak_info_left.left_bound,
x_max=peak_info_left.right_bound)
assert fit_result
# Fit the right peak
peak_info_left = PeakInfo(95.8, 93.5, 98.5, 'Right Peak')
fit_engine.fit_peaks(peak_tag=peak_info_left.tag,
x_min=peak_info_left.left_bound,
x_max=peak_info_left.right_bound)
def do_launch_strain_stress_window(self):
"""
launch the strain/stress calculation and visualization window
:return:
"""
# core
ss_core = pyrscore.PyRsCore()
if self.strain_stress_window is None:
self.strain_stress_window = strainstresscalwindow.StrainStressCalculationWindow(self, ss_core)
# launch
self.strain_stress_window.show()
def do_launch_calibration(self):
"""
:return:
"""
from pyrs.interface.calibration import calibrationwindow
# core
pyrs_core = pyrscore.PyRsCore()
# set up interface object
if self.calibration_window is None:
self.calibration_window = calibrationwindow.InstrumentCalibrationWindow(self, pyrs_core)
self.calibration_window.show()
def modify_test_copy_from_unconstrained_to_plane():
"""
testing the use case such that the user copy a strain/stress calculator to another one
:return:
"""
# initialize core
rs_core = pyrscore.PyRsCore()
# create testing files, aka, testing peak fitting module (core)
target_data_set = {
'e11': 'tests/temp/LD_Data_Log.hdf5',
'e22': 'tests/temp/BD_Data_Log.hdf5',
'e33': 'tests/temp/ND_Data_Log.hdf5'
}
# start a session
rs_core.new_strain_stress_session('test strain/stress module',
is_plane_strain=False,
is_plane_stress=False)
# set parameters
rs_core.strain_stress_calculator.set_d0(d0=1.2345)
rs_core.strain_stress_calculator.set_youngs_modulus(young_e=500.)
rs_core.strain_stress_calculator.set_poisson_ratio(poisson_ratio=0.23)
# load data
rs_core.strain_stress_calculator.load_reduced_file(
file_name=target_data_set['e11'], direction='e11')
rs_core.strain_stress_calculator.load_reduced_file(
file_name=target_data_set['e22'], direction='e22')
rs_core.strain_stress_calculator.load_reduced_file(
file_name=target_data_set['e33'], direction='e33')
# check and align measurement points around
try:
rs_core.strain_stress_calculator.check_grids_alignment()
except RuntimeError as run_err:
print('Measuring points are not aligned: {}'.format(run_err))
# create a plane strain/stress calculator
ss_calculator = rs_core.strain_stress_calculator
new_ss_calculator = ss_calculator.migrate(plane_strain=True,
plane_stress=False)
# re check
new_ss_calculator.check_grids_alignment()
new_ss_calculator.located_matched_grids(resolution=0.001)
new_ss_calculator.execute()
return
def __init__(self, input_file_name):
""" Initialization
:param input_file_name: name of testing HIDRA project file
"""
# Create calibration control
self._reduction_controller = pyrscore.PyRsCore()
# Load data
self._project_name = 'NFRS2 Peaks'
hd_ws = self._reduction_controller.load_hidra_project(input_file_name, project_name=self._project_name,
load_detector_counts=False,
load_diffraction=True)
# set wave length
hd_ws.set_wavelength(1.071, False)
def broken_test_pole_figure_calculation():
"""
main testing body to test the workflow to calculate pole figure
:return:
"""
# initialize core
rs_core = pyrscore.PyRsCore()
assert rs_core
# import data file: detector ID and file name
test_data_set = [
(1, 'tests/testdata/HB2B_exp129_Long_Al_222[1]_single.hdf5'),
(2, 'tests/testdata/HB2B_exp129_Long_Al_222[2]_single.hdf5'),
(3, 'tests/testdata/HB2B_exp129_Long_Al_222[3]_single.hdf5'),
(4, 'tests/testdata/HB2B_exp129_Long_Al_222[4]_single.hdf5'),
(5, 'tests/testdata/HB2B_exp129_Long_Al_222[5]_single.hdf5'),
(6, 'tests/testdata/HB2B_exp129_Long_Al_222[6]_single.hdf5'),
(7, 'tests/testdata/HB2B_exp129_Long_Al_222[7]_single.hdf5')
]
assert test_data_set
def do_launch_texture_window(self):
"""
launch texture analysis home
:return:
"""
# core
texture_core = pyrscore.PyRsCore()
if self.texture_analysis_window is None:
self.texture_analysis_window = textureanalysiswindow.TextureAnalysisWindow(self)
self.texture_analysis_window.setup_window(texture_core)
# show
self.texture_analysis_window.show()
# optionally close the main window
# if self.ui.checkBox_keepWindowOpen.isChecked() is False:
# self.close()
return
def modify_test_strain_calculation():
"""
main testing body to test the workflow to calculate strain
:return:
"""
# initialize core
rs_core = pyrscore.PyRsCore()
# create testing files, aka, testing peak fitting module (core)
target_data_set = {
'e11': 'tests/temp/LD_Data_Log.hdf5',
'e22': 'tests/temp/BD_Data_Log.hdf5',
'e33': 'tests/temp/ND_Data_Log.hdf5'
}
# start a session
rs_core.new_strain_stress_session('test strain/stress module',
is_plane_strain=False,
is_plane_stress=False)
# TODO - 20180810 - d0 might not be a single value but changes along grids.
# TODO continue So make it possible to accept d0 in a n x 3 matrix as (x, y, z)
rs_core.strain_stress_calculator.set_d0(d0=1.2345)
rs_core.strain_stress_calculator.set_youngs_modulus(young_e=500.)
rs_core.strain_stress_calculator.set_poisson_ratio(poisson_ratio=0.23)
# load data
rs_core.strain_stress_calculator.load_reduced_file(
file_name=target_data_set['e11'], direction='e11')
rs_core.strain_stress_calculator.load_reduced_file(
file_name=target_data_set['e22'], direction='e22')
rs_core.strain_stress_calculator.load_reduced_file(
file_name=target_data_set['e33'], direction='e33')
# convert peak positions to d-spacing
rs_core.strain_stress_calculator.convert_peaks_positions()
# check and align measurement points around
# TODO FIXME - 20181001 - Make an individual method for .... ---> New workflow!
if True:
# TODO FIXME - 20181001 - This is a new suite of methods to analyze the sample grids
# ... ...
# set the name of the sample log for grid positions
pos_x_sample_names = {'e11': 'vx', 'e22': 'vx', 'e33': 'vx'}
pos_y_sample_names = {'e11': 'vy', 'e22': 'vy', 'e33': 'vy'}
pos_z_sample_names = {'e11': 'vz', 'e22': 'vz', 'e33': 'vz'}
rs_core.strain_stress_calculator.set_grid_log_names(
pos_x_sample_names, pos_y_sample_names, pos_z_sample_names)
rs_core.strain_stress_calculator.check_grids_alignment(
) # rename method
rs_core.strain_stress_calculator.located_matched_grids(
resolution=0.001)
# END-Align-Grid
# calculate unconstrained strain and stress
strain_vec, stress_vec = rs_core.strain_stress_calculator.execute()
# save
rs_core.strain_stress_calculator.save_strain_stress('tests/temp/ss1.dat')
# generate strain/stress grids
grid_dict = {
'Min': {
'X': -130,
'Y': None,
'Z': 9.
},
'Max': {
'X': 130.,
'Y': None,
'Z': None
},
'NotUsed': {}
}
grids, maps = rs_core.strain_stress_calculator.generate_grids(
'e22', user_defined=False, grids_dimension_dict=grid_dict)
# convert to image of slice view...
rs_core.strain_stress_calculator.export_strain_2d(grids)
# export
# rs_core.export_to_paraview(data_key, 'strain', '/tmp/stain_para.dat')
return
def modify_test_plane_stress():
"""
Same as test_strain_calculation but using plane stress
:return:
"""
# TODO - 20180817 - Continue to implement
# initialize core
rs_core = pyrscore.PyRsCore()
# create testing files, aka, testing peak fitting module (core)
target_data_set = {
'e11': 'tests/temp/LD_Data_Log.hdf5',
'e22': 'tests/temp/BD_Data_Log.hdf5',
'e33': 'tests/temp/ND_Data_Log.hdf5'
}
# start a session
rs_core.new_strain_stress_session('test strain/stress module',
is_plane_strain=False,
is_plane_stress=True)
# set up d0, E and nu
rs_core.strain_stress_calculator.set_d0(d0=1.2345)
rs_core.strain_stress_calculator.set_youngs_modulus(young_e=500.)
rs_core.strain_stress_calculator.set_poisson_ratio(poisson_ratio=0.23)
# load data
rs_core.strain_stress_calculator.load_reduced_file(
file_name=target_data_set['e11'], direction='e11')
rs_core.strain_stress_calculator.load_reduced_file(
file_name=target_data_set['e22'], direction='e22')
# check and align measurement points around
try:
rs_core.strain_stress_calculator.check_grids_alignment()
except RuntimeError as run_err:
print('Measuring points are not aligned: {}'.format(run_err))
rs_core.strain_stress_calculator.located_matched_grids(resolution=0.001)
# convert peak positions to d-spacing
rs_core.strain_stress_calculator.convert_peaks_positions()
# generate strain/stress grids
grid_dict = {
'Min': {
'X': -130,
'Y': 0.,
'Z': 9.
},
'Max': {
'X': 130.,
'Y': 0.,
'Z': 19
},
'Resolution': {
'X': 5.0,
'Y': None,
'Z': 1.0
}
}
grids, maps = rs_core.strain_stress_calculator.generate_grids(
None, user_defined=True, grids_dimension_dict=grid_dict)
center_d_vec = rs_core.strain_stress_calculator.align_peak_parameter_on_grids(
grids, 'center_d', maps)
# calculate unconstrained strain and stress
strain_vec, stress_vec = rs_core.strain_stress_calculator.execute(
ss_grid_vec=grids, peak_pos_d_vec=center_d_vec)
assert strain_vec
assert stress_vec
return
def test_pseudovoigt_HB2B_1060(target_values):
"""This is a test of Pseudovoigt peak fitting for HB2B 1060.
Data are from the real HB2B data previously reported problematic
"""
# Define HiDRA project file name and skip test if it does not exist (on Travis)
project_file_name = 'tests/data/HB2B_1060_first3_subruns.h5'
if not os.path.exists(project_file_name):
pytest.skip('{} does not exist on Travis'.format(project_file_name))
# Create calibration control
controller = pyrscore.PyRsCore()
# Load project file to HidraWorkspace
project_name = 'HB2B_1060 Peaks'
hd_ws = controller.load_hidra_project(project_file_name,
project_name=project_name,
load_detector_counts=False,
load_diffraction=True)
peak_type = 'PseudoVoigt'
# Set peak fitting engine
# create a controller from factory
fit_engine = PeakFitEngineFactory.getInstance(
hd_ws,
peak_function_name=peak_type,
background_function_name='Linear',
wavelength=np.nan)
# Fit peak @ left and right
peak_info_left = PeakInfo(91.7, 87., 93., 'Left Peak')
peak_info_right = PeakInfo(95.8, 93.5, 98.5, 'Right Peak')
fit_result = fit_engine.fit_multiple_peaks(
peak_tags=[peak_info_left.tag, peak_info_right.tag],
x_mins=[peak_info_left.left_bound, peak_info_right.left_bound],
x_maxs=[peak_info_left.right_bound, peak_info_right.right_bound])
assert len(fit_result.peakcollections) == 2, 'two PeakCollection'
assert fit_result.fitted
assert fit_result.difference
# peak 'Left'
param_values_lp, _ = fit_result.peakcollections[0].get_native_params()
# peak 'Right'
param_values_rp, _ = fit_result.peakcollections[1].get_native_params()
assert param_values_lp.size == 3, '3 subruns'
assert len(param_values_lp.dtype.names) == 6, '6 native parameters'
assert param_values_rp.size == 3, '3 subruns'
assert len(param_values_rp.dtype.names) == 6, '6 native parameters'
np.testing.assert_allclose(param_values_lp['Intensity'],
target_values['Intensity'][0],
atol=0.9)
np.testing.assert_allclose(param_values_lp['PeakCentre'],
target_values['peak_center'][0],
atol=0.8)
np.testing.assert_allclose(param_values_lp['FWHM'],
target_values['FWHM'][0],
atol=1.)
np.testing.assert_allclose(param_values_lp['A0'],
target_values['background_A0'][0],
atol=1.)
np.testing.assert_allclose(param_values_lp['A1'],
target_values['background_A1'][0],
atol=1.)
np.testing.assert_allclose(param_values_rp['Intensity'],
target_values['Intensity'][1],
atol=0.01)
np.testing.assert_allclose(param_values_rp['PeakCentre'],
target_values['peak_center'][1],
atol=1)
np.testing.assert_allclose(param_values_rp['FWHM'],
target_values['FWHM'][1],
atol=1.2)
np.testing.assert_allclose(param_values_rp['A0'],
target_values['background_A0'][1],
atol=1.)
np.testing.assert_allclose(param_values_rp['A1'],
target_values['background_A1'][1],
atol=1.)
def test_peak_fitting(qtbot, tmpdir):
fit_peak_core = pyrscore.PyRsCore()
window = fitpeakswindow.FitPeaksWindow(None, fit_peak_core=fit_peak_core)
qtbot.addWidget(window)
window.show()
qtbot.wait(wait)
assert window.isVisible()
# This is the handle modal dialogs
def handle_dialog(filename):
# get a reference to the dialog and handle it here
dialog = window.findChild(QtWidgets.QFileDialog)
# get a File Name field
lineEdit = dialog.findChild(QtWidgets.QLineEdit)
# Type in file to load and press enter
qtbot.keyClicks(lineEdit, filename)
qtbot.wait(wait)
qtbot.keyClick(lineEdit, QtCore.Qt.Key_Enter)
# Browser Exp. Data File ...
# wait until dialog is loaded then handle it, this is required
# because the dialog is modal
QtCore.QTimer.singleShot(500, functools.partial(handle_dialog, "tests/data/HB2B_1423.h5"))
qtbot.mouseClick(window.ui.pushButton_browseHDF, QtCore.Qt.LeftButton)
qtbot.wait(wait)
# Select peak range, drag select
# First get canvas
canvas = window.ui.frame_PeakView.children()[1]._myCanvas
# The get start and end mouse points to drag select
start_x, start_y = canvas.figure.axes[0].transData.transform((78, 500))
end_x, end_y = canvas.figure.axes[0].transData.transform((85, 500))
# Drag select with mouse control
qtbot.mousePress(canvas, QtCore.Qt.LeftButton, QtCore.Qt.NoModifier, QtCore.QPoint(start_x, start_y))
qtbot.wait(wait)
qtbot.mouseRelease(canvas, QtCore.Qt.LeftButton, QtCore.Qt.NoModifier, QtCore.QPoint(end_x, end_y))
qtbot.wait(wait)
# Peak Ranges Save ...
peak_range_filename = tmpdir.join("peak_range.json")
# wait until dialog is loaded then handle it, this is required
# because the dialog is modal
QtCore.QTimer.singleShot(500, functools.partial(handle_dialog, str(peak_range_filename)))
qtbot.mouseClick(window.ui.pushButton_save_peak_range, QtCore.Qt.LeftButton)
qtbot.wait(wait)
# check peak range data in json file
with open(peak_range_filename, 'r') as json_file:
data = json.load(json_file)
assert len(data) == 1
assert '0' in data
p0 = data['0']
assert p0['peak_label'] == 'Peak0'
assert len(p0['d0']) == 0
start, end = p0['peak_range']
assert start == pytest.approx(78, abs=0.1)
assert end == pytest.approx(85, abs=0.1)
# Fit Peak(s)
qtbot.mouseClick(window.ui.pushButton_FitPeaks, QtCore.Qt.LeftButton)
qtbot.wait(wait)
# Export CSV ...
# wait until dialog is loaded then handle it, this is required
# because the dialog is modal
QtCore.QTimer.singleShot(500, functools.partial(handle_dialog, str(tmpdir)))
qtbot.mouseClick(window.ui.pushButton_exportCSV, QtCore.Qt.LeftButton)
qtbot.wait(wait)
# check output CSV
assert os.path.isfile(tmpdir.join("HB2B_1423.csv"))
file_contents = open(tmpdir.join("HB2B_1423.csv")).readlines()
# check number of lines
assert len(file_contents) == 127
# check number of values in line
assert len(np.fromstring(file_contents[-1], dtype=float, sep=',')) == 33
# look at 1D results plot
line = window.ui.graphicsView_fitResult.canvas().get_axis(0, 0, True).lines[0]
assert line.get_xdata().min() == 1
assert line.get_xdata().max() == 87
assert line.get_ydata().min() == pytest.approx(-42.000572)
assert line.get_ydata().max() == pytest.approx(37.999313)
# change plot to sx vs d-spacing and check data
# Scroll ComboBox down to d-spacing
for _ in range(15):
qtbot.keyClick(window.ui.comboBox_yaxisNames, QtCore.Qt.Key_Down)
qtbot.wait(wait)
# Scroll to sx
qtbot.keyClick(window.ui.comboBox_xaxisNames, QtCore.Qt.Key_Down)
qtbot.wait(wait)
line = window.ui.graphicsView_fitResult.canvas().get_axis(0, 0, True).lines[0]
assert line.get_xdata().min() == pytest.approx(-42.000572)
assert line.get_xdata().max() == pytest.approx(37.999313)
assert line.get_ydata().min() == pytest.approx(1.169515, rel=1e-5)
assert line.get_ydata().max() == pytest.approx(1.170074, rel=1e-5)
# Change to Peak Type to Gaussian
qtbot.keyClick(window.ui.comboBox_peakType, QtCore.Qt.Key_Down)
qtbot.wait(wait)
# Fit Peak(s)
qtbot.mouseClick(window.ui.pushButton_FitPeaks, QtCore.Qt.LeftButton)
qtbot.wait(wait)
# Export CSV ...
# wait until dialog is loaded then handle it, this is required
# because the dialog is modal
QtCore.QTimer.singleShot(500, functools.partial(handle_dialog, str(tmpdir)))
qtbot.mouseClick(window.ui.pushButton_exportCSV, QtCore.Qt.LeftButton)
qtbot.wait(wait)
# check output CSV
assert os.path.isfile(tmpdir.join("HB2B_1423.csv"))
file_contents = open(tmpdir.join("HB2B_1423.csv")).readlines()
# check number of lines
assert len(file_contents) == 127
# check number of values in line
assert len(np.fromstring(file_contents[-1], dtype=float, sep=',')) == 33
# look at 1D results plot
line = window.ui.graphicsView_fitResult.canvas().get_axis(0, 0, True).lines[0]
assert line.get_xdata().min() == 1
assert line.get_xdata().max() == 87
assert line.get_ydata().min() == pytest.approx(-42.000572)
assert line.get_ydata().max() == pytest.approx(37.999313)
# change plot to sx vs d-spacing and check data
# Scroll ComboBox down to d-spacing
for _ in range(15):
qtbot.keyClick(window.ui.comboBox_yaxisNames, QtCore.Qt.Key_Down)
qtbot.wait(wait)
# Scroll to sx
qtbot.keyClick(window.ui.comboBox_xaxisNames, QtCore.Qt.Key_Down)
qtbot.wait(wait)
line = window.ui.graphicsView_fitResult.canvas().get_axis(0, 0, True).lines[0]
assert line.get_xdata().min() == pytest.approx(-42.000572)
assert line.get_xdata().max() == pytest.approx(37.999313)
assert line.get_ydata().min() == pytest.approx(1.169389, rel=1e-5)
assert line.get_ydata().max() == pytest.approx(1.170393, rel=1e-5)
def main(argv):
"""
Main
:param argv:
:return:
"""
#
# Required: HIDRA
# Optional: Instrument file
# Optional: mask files
# Optional: bins
# long-name, short-name, target name, type, default value, is mandatory, documen
args_def_list = [('input', 'i', 'inputfile', str, None, True, 'Input HIDRA project file'),
('masks', 'm', 'masksfiles', str, None, False,
'Path to an ASCI file containing list of path to mask files, separated by ":", ", " or "\n"'),
('instrument', None, 'instrument', str, None, False, 'Path to instrument file'),
('output', 'o', 'outputfile', str, None, True, 'Output calibration in JSON format'),
('binsize', 'b', 'binsize', float, 0.01, False, '2theta step')]
try:
param_dict = script_helper.process_arguments(argv, args_def_list)
except RuntimeError as run_err:
print('Failed to parse inputs due to {}'.format(run_err))
return
# In case of help
if param_dict is None:
return
# Create calibration control
calib_controller = pyrscore.PyRsCore()
# Load data
project_name = 'calibration xray'
calib_controller.load_hidra_project(param_dict['inputfile'], project_name=project_name)
# Reduce data
calib_controller.reduce_diffraction_data(project_name, num_bins=param_dict['binsize'],
pyrs_engine=True)
# get handler on reduciton engine
reduction_engine = calib_controller.reduction_service.get_last_reduction_engine()
# Get pixels
pixel_pos_array = reduction_engine.get_pixel_positions(is_matrix=False) # (N, 3) array
pixel_2theta_array = reduction_engine.instrument.get_pixels_2theta(dimension=1) # (N, ) array
#
# # Calibration init: import ROI/Mask files
# if 'masksfiles' in param_dict:
# mask_file_list = parse_mask_files(param_dict['masksfiles'])
# if len(mask_file_list) < 2:
# print ('For X-ray case, user must specify at least 2 masks')
# sys.exit(-1)
# else:
# print ('[ERROR] X-ray-calibration algorithm requires Masks')
# sys.exit(-1)
#
# # Last test before calibration start: reduce by mask
# for mask_file_name in mask_file_list:
# calib_controller.reduce_diffraction_data(project_name, two_theta_step=param_dict['binsize'],
# pyrs_engine=True, mask_file_name=mask_file_name)
# # END-FOR
# Export reduction data
calib_controller.save_diffraction_data(project_name, param_dict['inputfile'])
return
