Esempio n. 1
0
    def update_fitting_plot(self):
        self.parent.ui.fitting.clear()
        if self.parent.fitting_peak_ui:
            self.parent.ui.fitting.removeItem(self.parent.fitting_peak_ui)

        o_get = Get(parent=self.parent)
        xaxis_checked = o_get.x_axis_checked()
        xaxis = o_get.x_axis_data(x_axis_selected=xaxis_checked)
        xaxis_label = o_get.x_axis_label(x_axis_selected=xaxis_checked)

        o_table = TableHandler(
            table_ui=self.parent.ui.march_dollase_result_table)
        list_row_selected = o_table.get_rows_of_table_selected()

        if list_row_selected is None:
            return

        for row_selected in list_row_selected:
            yaxis = o_get.y_axis_data_of_selected_row(
                row_selected=row_selected)
            self.parent.ui.fitting.plot(xaxis,
                                        yaxis,
                                        pen=(self.parent.selection_roi_rgb[0],
                                             self.parent.selection_roi_rgb[1],
                                             self.parent.selection_roi_rgb[2]),
                                        symbol='o')
            self.parent.ui.fitting.setLabel("bottom", xaxis_label)
            self.parent.ui.fitting.setLabel("left", "Average transmission")

        if self.parent.ui.march_dollase_toolBox.currentIndex() == 0:
            move_bragg_peak_range = True
        else:
            move_bragg_peak_range = False

        peak_range = self.parent.march_dollase_fitting_range_selected
        local_peak_range = [xaxis[peak_range[0]], xaxis[peak_range[1]]]

        if self.parent.march_dollase_fitting_peak_ui:
            self.parent.ui.fitting.removeItem(
                self.parent.march_dollase_fitting_peak_ui)
        self.parent.march_dollase_fitting_peak_ui = pg.LinearRegionItem(
            values=local_peak_range,
            orientation=None,
            brush=None,
            movable=move_bragg_peak_range,
            bounds=None)
        self.parent.march_dollase_fitting_peak_ui.sigRegionChanged.connect(
            self.parent.march_dollase_fitting_range_changed)
        self.parent.march_dollase_fitting_peak_ui.setZValue(-10)
        self.parent.ui.fitting.addItem(
            self.parent.march_dollase_fitting_peak_ui)
Esempio n. 2
0
    def export_data_of_selected_rows(self):

        base_folder = Path(self.parent.working_dir)
        directory = str(base_folder.parent)
        _export_folder = QFileDialog.getExistingDirectory(
            self.parent, directory=directory, caption="Select Output Folder")

        if _export_folder:
            o_table = TableHandler(
                table_ui=self.parent.ui.march_dollase_result_table)
            list_of_rows_selected = o_table.get_rows_of_table_selected()

            str_list_of_rows_selected = [
                str(_row) for _row in list_of_rows_selected
            ]
            str_rows = "_".join(str_list_of_rows_selected)
            output_file_name = os.path.join(
                str(_export_folder),
                "march_dollase_result_fitting_row{}.txt".format(str_rows))

            fitting_input_dictionary = self.parent.fitting_input_dictionary

            o_get = Get(parent=self.parent)
            xaxis_index = o_get.x_axis_data(x_axis_selected='index')
            xaxis_tof = o_get.x_axis_data(x_axis_selected='tof')
            xaxis_lambda = o_get.x_axis_data(x_axis_selected='lambda')

            # metadata
            metadata = ["#Marche Dollase Result of Fitting"]
            is_advance_mode = self.parent.ui.march_dollase_advanced_mode_checkBox.isChecked(
            )
            metadata.append(
                "#Using advanced fitting mode: {}".format(is_advance_mode))

            data_label = "#image index, TOF(micros), Lambda(Angstroms)"
            temp_data = []
            for _row in list_of_rows_selected:
                _entry = fitting_input_dictionary['rois'][_row]['fitting'][
                    'march_dollase']
                _top_entry = fitting_input_dictionary['rois'][_row]
                _line = "#-> row {}: x0: {}, y0:{}, width:{}, height:{}, " \
                        "d_spacing:{}, sigma:{}, alpha:{}, a1:{}, " \
                        "a2:{}".format(_row,
                                                   _top_entry['x0'],
                                                   _top_entry['y0'],
                                                   _top_entry['width'],
                                       _top_entry['height'],
                                                   _entry['d_spacing'],
                                                   _entry['sigma'],
                                                   _entry['alpha'],
                                                   _entry['a1'],
                                                   _entry['a2'])
                if is_advance_mode:
                    _line += ", a5:{}, a6:{}".format(_entry['a5'],
                                                     _entry['a6'])
                metadata.append(_line)
                data_label += ", row {}".format(_row)

                temp_data.append(
                    o_get.y_axis_data_of_selected_row(row_selected=_row))

            metadata.append("#")
            metadata.append(data_label)

            # data
            data = []
            self.parent.debug_data = temp_data

            for _index in np.arange(len(xaxis_index)):
                str_data = "{}, {}, {}".format(xaxis_index[_index],
                                               xaxis_tof[_index],
                                               xaxis_lambda[_index])
                for _col_index in np.arange(len(list_of_rows_selected)):
                    str_data += ", {}".format(temp_data[_col_index][_index])
                data.append(str_data)

            make_ascii_file(metadata=metadata,
                            data=data,
                            output_file_name=output_file_name,
                            dim='1d')

            message = "{} has been created!".format(output_file_name)
            self.parent.ui.statusbar.showMessage(message, 10000)  # 10s
Esempio n. 3
0
    def prepare(self):
        self.initialize_fitting_input_dictionary()
        fitting_input_dictionary = self.parent.fitting_input_dictionary
        march_dollase_fitting_history_table = self.parent.march_dollase_fitting_history_table

        _is_advanced_mode = self.is_advanced_mode()
        if _is_advanced_mode:
            gmodel = Model(march_dollase_advanced_fit, missing='drop')
        else:
            # gmodel = Model(march_dollase_basic_fit, missing='drop')
            gmodel = Model(march_dollase_basic_fit, nan_policy='propagate')

        march_dollase_fitting_history_table = self.parent.march_dollase_fitting_history_table
        nbr_row_in_fitting_scenario = len(march_dollase_fitting_history_table)

        self.parent.ui.eventProgress.setValue(0)
        nbr_roi_row = len(fitting_input_dictionary['rois'].keys())
        self.parent.ui.eventProgress.setMaximum(nbr_roi_row)
        self.parent.ui.eventProgress.setVisible(True)

        def set_params(params_object, name_of_parameter, dict_entry,
                       parameter_flag):
            params_object.add(name_of_parameter,
                              value=np.float(dict_entry[name_of_parameter]),
                              vary=parameter_flag)

        def record_result_into_dict(entry_dict, result_object,
                                    name_of_parameter, parameter_flag):
            if parameter_flag:
                print(f"-> name_of_parameter: {name_of_parameter}")
                [value,
                 error] = result_object.get_value_err(tag=name_of_parameter)
                entry_dict[name_of_parameter] = value
                entry_dict[name_of_parameter + "_error"] = error
                print(f"   - value: {value}")
                print(f"   - error: {error}")

        for _roi_row in np.arange(nbr_roi_row):
            _entry = fitting_input_dictionary['rois'][_roi_row]['fitting'][
                'march_dollase']

            o_get = Get(parent=self.parent)
            xaxis = o_get.x_axis_data(x_axis_selected='lambda')
            yaxis = o_get.y_axis_data_of_selected_row(_roi_row)

            for _history_row, _row_entry in enumerate(
                    march_dollase_fitting_history_table):

                [
                    d_spacing_flag, sigma_flag, alpha_flag, a1_flag, a2_flag,
                    a5_flag, a6_flag
                ] = _row_entry

                if _is_advanced_mode:
                    a5_flag = _entry['a5']
                    a6_flag = _entry['a6']

                params = gmodel.make_params()

                set_params(params, 'd_spacing', _entry, d_spacing_flag)
                set_params(params, 'sigma', _entry, sigma_flag)
                set_params(params, 'alpha', _entry, alpha_flag)
                set_params(params, 'a1', _entry, a1_flag)
                set_params(params, 'a2', _entry, a2_flag)

                if _is_advanced_mode:
                    set_params(params, 'a5', _entry, a5_flag)
                    set_params(params, 'a6', _entry, a6_flag)

                print("Parameters pre-initialized:")
                if not d_spacing_flag:
                    print(f"- d_spacing: {_entry['d_spacing']}")
                if not sigma_flag:
                    print(f"- sigma: {_entry['sigma']}")
                if not alpha_flag:
                    print(f"- alpha: {_entry['alpha']}")
                if not a1_flag:
                    print(f"- a1: {_entry['a1']}")
                if not a2_flag:
                    print(f"- a2: {_entry['a2']}")

                # try:
                result = gmodel.fit(yaxis, params, t=xaxis)
                # except ValueError:
                # 	print(f"we are having an error row:{_roi_row}")

                print(f"in _history_row: {_history_row}")

                o_result = ResultValueError(result=result)
                record_result_into_dict(_entry, o_result, 'd_spacing',
                                        d_spacing_flag)
                record_result_into_dict(_entry, o_result, 'sigma', sigma_flag)
                record_result_into_dict(_entry, o_result, 'alpha', alpha_flag)
                record_result_into_dict(_entry, o_result, 'a1', a1_flag)
                record_result_into_dict(_entry, o_result, 'a2', a2_flag)

                if _is_advanced_mode:
                    record_result_into_dict(_entry, o_result, 'a5', a5_flag)
                    record_result_into_dict(_entry, o_result, 'a6', a6_flag)

            break  # for debugging only (stop only after first row)

            self.parent.ui.eventProgress.setValue(_roi_row + 1)
            QApplication.processEvents()

        self.parent.ui.eventProgress.setVisible(False)
        self.parent.fitting_procedure_started['march-dollase'] = True