Changeset b95d748 in sasview for src/sas/qtgui/Perspectives/Fitting


Ignore:
Timestamp:
Oct 17, 2018 6:00:00 AM (5 years ago)
Author:
Piotr Rozyczko <piotr.rozyczko@…>
Branches:
ESS_GUI, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc
Children:
10d57f6
Parents:
345b3b3 (diff), dd545d1 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'ESS_GUI' into ESS_GUI_project_save

Location:
src/sas/qtgui/Perspectives/Fitting
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • src/sas/qtgui/Perspectives/Fitting/ConsoleUpdate.py

    r7adc2a8 ra4ceeb7  
    147147                    model_name = str(self.result.model.name) 
    148148                if m_flag and d_flag: 
    149                     msg += "Data : %s \n" % (str(data_name))#, 
    150                                                      #str(model_name)) 
     149                    msg += "Data : %s \n" % (str(data_name)) 
    151150                msg += str(self.result) 
    152151                msg += "\n" 
    153             else: 
    154                 msg += "No result available\n" 
    155152 
    156153            logging.info(msg) 
  • src/sas/qtgui/Perspectives/Fitting/FittingPerspective.py

    r345b3b3 rb95d748  
    102102 
    103103    def onParamCopy(self): 
    104         self.currentTab.onParameterCopy("") 
     104        self.currentTab.onCopyToClipboard("") 
    105105 
    106106    def onParamPaste(self): 
     
    108108 
    109109    def onExcelCopy(self): 
    110         self.currentTab.onParameterCopy("Excel") 
     110        self.currentTab.onCopyToClipboard("Excel") 
    111111 
    112112    def onLatexCopy(self): 
    113         self.currentTab.onParameterCopy("Latex") 
     113        self.currentTab.onCopyToClipboard("Latex") 
    114114 
    115115    def closeEvent(self, event): 
  • src/sas/qtgui/Perspectives/Fitting/FittingWidget.py

    r3ab2105 rdd545d1  
    119119        self.tab_id = tab_id 
    120120 
     121        import sys 
     122        sys.excepthook = self.info 
     123 
    121124        # Globals 
    122125        self.initializeGlobals() 
     
    163166        self.label_17.setStyleSheet(new_font) 
    164167        self.label_19.setStyleSheet(new_font) 
     168 
     169    def info(self, type, value, tb): 
     170        logger.error("SasView threw exception: " + str(value)) 
     171        traceback.print_exception(type, value, tb) 
    165172 
    166173    @property 
     
    543550 
    544551        # Respond to change in parameters from the UI 
    545         self._model_model.itemChanged.connect(self.onMainParamsChange) 
    546         #self.constraintAddedSignal.connect(self.modifyViewOnConstraint) 
    547         self._poly_model.itemChanged.connect(self.onPolyModelChange) 
    548         self._magnet_model.itemChanged.connect(self.onMagnetModelChange) 
     552        self._model_model.dataChanged.connect(self.onMainParamsChange) 
     553        self._poly_model.dataChanged.connect(self.onPolyModelChange) 
     554        self._magnet_model.dataChanged.connect(self.onMagnetModelChange) 
    549555        self.lstParams.selectionModel().selectionChanged.connect(self.onSelectionChanged) 
    550556 
     
    12071213        self.cbModel.addItems(sorted([model for (model, _) in model_list])) 
    12081214 
    1209     def onPolyModelChange(self, item): 
     1215    def onPolyModelChange(self, top, bottom): 
    12101216        """ 
    12111217        Callback method for updating the main model and sasmodel 
    12121218        parameters with the GUI values in the polydispersity view 
    12131219        """ 
     1220        item = self._poly_model.itemFromIndex(top) 
    12141221        model_column = item.column() 
    12151222        model_row = item.row() 
     
    12781285            self._model_model.blockSignals(False) 
    12791286 
    1280     def onMagnetModelChange(self, item): 
     1287    def onMagnetModelChange(self, top, bottom): 
    12811288        """ 
    12821289        Callback method for updating the sasmodel magnetic parameters with the GUI values 
    12831290        """ 
     1291        item = self._magnet_model.itemFromIndex(top) 
    12841292        model_column = item.column() 
    12851293        model_row = item.row() 
     
    17161724        # block signals temporarily, so we don't end up 
    17171725        # updating charts with every single model change on the end of fitting 
    1718         self._model_model.itemChanged.disconnect() 
     1726        self._model_model.dataChanged.disconnect() 
    17191727        self.iterateOverModel(updateFittedValues) 
    17201728        self.iterateOverModel(updatePolyValues) 
    1721         self._model_model.itemChanged.connect(self.onMainParamsChange) 
     1729        self._model_model.dataChanged.connect(self.onMainParamsChange) 
    17221730 
    17231731    def iterateOverPolyModel(self, func): 
     
    17711779        # block signals temporarily, so we don't end up 
    17721780        # updating charts with every single model change on the end of fitting 
    1773         self._poly_model.itemChanged.disconnect() 
     1781        self._poly_model.dataChanged.disconnect() 
    17741782        self.iterateOverPolyModel(updateFittedValues) 
    1775         self._poly_model.itemChanged.connect(self.onPolyModelChange) 
     1783        self._poly_model.dataChanged.connect(self.onPolyModelChange) 
    17761784 
    17771785        if self.has_poly_error_column: 
     
    18361844        # block signals temporarily, so we don't end up 
    18371845        # updating charts with every single model change on the end of fitting 
    1838         self._magnet_model.itemChanged.disconnect() 
     1846        self._magnet_model.dataChanged.disconnect() 
    18391847        self.iterateOverMagnetModel(updateFittedValues) 
    1840         self._magnet_model.itemChanged.connect(self.onMagnetModelChange) 
     1848        self._magnet_model.dataChanged.connect(self.onMagnetModelChange) 
    18411849 
    18421850        if self.has_magnet_error_column: 
     
    22722280        return False 
    22732281 
    2274     def onMainParamsChange(self, item): 
     2282    def onMainParamsChange(self, top, bottom): 
    22752283        """ 
    22762284        Callback method for updating the sasmodel parameters with the GUI values 
    22772285        """ 
     2286        item = self._model_model.itemFromIndex(top) 
     2287 
    22782288        model_column = item.column() 
    22792289 
     
    23012311        else: 
    23022312            parameter_name = str(self._model_model.data(name_index)) 
    2303  
    2304         # Update the parameter value - note: this supports +/-inf as well 
    2305         self.kernel_module.params[parameter_name] = value 
    23062313 
    23072314        # Update the parameter value - note: this supports +/-inf as well 
     
    31513158        # Update relevant models 
    31523159        self.setPolyModel() 
    3153         self.setMagneticModel() 
     3160        if self.canHaveMagnetism(): 
     3161            self.setMagneticModel() 
    31543162 
    31553163    def onShowSLDProfile(self): 
     
    34653473        #self._copy_parameters_state(self.fixed_param, self.state.fixed_param) 
    34663474 
    3467     def onParameterCopy(self, format=None): 
     3475    def onCopyToClipboard(self, format=None): 
     3476        """ 
     3477        Copy current fitting parameters into the clipboard 
     3478        using requested formatting: 
     3479        plain, excel, latex 
     3480        """ 
     3481        param_list = self.getFitParameters() 
     3482        if format=="": 
     3483            formatted_output = FittingUtilities.formatParameters(param_list) 
     3484        elif format == "Excel": 
     3485            formatted_output = FittingUtilities.formatParametersExcel(param_list[1:]) 
     3486        elif format == "Latex": 
     3487            formatted_output = FittingUtilities.formatParametersLatex(param_list[1:]) 
     3488        else: 
     3489            raise AttributeError("Bad parameter output format specifier.") 
     3490 
     3491        # Dump formatted_output to the clipboard 
     3492        cb = QtWidgets.QApplication.clipboard() 
     3493        cb.setText(formatted_output) 
     3494 
     3495    def getFitParameters(self, format=None): 
    34683496        """ 
    34693497        Copy current parameters into the clipboard 
     
    34723500        # first - regular params 
    34733501        param_list = [] 
    3474  
    34753502        param_list.append(['model_name', str(self.cbModel.currentText())]) 
     3503 
    34763504        def gatherParams(row): 
    34773505            """ 
     
    34793507            """ 
    34803508            param_name = str(self._model_model.item(row, 0).text()) 
     3509 
     3510            # Assure this is a parameter - must contain a checkbox 
     3511            if not self._model_model.item(row, 0).isCheckable(): 
     3512                # maybe it is a combobox item (multiplicity) 
     3513                try: 
     3514                    index = self._model_model.index(row, 1) 
     3515                    widget = self.lstParams.indexWidget(index) 
     3516                    if widget is None: 
     3517                        return 
     3518                    if isinstance(widget, QtWidgets.QComboBox): 
     3519                        # find the index of the combobox 
     3520                        current_index = widget.currentIndex() 
     3521                        param_list.append([param_name, 'None', str(current_index)]) 
     3522                except Exception as ex: 
     3523                    pass 
     3524                return 
     3525 
    34813526            param_checked = str(self._model_model.item(row, 0).checkState() == QtCore.Qt.Checked) 
     3527            # Value of the parameter. In some cases this is the text of the combobox choice. 
    34823528            param_value = str(self._model_model.item(row, 1).text()) 
    34833529            param_error = None 
     
    34863532            column_offset = 0 
    34873533            if self.has_error_column: 
    3488                 param_error = str(self._model_model.item(row, 2).text()) 
    34893534                column_offset = 1 
    3490  
    34913535            try: 
    34923536                param_min = str(self._model_model.item(row, 2+column_offset).text()) 
     
    34953539                pass 
    34963540 
    3497             param_list.append([param_name, param_checked, param_value, param_error, param_min, param_max]) 
     3541            param_list.append([param_name, param_checked, param_value, param_min, param_max]) 
    34983542 
    34993543        def gatherPolyParams(row): 
     
    35073551            column_offset = 0 
    35083552            if self.has_poly_error_column: 
    3509                 param_error = str(self._poly_model.item(row, 2).text()) 
    35103553                column_offset = 1 
    35113554            param_min   = str(self._poly_model.item(row, 2+column_offset).text()) 
     
    35143557            param_nsigs = str(self._poly_model.item(row, 5+column_offset).text()) 
    35153558            param_fun   = str(self._poly_model.item(row, 6+column_offset).text()).rstrip() 
     3559            index = self._poly_model.index(row, 6+column_offset) 
     3560            widget = self.lstPoly.indexWidget(index) 
     3561            if widget is not None and isinstance(widget, QtWidgets.QComboBox): 
     3562                param_fun = widget.currentText() 
    35163563            # width 
    35173564            name = param_name+".width" 
    3518             param_list.append([name, param_checked, param_value, param_error, 
    3519                                 param_npts, param_nsigs, param_min, param_max, param_fun]) 
     3565            param_list.append([name, param_checked, param_value, param_min, param_max, 
     3566                                param_npts, param_nsigs, param_fun]) 
    35203567 
    35213568        def gatherMagnetParams(row): 
     
    35293576            column_offset = 0 
    35303577            if self.has_magnet_error_column: 
    3531                 param_error = str(self._magnet_model.item(row, 2).text()) 
    35323578                column_offset = 1 
    35333579            param_min = str(self._magnet_model.item(row, 2+column_offset).text()) 
    35343580            param_max = str(self._magnet_model.item(row, 3+column_offset).text()) 
    3535             param_list.append([param_name, param_checked, param_value, param_error, param_min, param_max]) 
     3581            param_list.append([param_name, param_checked, param_value, param_min, param_max]) 
    35363582 
    35373583        self.iterateOverModel(gatherParams) 
     
    35413587            self.iterateOverMagnetModel(gatherMagnetParams) 
    35423588 
    3543         if format=="": 
    3544             formatted_output = FittingUtilities.formatParameters(param_list) 
    3545         elif format == "Excel": 
    3546             formatted_output = FittingUtilities.formatParametersExcel(param_list[1:]) 
    3547         elif format == "Latex": 
    3548             formatted_output = FittingUtilities.formatParametersLatex(param_list[1:]) 
    3549         else: 
    3550             raise AttributeError("Bad format specifier.") 
    3551  
    3552         # Dump formatted_output to the clipboard 
    3553         cb = QtWidgets.QApplication.clipboard() 
    3554         cb.setText(formatted_output) 
     3589        if self.kernel_module.is_multiplicity_model: 
     3590            param_list.append(['multiplicity', str(self.kernel_module.multiplicity)]) 
     3591 
     3592        # option tab 
     3593        param_list.append(['q_range_min', str(self.q_range_min)]) 
     3594        param_list.append(['q_range_max', str(self.q_range_max)]) 
     3595        param_list.append(['q_weighting', str(self.weighting)]) 
     3596 
     3597        # resolution 
     3598        smearing, accuracy, smearing_min, smearing_max = self.smearing_widget.state() 
     3599        index = self.smearing_widget.cbSmearing.currentIndex() 
     3600        param_list.append(['smearing', str(index)]) 
     3601        param_list.append(['smearing_min', str(smearing_min)]) 
     3602        param_list.append(['smearing_max', str(smearing_max)]) 
     3603 
     3604        # checkboxes, if required 
     3605        has_polydisp = self.chkPolydispersity.isChecked() 
     3606        has_magnetism = self.chkMagnetism.isChecked() 
     3607        has_chain = self.chkChainFit.isChecked() 
     3608        has_2D = self.chk2DView.isChecked() 
     3609        param_list.append(['polydisperse_params', str(has_polydisp)]) 
     3610        param_list.append(['magnetic_params', str(has_magnetism)]) 
     3611        param_list.append(['chainfit_params', str(has_chain)]) 
     3612        param_list.append(['2D_params', str(has_2D)]) 
     3613 
     3614        return param_list 
    35553615 
    35563616    def onParameterPaste(self): 
     
    35633623 
    35643624        context = {} 
    3565         # put the text into dictionary 
    35663625        lines = cb_text.split(':') 
    35673626        if lines[0] != 'sasview_parameter_values': 
    35683627            return False 
    35693628 
    3570         model = lines[1].split(',') 
    3571  
    3572         if model[0] != 'model_name': 
     3629        # put the text into dictionary 
     3630        line_dict = {} 
     3631        for line in lines[1:]: 
     3632            content = line.split(',') 
     3633            if len(content) > 1: 
     3634                line_dict[content[0]] = content[1:] 
     3635 
     3636        model = line_dict['model_name'][0] 
     3637 
     3638        if 'model_name' not in line_dict.keys(): 
    35733639            return False 
    35743640 
    3575         context['model_name'] = [model[1]] 
    3576         for line in lines[2:-1]: 
    3577             if len(line) != 0: 
    3578                 item = line.split(',') 
    3579                 check = item[1] 
    3580                 name = item[0] 
    3581                 value = item[2] 
    3582                 # Transfer the text to content[dictionary] 
    3583                 context[name] = [check, value] 
    3584  
    3585                 # limits 
    3586                 try: 
    3587                     limit_lo = item[3] 
    3588                     context[name].append(limit_lo) 
    3589                     limit_hi = item[4] 
    3590                     context[name].append(limit_hi) 
    3591                 except: 
    3592                     pass 
    3593  
    3594                 # Polydisp 
    3595                 if len(item) > 5: 
    3596                     value = item[5] 
    3597                     context[name].append(value) 
    3598                     try: 
    3599                         value = item[6] 
    3600                         context[name].append(value) 
    3601                         value = item[7] 
    3602                         context[name].append(value) 
    3603                     except IndexError: 
    3604                         pass 
    3605  
    3606         if str(self.cbModel.currentText()) != str(context['model_name'][0]): 
     3641        if 'multiplicity' in line_dict.keys(): 
     3642            multip = int(line_dict['multiplicity'][0], 0) 
     3643            # reset the model with multiplicity, so further updates are saved 
     3644            if self.kernel_module.is_multiplicity_model: 
     3645                self.kernel_module.multiplicity=multip 
     3646                self.updateMultiplicityCombo(multip) 
     3647 
     3648        if 'polydisperse_params' in line_dict.keys(): 
     3649            self.chkPolydispersity.setChecked(line_dict['polydisperse_params'][0]=='True') 
     3650        if 'magnetic_params' in line_dict.keys(): 
     3651            self.chkMagnetism.setChecked(line_dict['magnetic_params'][0]=='True') 
     3652        if 'chainfit_params' in line_dict.keys(): 
     3653            self.chkChainFit.setChecked(line_dict['chainfit_params'][0]=='True') 
     3654        if '2D_params' in line_dict.keys(): 
     3655            self.chk2DView.setChecked(line_dict['2D_params'][0]=='True') 
     3656 
     3657        # Create the context dictionary for parameters 
     3658        context['model_name'] = model 
     3659        for key, value in line_dict.items(): 
     3660            if len(value) > 2: 
     3661                context[key] = value 
     3662 
     3663        if str(self.cbModel.currentText()) != str(context['model_name']): 
    36073664            msg = QtWidgets.QMessageBox() 
    36083665            msg.setIcon(QtWidgets.QMessageBox.Information) 
     
    36163673                return 
    36173674 
     3675        if 'smearing' in line_dict.keys(): 
     3676            try: 
     3677                index = int(line_dict['smearing'][0]) 
     3678                self.smearing_widget.cbSmearing.setCurrentIndex(index) 
     3679            except ValueError: 
     3680                pass 
     3681        if 'smearing_min' in line_dict.keys(): 
     3682            try: 
     3683                self.smearing_widget.dq_l = float(line_dict['smearing_min'][0]) 
     3684            except ValueError: 
     3685                pass 
     3686        if 'smearing_max' in line_dict.keys(): 
     3687            try: 
     3688                self.smearing_widget.dq_r = float(line_dict['smearing_max'][0]) 
     3689            except ValueError: 
     3690                pass 
     3691 
     3692        if 'q_range_max' in line_dict.keys(): 
     3693            try: 
     3694                self.q_range_min = float(line_dict['q_range_min'][0]) 
     3695                self.q_range_max = float(line_dict['q_range_max'][0]) 
     3696            except ValueError: 
     3697                pass 
     3698        self.options_widget.updateQRange(self.q_range_min, self.q_range_max, self.npts) 
     3699 
    36183700        self.updateFullModel(context) 
    36193701        self.updateFullPolyModel(context) 
     3702        self.updateFullMagnetModel(context) 
     3703 
     3704    def updateMultiplicityCombo(self, multip): 
     3705        """ 
     3706        Find and update the multiplicity combobox 
     3707        """ 
     3708        index = self._model_model.index(self._n_shells_row, 1) 
     3709        widget = self.lstParams.indexWidget(index) 
     3710        if widget is not None and isinstance(widget, QtWidgets.QComboBox): 
     3711            widget.setCurrentIndex(widget.findText(str(multip))) 
     3712        self.current_shell_displayed = multip 
    36203713 
    36213714    def updateFullModel(self, param_dict): 
     
    36333726            if param_name not in list(param_dict.keys()): 
    36343727                return 
     3728            # Special case of combo box in the cell (multiplicity) 
     3729            param_line = param_dict[param_name] 
     3730            if len(param_line) == 1: 
     3731                # modify the shells value 
     3732                try: 
     3733                    combo_index = int(param_line[0]) 
     3734                except ValueError: 
     3735                    # quietly pass 
     3736                    return 
     3737                index = self._model_model.index(row, 1) 
     3738                widget = self.lstParams.indexWidget(index) 
     3739                if widget is not None and isinstance(widget, QtWidgets.QComboBox): 
     3740                    #widget.setCurrentIndex(combo_index) 
     3741                    return 
    36353742            # checkbox state 
    36363743            param_checked = QtCore.Qt.Checked if param_dict[param_name][0] == "True" else QtCore.Qt.Unchecked 
    36373744            self._model_model.item(row, 0).setCheckState(param_checked) 
    36383745 
    3639             # modify the param value 
    3640             param_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True) 
    3641             self._model_model.item(row, 1).setText(param_repr) 
     3746            # parameter value can be either just a value or text on the combobox 
     3747            param_text = param_dict[param_name][1] 
     3748            index = self._model_model.index(row, 1) 
     3749            widget = self.lstParams.indexWidget(index) 
     3750            if widget is not None and isinstance(widget, QtWidgets.QComboBox): 
     3751                # Find the right index based on text 
     3752                combo_index = int(param_text, 0) 
     3753                widget.setCurrentIndex(combo_index) 
     3754            else: 
     3755                # modify the param value 
     3756                param_repr = GuiUtils.formatNumber(param_text, high=True) 
     3757                self._model_model.item(row, 1).setText(param_repr) 
    36423758 
    36433759            # Potentially the error column 
     
    36453761            if len(param_dict[param_name])>4 and self.has_error_column: 
    36463762                # error values are not editable - no need to update 
    3647                 #error_repr = GuiUtils.formatNumber(param_dict[param_name][2], high=True) 
    3648                 #self._model_model.item(row, 2).setText(error_repr) 
    36493763                ioffset = 1 
    36503764            # min/max 
     
    36593773            self.setFocus() 
    36603774 
    3661  
    3662  
    3663         # block signals temporarily, so we don't end up 
    3664         # updating charts with every single model change on the end of fitting 
    3665         self._model_model.blockSignals(True) 
    36663775        self.iterateOverModel(updateFittedValues) 
    3667         self._model_model.blockSignals(False) 
    3668  
    36693776 
    36703777    def updateFullPolyModel(self, param_dict): 
     
    37133820            self.setFocus() 
    37143821 
    3715         # block signals temporarily, so we don't end up 
    3716         # updating charts with every single model change on the end of fitting 
    3717         self._poly_model.blockSignals(True) 
    37183822        self.iterateOverPolyModel(updateFittedValues) 
    3719         self._poly_model.blockSignals(False) 
    3720  
    3721  
    3722  
     3823 
     3824    def updateFullMagnetModel(self, param_dict): 
     3825        """ 
     3826        Update the magnetism model with new parameters, create the errors column 
     3827        """ 
     3828        assert isinstance(param_dict, dict) 
     3829        if not dict: 
     3830            return 
     3831 
     3832        def updateFittedValues(row): 
     3833            # Utility function for main model update 
     3834            # internal so can use closure for param_dict 
     3835            if row >= self._magnet_model.rowCount(): 
     3836                return 
     3837            param_name = str(self._magnet_model.item(row, 0).text()).rsplit()[-1] 
     3838            if param_name not in list(param_dict.keys()): 
     3839                return 
     3840            # checkbox state 
     3841            param_checked = QtCore.Qt.Checked if param_dict[param_name][0] == "True" else QtCore.Qt.Unchecked 
     3842            self._magnet_model.item(row,0).setCheckState(param_checked) 
     3843 
     3844            # modify the param value 
     3845            param_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True) 
     3846            self._magnet_model.item(row, 1).setText(param_repr) 
     3847 
     3848            # Potentially the error column 
     3849            ioffset = 0 
     3850            if len(param_dict[param_name])>4 and self.has_magnet_error_column: 
     3851                ioffset = 1 
     3852            # min 
     3853            param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True) 
     3854            self._magnet_model.item(row, 2+ioffset).setText(param_repr) 
     3855            # max 
     3856            param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True) 
     3857            self._magnet_model.item(row, 3+ioffset).setText(param_repr) 
     3858 
     3859        self.iterateOverMagnetModel(updateFittedValues) 
  • src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingWidgetTest.py

    ra4b9b7a rd2007a8  
    10101010 
    10111011        # Change another parameter 
    1012         self.widget._model_model.item(2, 1).setText("3.0") 
     1012        self.widget._model_model.item(3, 1).setText("3.0") 
     1013 
    10131014        # Check that the stack is updated 
    10141015        self.assertEqual(len(self.widget.page_stack), 2) 
Note: See TracChangeset for help on using the changeset viewer.