Changeset 6da3e3d in sasview for src/sas/qtgui/Perspectives/Fitting


Ignore:
Timestamp:
Sep 6, 2018 5:27:00 AM (6 years ago)
Author:
Laura Forster <Awork@…>
Branches:
ESS_GUI, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc
Children:
f84d793, 47471ec
Parents:
0eff615 (diff), 605d944 (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' of ​https://github.com/SasView/sasview into ESS_GUI

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

Legend:

Unmodified
Added
Removed

  • src/sas/qtgui/Perspectives/Fitting/FittingUtilities.py

    rff3b293 rb764ae5  
    430430 
    431431    theory_name = str(current_data.name.split()[0]) 
    432     residuals.name = "Residuals for " + str(theory_name) + "[" + \ 
    433                     str(reference_data.filename) + "]" 
     432    res_name = reference_data.filename if reference_data.filename else reference_data.name 
     433    residuals.name = "Residuals for " + str(theory_name) + "[" + res_name + "]" 
    434434    residuals.title = residuals.name 
    435435    residuals.ytransform = 'y' 
    … …  
    457457    """ 
    458458    weight = None 
     459    if data is None: 
     460        return [] 
    459461    if is2d: 
     462        if not hasattr(data, 'err_data'): 
     463            return [] 
    460464        dy_data = data.err_data 
    461465        data = data.data 
    462466    else: 
     467        if not hasattr(data, 'dy'): 
     468            return [] 
    463469        dy_data = data.dy 
    464470        data = data.y 

  • src/sas/qtgui/Perspectives/Fitting/FittingWidget.py

    r0eff615 r6da3e3d  
    6060 
    6161logger = logging.getLogger(__name__) 
    62  
    6362 
    6463class ToolTippedItemModel(QtGui.QStandardItemModel): 
    … …  
    225224        self.models = {} 
    226225        # Parameters to fit 
    227         self.parameters_to_fit = None 
     226        self.main_params_to_fit = [] 
     227        self.poly_params_to_fit = [] 
     228        self.magnet_params_to_fit = [] 
     229 
    228230        # Fit options 
    229231        self.q_range_min = 0.005 
    … …  
    263265        self.has_magnet_error_column = False 
    264266 
     267        # If the widget generated theory item, save it 
     268        self.theory_item = None 
     269 
    265270        # signal communicator 
    266271        self.communicate = self.parent.communicate 
    … …  
    385390        # Tag along functionality 
    386391        self.label.setText("Data loaded from: ") 
    387         self.lblFilename.setText(self.logic.data.filename) 
     392        if self.logic.data.filename: 
     393            self.lblFilename.setText(self.logic.data.filename) 
     394        else: 
     395            self.lblFilename.setText(self.logic.data.name) 
    388396        self.updateQRange() 
    389397        # Switch off Data2D control 
    … …  
    517525 
    518526        # Signals from separate tabs asking for replot 
    519         self.options_widget.plot_signal.connect(self.onOptionsUpdate) 
    520527        self.options_widget.plot_signal.connect(self.onOptionsUpdate) 
    521528 
    … …  
    948955        model = self.cbModel.currentText() 
    949956 
    950         # empty combobox forced to be read 
     957        # Assure the control is active 
     958        if not self.cbModel.isEnabled(): 
     959            return 
     960        # Empty combobox forced to be read 
    951961        if not model: 
    952962            return 
    953         # Reset structure factor 
    954         self.cbStructureFactor.setCurrentIndex(0) 
    955963 
    956964        # Reset parameters to fit 
    957         self.parameters_to_fit = None 
     965        self.resetParametersToFit() 
    958966        self.has_error_column = False 
    959967        self.has_poly_error_column = False 
    960968 
    961         self.respondToModelStructure(model=model, structure_factor=None) 
     969        structure = None 
     970        if self.cbStructureFactor.isEnabled(): 
     971            structure = str(self.cbStructureFactor.currentText()) 
     972        self.respondToModelStructure(model=model, structure_factor=structure) 
    962973 
    963974    def onSelectBatchFilename(self, data_index): 
    … …  
    979990 
    980991        # Reset parameters to fit 
    981         self.parameters_to_fit = None 
     992        self.resetParametersToFit() 
    982993        self.has_error_column = False 
    983994        self.has_poly_error_column = False 
    984995 
    985996        self.respondToModelStructure(model=model, structure_factor=structure) 
     997 
     998    def resetParametersToFit(self): 
     999        """ 
     1000        Clears the list of parameters to be fitted 
     1001        """ 
     1002        self.main_params_to_fit = [] 
     1003        self.poly_params_to_fit = [] 
     1004        self.magnet_params_to_fit = [] 
    9861005 
    9871006    def onCustomModelChange(self): 
    … …  
    10941113            self.disableModelCombo() 
    10951114            self.enableStructureCombo() 
     1115            # set the index to 0 
     1116            self.cbStructureFactor.setCurrentIndex(0) 
     1117            self.model_parameters = None 
    10961118            self._model_model.clear() 
    10971119            return 
    … …  
    11181140        model_row = item.row() 
    11191141        name_index = self._poly_model.index(model_row, 0) 
    1120         parameter_name = str(name_index.data()).lower() # "distribution of sld" etc. 
    1121         if "distribution of" in parameter_name: 
     1142        parameter_name = str(name_index.data()) # "distribution of sld" etc. 
     1143        if "istribution of" in parameter_name: 
    11221144            # just the last word 
    11231145            parameter_name = parameter_name.rsplit()[-1] 
    … …  
    11311153            parameter_name = parameter_name + '.width' 
    11321154            if value == QtCore.Qt.Checked: 
    1133                 self.parameters_to_fit.append(parameter_name) 
     1155                self.poly_params_to_fit.append(parameter_name) 
    11341156            else: 
    1135                 if parameter_name in self.parameters_to_fit: 
    1136                     self.parameters_to_fit.remove(parameter_name) 
    1137             self.cmdFit.setEnabled(self.parameters_to_fit != [] and self.logic.data_is_loaded) 
     1157                if parameter_name in self.poly_params_to_fit: 
     1158                    self.poly_params_to_fit.remove(parameter_name) 
     1159            self.cmdFit.setEnabled(self.haveParamsToFit()) 
    11381160 
    11391161        elif model_column in [delegate.poly_min, delegate.poly_max]: 
    … …  
    11871209            value = item.checkState() 
    11881210            if value == QtCore.Qt.Checked: 
    1189                 self.parameters_to_fit.append(parameter_name) 
     1211                self.magnet_params_to_fit.append(parameter_name) 
    11901212            else: 
    1191                 if parameter_name in self.parameters_to_fit: 
    1192                     self.parameters_to_fit.remove(parameter_name) 
    1193             self.cmdFit.setEnabled(self.parameters_to_fit != [] and self.logic.data_is_loaded) 
     1213                if parameter_name in self.magnet_params_to_fit: 
     1214                    self.magnet_params_to_fit.remove(parameter_name) 
     1215            self.cmdFit.setEnabled(self.haveParamsToFit()) 
    11941216            # Update state stack 
    11951217            self.updateUndo() 
    … …  
    14761498        qmin = self.q_range_min 
    14771499        qmax = self.q_range_max 
    1478         params_to_fit = self.parameters_to_fit 
     1500 
     1501        params_to_fit = self.main_params_to_fit 
     1502        if self.chkPolydispersity.isChecked(): 
     1503            params_to_fit += self.poly_params_to_fit 
     1504        if self.chkMagnetism.isChecked(): 
     1505            params_to_fit += self.magnet_params_to_fit 
    14791506        if not params_to_fit: 
    14801507            raise ValueError('Fitting requires at least one parameter to optimize.') 
    1481  
    1482         # Potential smearing added 
    1483         # Remember that smearing_min/max can be None -> 
    1484         # deal with it until Python gets discriminated unions 
    1485         self.addWeightingToData(data) 
    14861508 
    14871509        # Get the constraints. 
    … …  
    15011523            data = GuiUtils.dataFromItem(fit_index) 
    15021524            # Potential weights added directly to data 
    1503             self.addWeightingToData(data) 
     1525            weighted_data = self.addWeightingToData(data) 
    15041526            try: 
    1505                 fitter_single.set_model(model, fit_id, params_to_fit, data=data, 
     1527                fitter_single.set_model(model, fit_id, params_to_fit, data=weighted_data, 
    15061528                             constraints=constraints) 
    15071529            except ValueError as ex: 
    15081530                raise ValueError("Setting model parameters failed with: %s" % ex) 
    15091531 
    1510             qmin, qmax, _ = self.logic.computeRangeFromData(data) 
    1511             fitter_single.set_data(data=data, id=fit_id, smearer=smearer, qmin=qmin, 
     1532            qmin, qmax, _ = self.logic.computeRangeFromData(weighted_data) 
     1533            fitter_single.set_data(data=weighted_data, id=fit_id, smearer=smearer, qmin=qmin, 
    15121534                            qmax=qmax) 
    15131535            fitter_single.select_problem_for_fit(id=fit_id, value=1) 
    … …  
    19001922        Adds weighting contribution to fitting data 
    19011923        """ 
     1924        new_data = copy.deepcopy(data) 
    19021925        # Send original data for weighting 
    19031926        weight = FittingUtilities.getWeight(data=data, is2d=self.is2D, flag=self.weighting) 
    19041927        if self.is2D: 
    1905             data.err_data = weight 
     1928            new_data.err_data = weight 
    19061929        else: 
    1907             data.dy = weight 
    1908         pass 
     1930            new_data.dy = weight 
     1931 
     1932        return new_data 
    19091933 
    19101934    def updateQRange(self): 
    … …  
    19401964            # Allow the SF combobox visibility for the given sasmodel 
    19411965            self.enableStructureFactorControl(structure_factor) 
     1966            if self.cbStructureFactor.isEnabled(): 
     1967                structure_factor = self.cbStructureFactor.currentText() 
     1968                self.fromStructureFactorToQModel(structure_factor) 
    19421969 
    19431970        # Then, add multishells 
    … …  
    19742001        """ 
    19752002        name = model_name 
     2003        kernel_module = None 
    19762004        if self.cbCategory.currentText() == CATEGORY_CUSTOM: 
    19772005            # custom kernel load requires full path 
    … …  
    19792007        try: 
    19802008            kernel_module = generate.load_kernel_module(name) 
    1981         except ModuleNotFoundError: 
    1982             # maybe it's a recategorised custom model? 
    1983             name = os.path.join(ModelUtilities.find_plugins_dir(), model_name+".py") 
    1984             # If this rises, it's a valid problem. 
    1985             kernel_module = generate.load_kernel_module(name) 
     2009        except ModuleNotFoundError as ex: 
     2010            pass 
     2011 
     2012        if kernel_module is None: 
     2013            # mismatch between "name" attribute and actual filename. 
     2014            curr_model = self.models[model_name] 
     2015            name, _ = os.path.splitext(os.path.basename(curr_model.filename)) 
     2016            try: 
     2017                kernel_module = generate.load_kernel_module(name) 
     2018            except ModuleNotFoundError as ex: 
     2019                logging.error("Can't find the model "+ str(ex)) 
     2020                return 
    19862021 
    19872022        if hasattr(kernel_module, 'parameters'): 
    … …  
    20262061        Setting model parameters into QStandardItemModel based on selected _structure factor_ 
    20272062        """ 
     2063        if structure_factor is None or structure_factor=="None": 
     2064            return 
    20282065        structure_module = generate.load_kernel_module(structure_factor) 
    20292066        structure_parameters = modelinfo.make_parameter_table(getattr(structure_module, 'parameters', [])) 
    … …  
    20452082        self._last_model_row = self._model_model.rowCount() 
    20462083 
     2084    def haveParamsToFit(self): 
     2085        """ 
     2086        Finds out if there are any parameters ready to be fitted 
     2087        """ 
     2088        return (self.main_params_to_fit!=[] 
     2089                or self.poly_params_to_fit!=[] 
     2090                or self.magnet_params_to_fit != []) and \ 
     2091                self.logic.data_is_loaded 
     2092 
    20472093    def onMainParamsChange(self, item): 
    20482094        """ 
    … …  
    20532099        if model_column == 0: 
    20542100            self.checkboxSelected(item) 
    2055             self.cmdFit.setEnabled(self.parameters_to_fit != [] and self.logic.data_is_loaded) 
     2101            self.cmdFit.setEnabled(self.haveParamsToFit()) 
    20562102            # Update state stack 
    20572103            self.updateUndo() 
    … …  
    21122158        # Convert to proper indices and set requested enablement 
    21132159        self.setParameterSelection(status) 
    2114         #[self._model_model.item(row, 0).setCheckState(status) for row in self.selectedParameters()] 
    21152160        self._model_model.blockSignals(False) 
    21162161 
    21172162        # update the list of parameters to fit 
    2118         main_params = self.checkedListFromModel(self._model_model) 
    2119         poly_params = self.checkedListFromModel(self._poly_model) 
    2120         magnet_params = self.checkedListFromModel(self._magnet_model) 
    2121  
    2122         # Retrieve poly params names 
    2123         poly_params = [param.rsplit()[-1] + '.width' for param in poly_params] 
    2124  
    2125         self.parameters_to_fit = main_params + poly_params + magnet_params 
     2163        self.main_params_to_fit = self.checkedListFromModel(self._model_model) 
    21262164 
    21272165    def checkedListFromModel(self, model): 
    … …  
    21752213        name = self.nameFromData(fitted_data) 
    21762214        # Notify the GUI manager so it can create the theory model in DataExplorer 
    2177         new_item = GuiUtils.createModelItemWithPlot(fitted_data, name=name) 
    2178         self.communicate.updateTheoryFromPerspectiveSignal.emit(new_item) 
     2215        self.theory_item = GuiUtils.createModelItemWithPlot(fitted_data, name=name) 
     2216        self.communicate.updateTheoryFromPerspectiveSignal.emit(self.theory_item) 
    21792217 
    21802218    def nameFromData(self, fitted_data): 
    … …  
    22102248            completefn = self.methodCompleteForData() 
    22112249        smearer = self.smearing_widget.smearer() 
     2250        weight = FittingUtilities.getWeight(data=data, is2d=self.is2D, flag=self.weighting) 
     2251 
    22122252        # Awful API to a backend method. 
    22132253        calc_thread = self.methodCalculateForData()(data=data, 
    … …  
    22182258                                               smearer=smearer, 
    22192259                                               state=None, 
    2220                                                weight=None, 
     2260                                               weight=weight, 
    22212261                                               fid=None, 
    22222262                                               toggle_mode_on=False, 
    … …  
    22662306        residuals = self.calculateResiduals(fitted_data) 
    22672307        self.model_data = fitted_data 
    2268  
    2269         new_plots = [fitted_data, residuals] 
     2308        new_plots = [fitted_data] 
     2309        if residuals is not None: 
     2310            new_plots.append(residuals) 
     2311 
     2312        if self.data_is_loaded: 
     2313            GuiUtils.deleteRedundantPlots(self.all_data[self.data_index], new_plots) 
     2314        else: 
     2315            # delete theory items for the model, in order to get rid of any redundant items, e.g. beta(Q), S_eff(Q) 
     2316            self.communicate.deleteIntermediateTheoryPlotsSignal.emit(self.kernel_module.id) 
    22702317 
    22712318        # Create plots for intermediate product data 
    … …  
    22822329            new_plots.append(sq_data) 
    22832330 
    2284         if self.data_is_loaded: 
    2285             GuiUtils.deleteRedundantPlots(self.all_data[self.data_index], new_plots) 
    2286  
     2331        # Update/generate plots 
    22872332        for plot in new_plots: 
    2288             if hasattr(plot, "id") and "esidual" in plot.id: 
    2289                 # TODO: fix updates to residuals plot 
    2290                 pass 
    2291             elif plot is not None: 
    2292                 self.communicate.plotUpdateSignal.emit([plot]) 
     2333            self.communicate.plotUpdateSignal.emit([plot]) 
    22932334 
    22942335    def complete2D(self, return_data): 
    … …  
    23082349 
    23092350        # Modify fitted_data with weighting 
    2310         self.addWeightingToData(fitted_data) 
    2311  
    2312         self.createNewIndex(fitted_data) 
     2351        weighted_data = self.addWeightingToData(fitted_data) 
     2352 
     2353        self.createNewIndex(weighted_data) 
    23132354        # Calculate difference between return_data and logic.data 
    2314         self.chi2 = FittingUtilities.calculateChi2(fitted_data, self.logic.data) 
     2355        self.chi2 = FittingUtilities.calculateChi2(weighted_data, self.logic.data) 
    23152356        # Update the control 
    23162357        chi2_repr = "---" if self.chi2 is None else GuiUtils.formatNumber(self.chi2, high=True) 
    23172358        self.lblChi2Value.setText(chi2_repr) 
    23182359 
    2319         # self.communicate.plotUpdateSignal.emit([fitted_data]) 
    2320  
    23212360        # Plot residuals if actual data 
    23222361        if not self.data_is_loaded: 
    23232362            return 
    23242363 
    2325         residuals_plot = FittingUtilities.plotResiduals(self.data, fitted_data) 
     2364        residuals_plot = FittingUtilities.plotResiduals(self.data, weighted_data) 
    23262365        residuals_plot.id = "Residual " + residuals_plot.id 
    23272366        self.createNewIndex(residuals_plot) 
    … …  
    23922431        self._poly_model.clear() 
    23932432 
     2433        parameters = self.model_parameters.form_volume_parameters 
     2434        if self.is2D: 
     2435            parameters += self.model_parameters.orientation_parameters 
     2436 
    23942437        [self.setPolyModelParameters(i, param) for i, param in \ 
    2395             enumerate(self.model_parameters.form_volume_parameters) if param.polydisperse] 
     2438            enumerate(parameters) if param.polydisperse] 
     2439 
    23962440        FittingUtilities.addPolyHeadersToModel(self._poly_model) 
    23972441 
    … …  
    27512795 
    27522796        fp.chi2 = self.chi2 
    2753         fp.parameters_to_fit = self.parameters_to_fit 
     2797        fp.main_params_to_fit = self.main_params_to_fit 
     2798        fp.poly_params_to_fit = self.poly_params_to_fit 
     2799        fp.magnet_params_to_fit = self.magnet_params_to_fit 
    27542800        fp.kernel_module = self.kernel_module 
    27552801 
    … …  
    28112857        if self.all_data: 
    28122858            index = self.all_data[self.data_index] 
     2859        else: 
     2860            index = self.theory_item 
    28132861        report_logic = ReportPageLogic(self, 
    28142862                                       kernel_module=self.kernel_module, 

  • src/sas/qtgui/Perspectives/Fitting/ModelThread.py

    r3ae9179 r2df558e  
    117117                    self.source) 
    118118        else: 
    119             self.complete(image=output, 
    120                            data=self.data, 
    121                            page_id=self.page_id, 
    122                            model=self.model, 
    123                            state=self.state, 
    124                            toggle_mode_on=self.toggle_mode_on, 
    125                            elapsed=elapsed, 
    126                            index=index_model, 
    127                            fid=self.fid, 
    128                            qmin=self.qmin, 
    129                            qmax=self.qmax, 
    130                            weight=self.weight, 
     119            self.completefn((output, 
     120                           self.data, 
     121                           self.page_id, 
     122                           self.model, 
     123                           self.state, 
     124                           self.toggle_mode_on, 
     125                           elapsed, 
     126                           index_model, 
     127                           self.fid, 
     128                           self.qmin, 
     129                           self.qmax, 
     130                           self.weight, 
    131131                           #qstep=self.qstep, 
    132                            update_chisqr=self.update_chisqr, 
    133                            source=self.source) 
     132                           self.update_chisqr, 
     133                           self.source)) 
    134134 
    135135 
    … …  
    250250                    pq_values, sq_values) 
    251251        else: 
    252             self.complete(x=self.data.x[index], y=output[index], 
    253                           page_id=self.page_id, 
    254                           state=self.state, 
    255                           weight=self.weight, 
    256                           fid=self.fid, 
    257                           toggle_mode_on=self.toggle_mode_on, 
    258                           elapsed=elapsed, index=index, model=self.model, 
    259                           data=self.data, 
    260                           update_chisqr=self.update_chisqr, 
    261                           source=self.source, 
    262                           unsmeared_model=unsmeared_output, 
    263                           unsmeared_data=unsmeared_data, 
    264                           unsmeared_error=unsmeared_error, 
    265                           pq_model=pq_values, 
    266                           sq_model=sq_values) 
     252            self.completefn((self.data.x[index], output[index], 
     253                        self.page_id, 
     254                        self.state, 
     255                        self.weight, 
     256                        self.fid, 
     257                        self.toggle_mode_on, 
     258                        elapsed, index, self.model, 
     259                        self.data, 
     260                        self.update_chisqr, 
     261                        self.source, 
     262                        unsmeared_output, unsmeared_data, unsmeared_error, 
     263                        pq_values, sq_values)) 
    267264 
    268265    def results(self): 

  • src/sas/qtgui/Perspectives/Fitting/OptionsWidget.py

    re20870bc rb764ae5  
    7979        self.weightingGroup.buttonClicked.connect(self.onWeightingChoice) 
    8080 
     81        self.qmin = QMIN_DEFAULT 
     82        self.qmax = QMAX_DEFAULT 
     83        self.npts = NPTS_DEFAULT 
     84        if self.logic.data_is_loaded: 
     85            self.qmin, self.qmax, self.npts = self.logic.computeDataRange() 
    8186        self.initModel() 
    8287        self.initMapper() 
    8388        self.model.blockSignals(True) 
    84         self.updateQRange(QMIN_DEFAULT, QMAX_DEFAULT, NPTS_DEFAULT) 
    85         self.txtMaxRange.setText(str(QMAX_DEFAULT)) 
    86         self.txtMinRange.setText(str(QMIN_DEFAULT)) 
    87         self.txtNpts.setText(str(NPTS_DEFAULT)) 
    88         self.txtNptsFit.setText(str(NPTS_DEFAULT)) 
     89        self.updateQRange(self.qmin, self.qmax, self.npts) 
     90        self.txtMaxRange.setText(str(self.qmax)) 
     91        self.txtMinRange.setText(str(self.qmin)) 
     92        self.txtNpts.setText(str(self.npts)) 
     93        self.txtNptsFit.setText(str(self.npts)) 
    8994        self.model.blockSignals(False) 
    9095 
    … …  
    127132        Callback for running the mask editor 
    128133        """ 
    129         self.parent.communicate.maskEditorSignal.emit(self.logic.data) 
    130         pass 
     134        if isinstance(self.logic.data, Data2D): 
     135            self.parent.communicate.maskEditorSignal.emit(self.logic.data) 
    131136 
    132137    def onRangeReset(self): 
    … …  
    134139        Callback for resetting qmin/qmax 
    135140        """ 
    136         self.updateQRange(QMIN_DEFAULT, QMAX_DEFAULT, NPTS_DEFAULT) 
     141        self.updateQRange(self.qmin, self.qmax, self.npts) 
    137142 
    138143    def onWeightingChoice(self, button): 
    … …  
    157162        Enable/disable various UI elements based on data loaded 
    158163        """ 
     164        is2Ddata = isinstance(self.logic.data, Data2D) 
    159165        self.boxWeighting.setEnabled(True) 
    160         self.cmdMaskEdit.setEnabled(True) 
     166        self.cmdMaskEdit.setEnabled(is2Ddata) 
    161167        # Switch off txtNpts related controls 
    162168        self.txtNpts.setEnabled(False) 
    … …  
    178184        self.model.item(MODEL.index('MAX_RANGE')).setText(str(q_range_max)) 
    179185        self.model.item(MODEL.index('NPTS')).setText(str(npts)) 
     186        self.qmin, self.qmax, self.npts = q_range_min, q_range_max, npts 
    180187 
    181188    def state(self): 

  • src/sas/qtgui/Perspectives/Fitting/UI/FittingWidgetUI.ui

    rc1cfa80 rd686ff1  
    77    <x>0</x> 
    88    <y>0</y> 
    9     <width>680</width> 
    10     <height>605</height> 
     9    <width>566</width> 
     10    <height>646</height> 
    1111   </rect> 
    1212  </property> 
    … …  
    1919  <property name="minimumSize"> 
    2020   <size> 
    21     <width>434</width> 
    22     <height>466</height> 
     21    <width>445</width> 
     22    <height>540</height> 
    2323   </size> 
    2424  </property> 

  • src/sas/qtgui/Perspectives/Fitting/UI/OptionsWidgetUI.ui

    rc1e380e r79bd268  
    88    <y>0</y> 
    99    <width>522</width> 
    10     <height>667</height> 
     10    <height>455</height> 
    1111   </rect> 
    1212  </property> 

  • src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingWidgetTest.py

    r3f5b901 r605d944  
    1818from sas.qtgui.Perspectives.Fitting.FittingWidget import * 
    1919from sas.qtgui.Perspectives.Fitting.Constraint import Constraint 
    20  
     20import sas.qtgui.Utilities.LocalConfig 
    2121from sas.qtgui.UnitTesting.TestUtils import QtSignalSpy 
     22from sas.qtgui.Perspectives.Fitting.ModelThread import Calc1D 
     23from sas.qtgui.Perspectives.Fitting.ModelThread import Calc2D 
    2224 
    2325from sas.qtgui.Plotting.PlotterData import Data1D 
    … …  
    260262        self.widget.cbModel.setCurrentIndex(0) 
    261263 
    262         # Observe factor reset to None 
    263         self.assertEqual(self.widget.cbStructureFactor.currentText(), STRUCTURE_DEFAULT) 
     264        # Observe factor doesn't reset to None 
     265        self.assertEqual(self.widget.cbStructureFactor.currentText(), 'squarewell') 
    264266 
    265267        # Switch category to structure factor 
    … …  
    319321        Check that the fitting 1D data object is ready 
    320322        """ 
    321         # Mock the thread creation 
    322         threads.deferToThread = MagicMock() 
    323         # Model for theory 
    324         self.widget.SASModelToQModel("cylinder") 
    325         # Call the tested method 
    326         self.widget.calculateQGridForModel() 
    327         time.sleep(1) 
    328         # Test the mock 
    329         self.assertTrue(threads.deferToThread.called) 
    330         self.assertEqual(threads.deferToThread.call_args_list[0][0][0].__name__, "compute") 
     323 
     324        if LocalConfig.USING_TWISTED: 
     325            # Mock the thread creation 
     326            threads.deferToThread = MagicMock() 
     327            # Model for theory 
     328            self.widget.SASModelToQModel("cylinder") 
     329            # Call the tested method 
     330            self.widget.calculateQGridForModel() 
     331            time.sleep(1) 
     332            # Test the mock 
     333            self.assertTrue(threads.deferToThread.called) 
     334            self.assertEqual(threads.deferToThread.call_args_list[0][0][0].__name__, "compute") 
     335        else: 
     336            Calc2D.queue = MagicMock() 
     337            # Model for theory 
     338            self.widget.SASModelToQModel("cylinder") 
     339            # Call the tested method 
     340            self.widget.calculateQGridForModel() 
     341            time.sleep(1) 
     342            # Test the mock 
     343            self.assertTrue(Calc2D.queue.called) 
    331344 
    332345    def testCalculateResiduals(self): 
    … …  
    417430        index = self.widget._poly_model.index(0,0) 
    418431 
    419         #self.widget.show() 
    420         #QtWidgets.QApplication(sys.argv).exec_() 
    421  
    422  
    423432        # Set the checbox 
    424433        self.widget._poly_model.item(0,0).setCheckState(2) 
    425434        # Assure the parameter is added 
    426         self.assertEqual(self.widget.parameters_to_fit, ['radius_bell.width']) 
     435        self.assertEqual(self.widget.poly_params_to_fit, ['radius_bell.width']) 
    427436 
    428437        # Add another parameter 
    429438        self.widget._poly_model.item(2,0).setCheckState(2) 
    430439        # Assure the parameters are added 
    431         self.assertEqual(self.widget.parameters_to_fit, ['radius_bell.width', 'length.width']) 
     440        self.assertEqual(self.widget.poly_params_to_fit, ['radius_bell.width', 'length.width']) 
    432441 
    433442        # Change the min/max values 
    … …  
    638647        self.assertEqual(self.widget.cmdPlot.text(), 'Show Plot') 
    639648 
    640         self.widget.show() 
    641  
    642649        # Set data 
    643650        test_data = Data1D(x=[1,2], y=[1,2]) 
    644  
     651        item = QtGui.QStandardItem() 
     652        updateModelItem(item, test_data, "test") 
    645653        # Force same data into logic 
    646         self.widget.logic.data = test_data 
    647         self.widget.data_is_loaded = True 
     654        self.widget.data = item 
    648655 
    649656        # Change the category index so we have a model available 
    … …  
    683690 
    684691        # Test no fitting params 
    685         self.widget.parameters_to_fit = [] 
     692        self.widget.main_params_to_fit = [] 
    686693 
    687694        logging.error = MagicMock() 
    … …  
    691698        self.widget.close() 
    692699 
     700    def testOnEmptyFit2(self): 
    693701        test_data = Data2D(image=[1.0, 2.0, 3.0], 
    694702                           err_image=[0.01, 0.02, 0.03], 
    … …  
    701709        item = QtGui.QStandardItem() 
    702710        updateModelItem(item, test_data, "test") 
     711 
    703712        # Force same data into logic 
    704713        self.widget.data = item 
    … …  
    709718 
    710719        # Test no fitting params 
    711         self.widget.parameters_to_fit = [] 
     720        self.widget.main_params_to_fit = [] 
    712721 
    713722        logging.error = MagicMock() 
    … …  
    718727        self.widget.close() 
    719728 
    720  
    721     def testOnFit1D(self): 
     729    def notestOnFit1D(self): 
    722730        """ 
    723731        Test the threaded fitting call 
    … …  
    735743 
    736744        # Assing fitting params 
    737         self.widget.parameters_to_fit = ['scale'] 
     745        self.widget.main_params_to_fit = ['scale'] 
    738746 
    739747        # Spying on status update signal 
    … …  
    748756 
    749757            # the fit button changed caption and got disabled 
    750             self.assertEqual(self.widget.cmdFit.text(), 'Stop fit') 
    751             self.assertFalse(self.widget.cmdFit.isEnabled()) 
     758            # could fail if machine fast enough to finish 
     759            #self.assertEqual(self.widget.cmdFit.text(), 'Stop fit') 
     760            #self.assertFalse(self.widget.cmdFit.isEnabled()) 
    752761 
    753762            # Signal pushed up 
    … …  
    756765        self.widget.close() 
    757766 
    758     def testOnFit2D(self): 
     767    def notestOnFit2D(self): 
    759768        """ 
    760769        Test the threaded fitting call 
    … …  
    779788 
    780789        # Assing fitting params 
    781         self.widget.parameters_to_fit = ['scale'] 
     790        self.widget.main_params_to_fit = ['scale'] 
    782791 
    783792        # Spying on status update signal 
    … …  
    792801 
    793802            # the fit button changed caption and got disabled 
    794             self.assertEqual(self.widget.cmdFit.text(), 'Stop fit') 
    795             self.assertFalse(self.widget.cmdFit.isEnabled()) 
     803            #self.assertEqual(self.widget.cmdFit.text(), 'Stop fit') 
     804            #self.assertFalse(self.widget.cmdFit.isEnabled()) 
    796805 
    797806            # Signal pushed up 
    … …  
    851860        # Set data 
    852861        test_data = Data1D(x=[1,2], y=[1,2]) 
    853  
     862        item = QtGui.QStandardItem() 
     863        updateModelItem(item, test_data, "test") 
    854864        # Force same data into logic 
    855         self.widget.logic.data = test_data 
    856         self.widget.data_is_loaded = True 
     865        self.widget.data = item 
     866 
     867        # Force same data into logic 
    857868        category_index = self.widget.cbCategory.findText('Sphere') 
    858         self.widget.cbCategory.setCurrentIndex(category_index) 
    859         self.widget.parameters_to_fit = ['scale'] 
     869 
     870        self.widget.cbCategory.setCurrentIndex(category_index) 
     871        self.widget.main_params_to_fit = ['scale'] 
    860872        # Invoke the tested method 
    861873        fp = self.widget.currentState() 
    … …  
    905917 
    906918        # Test no fitting params 
    907         self.widget.parameters_to_fit = ['scale'] 
     919        self.widget.main_params_to_fit = ['scale'] 
    908920 
    909921        # Invoke the tested method 
    … …  
    937949        # Set data 
    938950        test_data = Data1D(x=[1,2], y=[1,2]) 
    939  
     951        item = QtGui.QStandardItem() 
     952        updateModelItem(item, test_data, "test") 
    940953        # Force same data into logic 
    941         self.widget.logic.data = test_data 
    942         self.widget.data_is_loaded = True 
     954        self.widget.data = item 
    943955        category_index = self.widget.cbCategory.findText("Sphere") 
    944956        self.widget.cbCategory.setCurrentIndex(category_index) 
    945         self.widget.parameters_to_fit = ['scale'] 
     957        self.widget.main_params_to_fit = ['scale'] 
    946958 
    947959        # Invoke the tested method 
    … …  
    954966        self.assertEqual(fp.current_category, "Sphere") 
    955967        self.assertEqual(fp.current_model, "adsorbed_layer") 
    956         self.assertListEqual(fp.parameters_to_fit, ['scale']) 
     968        self.assertListEqual(fp.main_params_to_fit, ['scale']) 
    957969 
    958970    def testPushFitPage(self): 
    … …  
    962974        # Set data 
    963975        test_data = Data1D(x=[1,2], y=[1,2]) 
    964  
     976        item = QtGui.QStandardItem() 
     977        updateModelItem(item, test_data, "test") 
    965978        # Force same data into logic 
    966         self.widget.logic.data = test_data 
    967         self.widget.data_is_loaded = True 
     979        self.widget.data = item 
    968980        category_index = self.widget.cbCategory.findText("Sphere") 
    969981 
    … …  
    974986        self.widget.undo_supported = True 
    975987        self.widget.cbCategory.setCurrentIndex(category_index) 
    976         self.widget.parameters_to_fit = ['scale'] 
     988        self.widget.main_params_to_fit = ['scale'] 
    977989 
    978990        # Check that the stack is updated 
Note: See TracChangeset for help on using the changeset viewer.