def set_matched_girds_info(self, matched_grid_scan_list):
""" set the list of experimentally matched grids
:param matched_grid_scan_list:
:return:
"""
# check
checkdatatypes.check_list('Experimentally matched grids scans',
matched_grid_scan_list)
# reset
self.ui.tableView_matchedGrids.remove_all_rows()
for igrid in range(len(matched_grid_scan_list)):
row_items = [
igrid, matched_grid_scan_list[igrid]['e11'],
matched_grid_scan_list[igrid]['e22']
]
if 'e33' in matched_grid_scan_list[igrid]:
row_items.append(matched_grid_scan_list[igrid]['e22'])
else:
row_items.append('')
# END-IF
# add a new row
self.ui.tableView_matchedGrids.append_row(row_items)
# END-FOR
return
def export_to_mtex(pole_figure_array_dict, detector_id_list, file_name,
header):
"""
export to mtex format, which includes
line 1: NRSF2
line 2: alpha beta intensity
line 3: (optional header)
line 4 and on: alpha\tbeta\tintensity
:param file_name:
:param detector_id_list: selected the detector IDs for pole figure
:param pole_figure_array_dict:
:param header
:return:
"""
# check input types
checkdatatypes.check_dict('Pole figure array dictionary',
pole_figure_array_dict)
checkdatatypes.check_list('Detector ID list', detector_id_list)
# initialize output string: MTEX HEAD
mtex = 'NRSF2\n'
mtex += 'alpha beta intensity\n'
# user optional header
mtex += '{0}\n'.format(header)
# writing data
pf_keys = sorted(pole_figure_array_dict.keys())
for pf_key in pf_keys:
print(
'[STUDY ]Pole figure key = {}. It is in detector ID list {} = {}'
''.format(pf_key, detector_id_list, pf_key in detector_id_list))
if pf_key not in detector_id_list:
raise NotImplementedError(
'The data structure of pole figure array is not clear. '
'Find out how detector IDs are involved.')
sample_log_index, pole_figure_array = pole_figure_array_dict[pf_key]
for i_pt in range(pole_figure_array.shape[0]):
mtex += '{0:5.5f}\t{1:5.5f}\t{2:5.5f}\n' \
''.format(pole_figure_array[i_pt, 0], pole_figure_array[i_pt, 1], pole_figure_array[i_pt, 2])
# END-FOR (i_pt)
# END-FOR
# write file
p_file = open(file_name, 'w')
p_file.write(mtex)
p_file.close()
def calculate_pole_figure(self, det_id_list):
""" Calculate pole figures
:param det_id_list:
:return:
"""
# check input
if det_id_list is None:
det_id_list = self.get_detector_ids()
else:
checkdatatypes.check_list('Detector IDs to calculate pole figure',
det_id_list, self.get_detector_ids())
# END-IF
for det_id in det_id_list:
# calculator by each detector
peak_intensity_dict = self._peak_intensity_dict[det_id]
peak_info_dict = self._peak_info_dict[det_id]
# construct the output
scan_log_index_list = sorted(peak_intensity_dict.keys())
num_pts = len(scan_log_index_list)
pole_figure_array = np.ndarray(shape=(num_pts, 3), dtype='float')
for index, scan_index in enumerate(scan_log_index_list):
# check fitting result
intensity_i = peak_intensity_dict[scan_index]
# rotate Q from instrument coordinate to sample coordinate
theta_i = 0.5 * peak_info_dict[scan_index]['center']
omega_i = peak_info_dict[scan_index]['omega']
if omega_i < 0.:
omega_i += 90.
chi_i = peak_info_dict[scan_index]['chi']
phi_i = peak_info_dict[scan_index]['phi']
eta_i = peak_info_dict[scan_index]['eta']
alpha, beta = self.rotate_project_q(theta_i, omega_i, chi_i,
phi_i, eta_i)
pole_figure_array[index, 0] = alpha
pole_figure_array[index, 1] = beta
pole_figure_array[index, 2] = intensity_i
# END-FOR
# END-FOR
# convert
self._pole_figure_dict[
det_id] = scan_log_index_list, pole_figure_array
def get_pole_figure_values(self, data_key, detector_id_list, max_cost):
""" API method to get the (N, 3) array for pole figures
:param data_key:
:param detector_id_list:
:param max_cost:
:return:
"""
pole_figure_calculator = self._pole_figure_calculator_dict[data_key]
assert isinstance(pole_figure_calculator, polefigurecalculator.PoleFigureCalculator),\
'Pole figure calculator type mismatched. Input is of type {0} but expected as {1}.' \
''.format(type(pole_figure_calculator), 'polefigurecalculator.PoleFigureCalculato')
if detector_id_list is None:
detector_id_list = pole_figure_calculator.get_detector_ids()
else:
checkdatatypes.check_list('Detector ID list', detector_id_list)
# get all the pole figure vectors
vec_alpha = None
vec_beta = None
vec_intensity = None
for det_id in detector_id_list:
print(
'[DB...BAt] Get pole figure from detector {0}'.format(det_id))
# get_pole_figure returned 2 tuple. we need the second one as an array for alpha, beta, intensity
sub_array = pole_figure_calculator.get_pole_figure_vectors(
det_id, max_cost)[1]
vec_alpha_i = sub_array[:, 0]
vec_beta_i = sub_array[:, 1]
vec_intensity_i = sub_array[:, 2]
print('Det {} # data points = {}'.format(det_id, len(sub_array)))
# print ('alpha: {0}'.format(vec_alpha_i))
if vec_alpha is None:
vec_alpha = vec_alpha_i
vec_beta = vec_beta_i
vec_intensity = vec_intensity_i
else:
vec_alpha = numpy.concatenate((vec_alpha, vec_alpha_i), axis=0)
vec_beta = numpy.concatenate((vec_beta, vec_beta_i), axis=0)
vec_intensity = numpy.concatenate(
(vec_intensity, vec_intensity_i), axis=0)
print('Updated alpha: size = {0}: {1}'.format(
len(vec_alpha), vec_alpha))
return vec_alpha, vec_beta, vec_intensity
def export_pole_figure(self,
detector_id_list,
file_name,
file_type,
file_header=''):
"""
exported the calculated pole figure
:param detector_id_list: list of detector IDs to write the pole figure file
:param file_name:
:param file_type: ASCII or MTEX (.jul)
:param file_header: for MTEX format
:return:
"""
# TESTME - 20180711 - Clean this method and allow user to specifiy header
# process detector ID list
if detector_id_list is None:
detector_id_list = self.get_detector_ids()
else:
checkdatatypes.check_list('Detector IDs', detector_id_list)
# check inputs
checkdatatypes.check_file_name(file_name,
check_exist=False,
check_writable=True)
checkdatatypes.check_string_variable(
'Output pole figure file type/format', file_type)
# it is a dictionary now
if file_type.lower() == 'ascii':
# export pole figure arrays as ascii column file
export_arrays_to_ascii(self._pole_figure_dict, detector_id_list,
file_name)
elif file_type.lower() == 'mtex':
# export to MTEX format
export_to_mtex(self._pole_figure_dict,
detector_id_list,
file_name,
header=file_header)
return
def add_input_data_set(self, det_id, peak_intensity_dict,
peak_fit_info_dict, log_dict):
""" set peak intensity log and experiment logs that are required by pole figure calculation
:param det_id
:param peak_intensity_dict : dictionary (key = scan log index (int), value = peak intensity (float)
:param peak_fit_info_dict: dictionary (key = scan log index (int), value = peak fitting information (float)
:param log_dict: dictionary (key = scan log index (int), value = dictionary (log name, log value))
:return:
"""
# check inputs
if det_id in self._peak_intensity_dict:
raise RuntimeError(
'Detector ID {0} already been added. Must be reset calculator.'
''.format(det_id))
checkdatatypes.check_int_variable('Detector ID', det_id, (0, None))
checkdatatypes.check_dict('Peak intensities', peak_intensity_dict)
checkdatatypes.check_dict('Peak fitting information',
peak_fit_info_dict)
checkdatatypes.check_dict('Log values for pole figure', log_dict)
# check sample log index
if set(peak_intensity_dict.keys()) != set(log_dict.keys()):
raise RuntimeError(
'Sample log indexes from peak intensities and sample logs'
' do not match.')
# add peak intensity
self._peak_intensity_dict[det_id] = peak_intensity_dict
# go through all the values
for scan_log_index in log_dict:
# check each log index (entry) whether there are enough 2theta
log_names = log_dict[scan_log_index].keys()
checkdatatypes.check_list('Pole figure motor names', log_names,
['2theta', 'chi', 'phi', 'omega'])
# END-FOR
# set
self._peak_info_dict[det_id] = log_dict
self._peak_fit_info_dict[det_id] = peak_fit_info_dict
def export_arrays_to_ascii(pole_figure_array_dict, detector_id_list,
file_name):
"""
export a dictionary of arrays to an ASCII file
:param file_name:
:param detector_id_list: selected the detector IDs for pole figure
:param pole_figure_array_dict:
:return:
"""
# check input types
checkdatatypes.check_dict('Pole figure array dictionary',
pole_figure_array_dict)
checkdatatypes.check_list('Detector ID list', detector_id_list)
print(
'[INFO] Export Pole Figure Arrays To ASCII:\nKeys: {0}\nValues[0]: {1}'
''.format(pole_figure_array_dict.keys(),
pole_figure_array_dict.values()[0]))
# combine
pole_figure_array_list = list()
for pf_key in pole_figure_array_dict.keys():
index_vec, pole_figure_vec = pole_figure_array_dict[pf_key]
if pf_key not in detector_id_list:
raise NotImplementedError(
'The data structure of pole figure array is not clear. '
'Find out how detector IDs are involved.')
pole_figure_array_list.append(pole_figure_vec)
# END-FOR
combined_array = np.concatenate(pole_figure_array_list, axis=0)
# sort
combined_array = np.sort(combined_array, axis=0)
# save
np.savetxt(file_name, combined_array) # x,y,z equal sized 1D arrays
return
def set_statistics(self, stat_dict, row_item_list):
"""
:param stat_dict:
:param row_item_list: list of item names for each row in order to maitain the order
:return:
"""
checkdatatypes.check_dict('Statistic dictionary', stat_dict)
checkdatatypes.check_list('Row item names', row_item_list)
# add rows to fill the table
num_diff = len(row_item_list) - self.rowCount()
if num_diff > 0:
for i_row in range(num_diff):
self.append_row(['', 0., 0., 0.])
# fill the table
for i_row, item_name in enumerate(row_item_list):
self.update_cell_value(i_row, self._indexItemName, item_name)
for dir_i in stat_dict.keys():
self.update_cell_value(i_row, self._indexDirDict[dir_i],
stat_dict[dir_i][item_name])
def set_peak_parameter_names(self, peak_param_names):
""" set the peak parameter names to combo box for user to specify
:param peak_param_names:
:return:
"""
checkdatatypes.check_list('Peak parameter names', peak_param_names)
# lock
self._mutex_param_name_list = True
# write
self.ui.comboBox_parameterList.clear()
self.ui.comboBox_parameterNamesAnalysis.clear()
peak_param_names.sort()
for p_name in peak_param_names:
self.ui.comboBox_parameterList.addItem(p_name)
self.ui.comboBox_parameterNamesAnalysis.addItem(p_name)
# END-FOR
# unlock
self._mutex_param_name_list = False
return
