Changes in / [48e55c9:4d959c8] in sasview


Ignore:
Location:
src/sas/qtgui
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • src/sas/qtgui/MainWindow/DataExplorer.py

    r2b8286c r0cd98a1  
    9898        self.communicator.maskEditorSignal.connect(self.showEditDataMask) 
    9999        self.communicator.extMaskEditorSignal.connect(self.extShowEditDataMask) 
    100         self.communicator.changeDataExplorerTabSignal.connect(self.changeTabs) 
    101100 
    102101        self.cbgraph.editTextChanged.connect(self.enableGraphCombo) 
    … …  
    140139        else: 
    141140            self.current_view = self.freezeView 
    142  
    143     def changeTabs(self, tab=0): 
    144         """ 
    145         Switch tabs of the data explorer 
    146         0: data tab 
    147         1: theory tab 
    148         """ 
    149         assert(tab in [0,1]) 
    150         self.setCurrentIndex(tab) 
    151141 
    152142    def displayHelp(self): 
    … …  
    563553        return item 
    564554 
    565     def displayFile(self, filename=None, is_data=True, id=None): 
     555    def displayFile(self, filename=None, is_data=True): 
    566556        """ 
    567557        Forces display of charts for the given filename 
    … …  
    570560        # Now query the model item for available plots 
    571561        plots = GuiUtils.plotsFromFilename(filename, model) 
    572         # Each fitpage contains the name based on fit widget number 
    573         fitpage_name = "" if id is None else "M"+str(id) 
     562 
    574563        new_plots = [] 
    575564        for item, plot in plots.items(): 
    576             if self.updatePlot(plot) and filename != plot.name: 
    577                 continue 
    578             # Don't plot intermediate results, e.g. P(Q), S(Q) 
    579             match = GuiUtils.theory_plot_ID_pattern.match(plot.id) 
    580             # 2nd match group contains the identifier for the intermediate result, if present (e.g. "[P(Q)]") 
    581             if match and match.groups()[1] != None: 
    582                 continue 
    583             # Don't include plots from different fitpages, but always include the original data 
    584             if fitpage_name in plot.name or filename == plot.name: 
     565            if not self.updatePlot(plot): 
     566                # Don't plot intermediate results, e.g. P(Q), S(Q) 
     567                match = GuiUtils.theory_plot_ID_pattern.match(plot.id) 
     568                # 2nd match group contains the identifier for the intermediate result, if present (e.g. "[P(Q)]") 
     569                if match and match.groups()[1] != None: 
     570                    continue 
    585571                # 'sophisticated' test to generate standalone plot for residuals 
    586572                if 'esiduals' in plot.title: 
    … …  
    593579            self.plotData(new_plots) 
    594580 
    595     def displayData(self, data_list, id=None): 
     581    def displayData(self, data_list): 
    596582        """ 
    597583        Forces display of charts for the given data set 
    … …  
    602588        # the data explorer indices. 
    603589        filename = plot_to_show.filename 
    604         self.displayFile(filename=filename, is_data=plot_to_show.is_data, id=id) 
     590        self.displayFile(filename=filename, is_data=plot_to_show.is_data) 
    605591 
    606592    def addDataPlot2D(self, plot_set, item): 

  • src/sas/qtgui/MainWindow/GuiManager.py

    r5b144c6 r339e22b  
    921921            self.filesWidget.displayFile(filename=filename, is_data=True) 
    922922 
    923     def showPlot(self, plot, id): 
     923    def showPlot(self, plot): 
    924924        """ 
    925925        Pass the show plot request to the data explorer 
    926926        """ 
    927927        if hasattr(self, "filesWidget"): 
    928             self.filesWidget.displayData(plot, id) 
     928            self.filesWidget.displayData(plot) 
    929929 
    930930    def uncheckAllMenuItems(self, menuObject): 

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

    r61f0c75 rdcabba7  
    213213        plots = [] 
    214214        for name, result in return_data['intermediate_results'].items(): 
    215             if not isinstance(result, np.ndarray): 
    216                 continue 
    217215            plots.append(self._create1DPlot(tab_id, return_data['x'], result, 
    218216                         return_data['model'], return_data['data'], 

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

    rbb477f5 rd4ba565  
    569569            menu.exec_(self.lstParams.viewport().mapToGlobal(position)) 
    570570        except AttributeError as ex: 
    571             logger.error("Error generating context menu: %s" % ex) 
     571            logging.error("Error generating context menu: %s" % ex) 
    572572        return 
    573573 
    … …  
    14561456            self.communicate.statusBarUpdateSignal.emit(msg) 
    14571457            msg += results.mesg 
    1458             logger.error(msg) 
     1458            logging.error(msg) 
    14591459            return 
    14601460 
    … …  
    14991499        if self.calc_fit._interrupting: 
    15001500            msg = "Fitting cancelled by user after: %s s." % GuiUtils.formatNumber(elapsed) 
    1501             logger.warning("\n"+msg+"\n") 
     1501            logging.warning("\n"+msg+"\n") 
    15021502        else: 
    15031503            msg = "Fitting completed successfully in: %s s." % GuiUtils.formatNumber(elapsed) 
    … …  
    18411841        data_to_show = self.data if self.data_is_loaded else self.model_data 
    18421842        if data_to_show is not None: 
    1843             self.communicate.plotRequestedSignal.emit([data_to_show], self.tab_id) 
     1843            self.communicate.plotRequestedSignal.emit([data_to_show]) 
    18441844 
    18451845    def onOptionsUpdate(self): 
    … …  
    20522052                kernel_module = generate.load_kernel_module(name) 
    20532053            except ModuleNotFoundError as ex: 
    2054                 logger.error("Can't find the model "+ str(ex)) 
     2054                logging.error("Can't find the model "+ str(ex)) 
    20552055                return 
    20562056 
    … …  
    22872287            fitted_data.symbol = "Line" 
    22882288            self.createTheoryIndex(fitted_data) 
    2289             # Switch to the theory tab for user's glee 
    2290             self.communicate.changeDataExplorerTabSignal.emit(1) 
    22912289 
    22922290    def updateModelIndex(self, fitted_data): 
    … …  
    24242422 
    24252423        if self.data_is_loaded: 
    2426             # delete any plots associated with the data that were not updated (e.g. to remove beta(Q), S_eff(Q)) 
    24272424            GuiUtils.deleteRedundantPlots(self.all_data[self.data_index], new_plots) 
    2428             pass 
    24292425        else: 
    24302426            # delete theory items for the model, in order to get rid of any redundant items, e.g. beta(Q), S_eff(Q) 
    … …  
    25152511        """ 
    25162512        # TODO: remimplement thread cancellation 
    2517         logger.error("".join(traceback.format_exception(etype, value, tb))) 
     2513        logging.error("".join(traceback.format_exception(etype, value, tb))) 
    25182514 
    25192515    def setTableProperties(self, table): 
    … …  
    26972693 
    26982694        if not datafile: 
    2699             logger.info("No weight data chosen.") 
     2695            logging.info("No weight data chosen.") 
    27002696            raise IOError 
    27012697 
    … …  
    28132809        self._n_shells_row = shell_row - 1 
    28142810 
    2815         # Get the default number of shells for the model 
    2816         kernel_pars = self.kernel_module._model_info.parameters.kernel_parameters 
    2817         shell_par = None 
    2818         for par in kernel_pars: 
    2819             if par.name == param_name: 
    2820                 shell_par = par 
    2821                 break 
    2822         if not shell_par: 
    2823             logger.error("Could not find %s in kernel parameters.", param_name) 
    2824         default_shell_count = shell_par.default 
    2825  
    2826         # Add default number of shells to the model 
    2827         func.setCurrentIndex(default_shell_count) 
     2811        # Set the index to the state-kept value 
     2812        func.setCurrentIndex(self.current_shell_displayed 
     2813                             if self.current_shell_displayed < func.count() else 0) 
    28282814 
    28292815    def modifyShellsInList(self, index): 
    … …  
    31393125            param_value = str(self._model_model.item(row, 1).text()) 
    31403126            param_error = None 
    3141             param_min = None 
    3142             param_max = None 
    31433127            column_offset = 0 
    31443128            if self.has_error_column: 
    31453129                param_error = str(self._model_model.item(row, 2).text()) 
    31463130                column_offset = 1 
    3147  
    3148             try: 
    3149                 param_min = str(self._model_model.item(row, 2+column_offset).text()) 
    3150                 param_max = str(self._model_model.item(row, 3+column_offset).text()) 
    3151             except: 
    3152                 pass 
    3153  
     3131            param_min = str(self._model_model.item(row, 2+column_offset).text()) 
     3132            param_max = str(self._model_model.item(row, 3+column_offset).text()) 
    31543133            param_list.append([param_name, param_checked, param_value, param_error, param_min, param_max]) 
    31553134 
    … …  
    32413220 
    32423221                # limits 
    3243                 try: 
    3244                     limit_lo = item[3] 
    3245                     context[name].append(limit_lo) 
    3246                     limit_hi = item[4] 
    3247                     context[name].append(limit_hi) 
    3248                 except: 
    3249                     pass 
     3222                limit_lo = item[3] 
     3223                context[name].append(limit_lo) 
     3224                limit_hi = item[4] 
     3225                context[name].append(limit_hi) 
    32503226 
    32513227                # Polydisp 
    … …  
    33063282                ioffset = 1 
    33073283            # min/max 
    3308             try: 
    3309                 param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True) 
    3310                 self._model_model.item(row, 2+ioffset).setText(param_repr) 
    3311                 param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True) 
    3312                 self._model_model.item(row, 3+ioffset).setText(param_repr) 
    3313             except: 
    3314                 pass 
    3315  
     3284            param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True) 
     3285            self._model_model.item(row, 2+ioffset).setText(param_repr) 
     3286            param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True) 
     3287            self._model_model.item(row, 3+ioffset).setText(param_repr) 
    33163288            self.setFocus() 
    3317  
    33183289 
    33193290 

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

    rf712bf30 r3fbd77b  
    613613 
    614614        # Check that the number of rows increased 
    615         # (note that n == 1 by default in core_multi_shell so this increases index by 2) 
    616615        more_rows = self.widget._model_model.rowCount() - last_row 
    617         self.assertEqual(more_rows, 4) # 4 new rows: 2 params per index 
    618  
    619         # Set to 0 
     616        self.assertEqual(more_rows, 6) # 6 new rows: 2 params per index 
     617 
     618        # Back to 0 
    620619        self.widget.lstParams.indexWidget(func_index).setCurrentIndex(0) 
    621         self.assertEqual(self.widget._model_model.rowCount(), last_row - 2) # 2 fewer rows than default 
     620        self.assertEqual(self.widget._model_model.rowCount(), last_row) 
    622621 
    623622    def testPlotTheory(self): 

  • src/sas/qtgui/Perspectives/Inversion/InversionPerspective.py

    r4d959c8 r4d959c8  
    562562            title = self.prPlot.name 
    563563            GuiUtils.updateModelItemWithPlot(self._data, self.prPlot, title) 
    564             self.communicate.plotRequestedSignal.emit([self.prPlot], None) 
     564            self.communicate.plotRequestedSignal.emit([self.prPlot]) 
    565565        if self.dataPlot is not None: 
    566566            title = self.dataPlot.name 
    567567            GuiUtils.updateModelItemWithPlot(self._data, self.dataPlot, title) 
    568             self.communicate.plotRequestedSignal.emit([self.dataPlot], None) 
     568            self.communicate.plotRequestedSignal.emit([self.dataPlot]) 
    569569        self.enableButtons() 
    570570 

  • src/sas/qtgui/Plotting/Plotter.py

    r5b144c6 r0cd98a1  
    561561 
    562562        #Remove another Fit, if exists 
    563         self.removePlot("Fit") 
     563        self.removePlot("fit") 
    564564 
    565565        self.fit_result.reset_view() 

  • src/sas/qtgui/Plotting/UnitTesting/PlotterTest.py

    r5b144c6 rb8080e1  
    5757        self.plotter.data = self.data 
    5858        self.plotter.show() 
    59         FigureCanvas.draw = MagicMock() 
     59        FigureCanvas.draw_idle = MagicMock() 
    6060 
    6161        self.plotter.plot(hide_error=False) 
    6262 
    6363        self.assertEqual(self.plotter.ax.get_xscale(), 'log') 
    64         self.assertTrue(FigureCanvas.draw.called) 
     64        self.assertTrue(FigureCanvas.draw_idle.called) 
    6565 
    6666        self.plotter.figure.clf() 
    … …  
    7070        self.plotter.data = self.data 
    7171        self.plotter.show() 
    72         FigureCanvas.draw = MagicMock() 
     72        FigureCanvas.draw_idle = MagicMock() 
    7373 
    7474        self.plotter.plot(hide_error=True) 
    7575 
    7676        self.assertEqual(self.plotter.ax.get_yscale(), 'log') 
    77         self.assertTrue(FigureCanvas.draw.called) 
     77        self.assertTrue(FigureCanvas.draw_idle.called) 
    7878        self.plotter.figure.clf() 
    7979 
    … …  
    9191        self.plotter.data = data 
    9292        self.plotter.show() 
    93         FigureCanvas.draw = MagicMock() 
     93        FigureCanvas.draw_idle = MagicMock() 
    9494 
    9595        self.plotter.plot(hide_error=True) 
    … …  
    9797        self.assertEqual(self.plotter.ax.get_xscale(), 'linear') 
    9898        self.assertEqual(self.plotter.ax.get_yscale(), 'linear') 
    99         self.assertTrue(FigureCanvas.draw.called) 
     99        self.assertTrue(FigureCanvas.draw_idle.called) 
    100100 
    101101    def testCreateContextMenuQuick(self): 
    … …  
    262262        # Just this one plot 
    263263        self.assertEqual(len(list(self.plotter.plot_dict.keys())), 1) 
    264         self.plotter.onLinearFit('Test name') 
     264        self.plotter.onLinearFit(1) 
    265265 
    266266        # Check that exec_ got called 
    … …  
    289289 
    290290        # Delete one set 
    291         self.plotter.onRemovePlot('Test name 2') 
     291        self.plotter.onRemovePlot(2) 
    292292        # Assure we have two sets 
    293293        self.assertEqual(len(list(self.plotter.plot_dict.keys())), 1) 
    … …  
    296296 
    297297        # Delete the remaining set 
    298         self.plotter.onRemovePlot('Test name') 
     298        self.plotter.onRemovePlot(1) 
    299299        # Assure we have no plots 
    300300        self.assertEqual(len(list(self.plotter.plot_dict.keys())), 0) 
    … …  
    331331        self.assertEqual(yl, "$YAXIS(cake)$") 
    332332        # The hide_error flag should also remain 
    333         self.assertTrue(self.plotter.plot_dict['Test name 2'].hide_error) 
     333        self.assertTrue(self.plotter.plot_dict[2].hide_error) 
    334334        self.plotter.figure.clf() 
    335335 
    … …  
    355355 
    356356        # Reverse the toggle 
    357         self.plotter.onToggleHideError('Test name 2') 
     357        self.plotter.onToggleHideError(2) 
    358358        # See that the labels didn't change 
    359359        xl = self.plotter.ax.xaxis.label.get_text() 
    … …  
    362362        self.assertEqual(yl, "$YAXIS(cake)$") 
    363363        # The hide_error flag should toggle 
    364         self.assertEqual(self.plotter.plot_dict['Test name 2'].hide_error, not error_status) 
     364        self.assertEqual(self.plotter.plot_dict[2].hide_error, not error_status) 
    365365        self.plotter.figure.clf() 
    366366 
    … …  
    417417        self.assertEqual(yl, "$YAXIS(cake)$") 
    418418        # The hide_error flag should be as set 
    419         self.assertEqual(self.plotter.plot_dict['Test name 2'].hide_error, error_status) 
     419        self.assertEqual(self.plotter.plot_dict[2].hide_error, error_status) 
    420420        self.plotter.figure.clf() 
    421421 

  • src/sas/qtgui/Utilities/GuiUtils.py

    r5d28d6b r339e22b  
    225225    # New plot requested from the GUI manager 
    226226    # Old "NewPlotEvent" 
    227     plotRequestedSignal = QtCore.pyqtSignal(list, int) 
     227    plotRequestedSignal = QtCore.pyqtSignal(list) 
    228228 
    229229    # Plot from file names 
    … …  
    277277    # Notify about new categories/models from category manager 
    278278    updateModelCategoriesSignal = QtCore.pyqtSignal() 
    279  
    280     # Tell the data explorer to switch tabs 
    281     changeDataExplorerTabSignal = QtCore.pyqtSignal(int) 
    282279 
    283280def updateModelItemWithPlot(item, update_data, name=""): 
    … …  
    291288    for index in range(item.rowCount()): 
    292289        plot_item = item.child(index) 
    293         if not plot_item.isCheckable(): 
    294             continue 
    295         plot_data = plot_item.child(0).data() 
    296         if plot_data.id is not None and \ 
    297                 plot_data.name == update_data.name: 
    298                 #(plot_data.name == update_data.name or plot_data.id == update_data.id): 
     290        if plot_item.isCheckable(): 
     291            plot_data = plot_item.child(0).data() 
     292            if plot_data.id is not None and \ 
     293                   (plot_data.name == update_data.name or plot_data.id == update_data.id): 
    299294            # if plot_data.id is not None and plot_data.id == update_data.id: 
    300             # replace data section in item 
    301             plot_item.child(0).setData(update_data) 
    302             plot_item.setText(name) 
    303             # Plot title if any 
    304             if plot_item.child(1).hasChildren(): 
    305                 plot_item.child(1).child(0).setText("Title: %s"%name) 
    306             # Force redisplay 
    307             return 
     295                # replace data section in item 
     296                plot_item.child(0).setData(update_data) 
     297                plot_item.setText(name) 
     298                # Plot title if any 
     299                if plot_item.child(1).hasChildren(): 
     300                    plot_item.child(1).child(0).setText("Title: %s"%name) 
     301                # Force redisplay 
     302                return 
    308303 
    309304    # Create the new item 
Note: See TracChangeset for help on using the changeset viewer.