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