Changes in / [1bd266b:e908916] in sasview


Ignore:
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • .gitignore

    r7cc38a7 rce1f491  
    1616*.pyproj 
    1717*.sln 
    18 .*.swp 
    1918.DS_Store 
    2019/.settings 

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

    r0cd98a1 r60d55a7  
    4242        # Main model for keeping loaded data 
    4343        self.model = QtGui.QStandardItemModel(self) 
     44 
    4445        # Secondary model for keeping frozen data sets 
    4546        self.theory_model = QtGui.QStandardItemModel(self) 
    … …  
    9798        self.communicator.plotUpdateSignal.connect(self.updatePlot) 
    9899        self.communicator.maskEditorSignal.connect(self.showEditDataMask) 
    99         self.communicator.extMaskEditorSignal.connect(self.extShowEditDataMask) 
    100100 
    101101        self.cbgraph.editTextChanged.connect(self.enableGraphCombo) 
    … …  
    598598        plot2D.plot(plot_set) 
    599599        self.addPlot(plot2D) 
    600         self.active_plots[plot2D.data.name] = plot2D 
     600        self.active_plots[plot2D.data.id] = plot2D 
    601601        #============================================ 
    602602        # Experimental hook for silx charts 
    … …  
    626626                new_plot.plot(plot_set, transform=transform) 
    627627                # active_plots may contain multiple charts 
    628                 self.active_plots[plot_set.name] = new_plot 
     628                self.active_plots[plot_set.id] = new_plot 
    629629            elif isinstance(plot_set, Data2D): 
    630630                self.addDataPlot2D(plot_set, item) 
    … …  
    697697                old_plot.plot() 
    698698                # need this for lookup - otherwise this plot will never update 
    699                 self.active_plots[plot_set.name] = old_plot 
     699                self.active_plots[plot_set.id] = old_plot 
    700700 
    701701    def updatePlot(self, data): 
    … …  
    711711 
    712712        ids_keys = list(self.active_plots.keys()) 
    713         ids_vals = [val.data.name for val in self.active_plots.values()] 
    714  
    715         data_id = data.name 
     713        ids_vals = [val.data.id for val in self.active_plots.values()] 
     714 
     715        data_id = data.id 
    716716        if data_id in ids_keys: 
    717717            self.active_plots[data_id].replacePlot(data_id, data) 
    … …  
    952952        model = proxy.sourceModel() 
    953953 
    954         if not index.isValid(): 
    955             return 
    956         model_item = model.itemFromIndex(proxy.mapToSource(index)) 
    957         # Find the mapped index 
    958         orig_index = model_item.isCheckable() 
    959         if not orig_index: 
    960             return 
    961         # Check the data to enable/disable actions 
    962         is_2D = isinstance(GuiUtils.dataFromItem(model_item), Data2D) 
    963         self.actionQuick3DPlot.setEnabled(is_2D) 
    964         self.actionEditMask.setEnabled(is_2D) 
    965         # Fire up the menu 
    966         self.context_menu.exec_(self.current_view.mapToGlobal(position)) 
     954        if index.isValid(): 
     955            model_item = model.itemFromIndex(proxy.mapToSource(index)) 
     956            # Find the mapped index 
     957            orig_index = model_item.isCheckable() 
     958            if orig_index: 
     959                # Check the data to enable/disable actions 
     960                is_2D = isinstance(GuiUtils.dataFromItem(model_item), Data2D) 
     961                self.actionQuick3DPlot.setEnabled(is_2D) 
     962                self.actionEditMask.setEnabled(is_2D) 
     963                # Fire up the menu 
     964                self.context_menu.exec_(self.current_view.mapToGlobal(position)) 
    967965 
    968966    def showDataInfo(self): 
    … …  
    10611059        self.new_plot.show() 
    10621060 
    1063     def extShowEditDataMask(self): 
    1064         self.showEditDataMask() 
    1065  
    10661061    def showEditDataMask(self, data=None): 
    10671062        """ 
    10681063        Mask Editor for 2D plots 
    10691064        """ 
    1070         try: 
    1071             if data is None or not isinstance(data, Data2D): 
    1072                 index = self.current_view.selectedIndexes()[0] 
    1073                 proxy = self.current_view.model() 
    1074                 model = proxy.sourceModel() 
    1075                 model_item = model.itemFromIndex(proxy.mapToSource(index)) 
    1076  
    1077                 data = GuiUtils.dataFromItem(model_item) 
    1078  
    1079             if data is None or not isinstance(data, Data2D): 
    1080                 msg = QtWidgets.QMessageBox() 
    1081                 msg.setIcon(QtWidgets.QMessageBox.Information) 
    1082                 msg.setText("Error: cannot apply mask. \ 
    1083                                 Please select a 2D dataset.") 
    1084                 msg.setStandardButtons(QtWidgets.QMessageBox.Cancel) 
    1085                 msg.exec_() 
    1086                 return 
    1087         except: 
    1088             msg = QtWidgets.QMessageBox() 
    1089             msg.setIcon(QtWidgets.QMessageBox.Information) 
    1090             msg.setText("Error: No dataset selected. \ 
    1091                             Please select a 2D dataset.") 
    1092             msg.setStandardButtons(QtWidgets.QMessageBox.Cancel) 
    1093             msg.exec_() 
    1094             return 
     1065        if data is None or not isinstance(data, Data2D): 
     1066            index = self.current_view.selectedIndexes()[0] 
     1067            proxy = self.current_view.model() 
     1068            model = proxy.sourceModel() 
     1069            model_item = model.itemFromIndex(proxy.mapToSource(index)) 
     1070 
     1071            data = GuiUtils.dataFromItem(model_item) 
    10951072 
    10961073        mask_editor = MaskEditor(self, data) 

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

    r339e22b rf84d793  
    422422        self._workspace.actionExcel.triggered.connect(self.actionExcel) 
    423423        self._workspace.actionLatex.triggered.connect(self.actionLatex) 
     424 
    424425        # View 
    425426        self._workspace.actionShow_Grid_Window.triggered.connect(self.actionShow_Grid_Window) 
    … …  
    451452        self._workspace.actionManage_Custom_Models.triggered.connect(self.actionManage_Custom_Models) 
    452453        self._workspace.actionAddMult_Models.triggered.connect(self.actionAddMult_Models) 
    453         self._workspace.actionEditMask.triggered.connect(self.actionEditMask) 
    454  
    455454        # Window 
    456455        self._workspace.actionCascade.triggered.connect(self.actionCascade) 
    … …  
    782781        self.add_mult_editor.show() 
    783782 
    784     def actionEditMask(self): 
    785  
    786         self.communicate.extMaskEditorSignal.emit() 
    787  
    788783    #============ ANALYSIS ================= 
    789784    def actionFitting(self): 

  • src/sas/qtgui/MainWindow/UI/MainWindowUI.ui

    r2f14b5d rdda8f16  
    113113    <addaction name="actionManage_Custom_Models"/> 
    114114    <addaction name="actionAddMult_Models"/> 
    115     <addaction name="separator"/> 
    116     <addaction name="actionEditMask"/> 
    117115   </widget> 
    118116   <widget class="QMenu" name="menuWindow"> 
    … …  
    415413   </property> 
    416414  </action> 
    417     <action name="actionEditMask"> 
    418    <property name="text"> 
    419     <string>Edit Mask</string> 
    420    </property> 
    421   </action> 
    422415  <action name="actionCascade"> 
    423416   <property name="text"> 

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

    rdcabba7 rdcabba7  
    161161        Create a new 1D data instance based on fitting results 
    162162        """ 
     163 
    163164        return self._create1DPlot(tab_id, return_data['x'], return_data['y'], 
    164165                                  return_data['model'], return_data['data']) 
    … …  
    211212        (pq_plot, sq_plot). If either are unavailable, the corresponding plot is None. 
    212213        """ 
    213         plots = [] 
    214         for name, result in return_data['intermediate_results'].items(): 
    215             plots.append(self._create1DPlot(tab_id, return_data['x'], result, 
    216                          return_data['model'], return_data['data'], 
    217                          component=name)) 
    218         return plots 
     214 
     215        pq_plot = None 
     216        sq_plot = None 
     217 
     218        if return_data.get('pq_values', None) is not None: 
     219            pq_plot = self._create1DPlot(tab_id, return_data['x'], 
     220                    return_data['pq_values'], return_data['model'], 
     221                    return_data['data'], component="P(Q)") 
     222        if return_data.get('sq_values', None) is not None: 
     223            sq_plot = self._create1DPlot(tab_id, return_data['x'], 
     224                    return_data['sq_values'], return_data['model'], 
     225                    return_data['data'], component="S(Q)") 
     226 
     227        return pq_plot, sq_plot 
    219228 
    220229    def computeDataRange(self): 

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

    r70f4458 r70f4458  
    167167    return rows 
    168168 
    169 def addSimpleParametersToModel(parameters, is2D, parameters_original=None, model=None, view=None, row_num=None): 
     169def addSimpleParametersToModel(parameters, is2D, parameters_original=None, model=None, view=None): 
    170170    """ 
    171171    Update local ModelModel with sasmodel parameters (non-dispersed, non-magnetic) 
    … …  
    216216        # Append to the model and use the combobox, if required 
    217217        if None not in (model, view): 
    218             if row_num is None: 
    219                 model.appendRow(row) 
    220             else: 
    221                 model.insertRow(row_num, row) 
    222                 row_num += 1 
    223  
     218            model.appendRow(row) 
    224219            if cbox: 
    225220                view.setIndexWidget(item2.index(), cbox) 
    226  
    227221        rows.append(row) 
    228222 

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

    rd4ba565 r5fb714b  
    4848from sas.qtgui.Perspectives.Fitting.ReportPageLogic import ReportPageLogic 
    4949 
     50 
    5051TAB_MAGNETISM = 4 
    5152TAB_POLY = 3 
    … …  
    187188 
    188189        # Overwrite data type descriptor 
    189  
    190190        self.is2D = True if isinstance(self.logic.data, Data2D) else False 
    191191 
    … …  
    563563        When clicked on white space: model description 
    564564        """ 
    565         rows = [s.row() for s in self.lstParams.selectionModel().selectedRows() 
    566                 if self.isCheckable(s.row())] 
     565        rows = [s.row() for s in self.lstParams.selectionModel().selectedRows()] 
    567566        menu = self.showModelDescription() if not rows else self.modelContextMenu(rows) 
    568567        try: 
    … …  
    800799    def getConstraintForRow(self, row): 
    801800        """ 
    802         For the given row, return its constraint, if any (otherwise None) 
    803         """ 
    804         if not self.isCheckable(row): 
    805             return None 
    806         item = self._model_model.item(row, 1) 
    807         try: 
    808             return item.child(0).data() 
    809         except AttributeError: 
    810             return None 
     801        For the given row, return its constraint, if any 
     802        """ 
     803        if self.isCheckable(row): 
     804            item = self._model_model.item(row, 1) 
     805            try: 
     806                return item.child(0).data() 
     807            except AttributeError: 
     808                # return none when no constraints 
     809                pass 
     810        return None 
    811811 
    812812    def rowHasConstraint(self, row): 
    … …  
    814814        Finds out if row of the main model has a constraint child 
    815815        """ 
    816         if not self.isCheckable(row): 
    817             return False 
    818         item = self._model_model.item(row, 1) 
    819         if not item.hasChildren(): 
    820             return False 
    821         c = item.child(0).data() 
    822         if isinstance(c, Constraint): 
    823             return True 
     816        if self.isCheckable(row): 
     817            item = self._model_model.item(row, 1) 
     818            if item.hasChildren(): 
     819                c = item.child(0).data() 
     820                if isinstance(c, Constraint): 
     821                    return True 
    824822        return False 
    825823 
    … …  
    828826        Finds out if row of the main model has an active constraint child 
    829827        """ 
    830         if not self.isCheckable(row): 
    831             return False 
    832         item = self._model_model.item(row, 1) 
    833         if not item.hasChildren(): 
    834             return False 
    835         c = item.child(0).data() 
    836         if isinstance(c, Constraint) and c.active: 
    837             return True 
     828        if self.isCheckable(row): 
     829            item = self._model_model.item(row, 1) 
     830            if item.hasChildren(): 
     831                c = item.child(0).data() 
     832                if isinstance(c, Constraint) and c.active: 
     833                    return True 
    838834        return False 
    839835 
    … …  
    842838        Finds out if row of the main model has an active, nontrivial constraint child 
    843839        """ 
    844         if not self.isCheckable(row): 
    845             return False 
    846         item = self._model_model.item(row, 1) 
    847         if not item.hasChildren(): 
    848             return False 
    849         c = item.child(0).data() 
    850         if isinstance(c, Constraint) and c.func and c.active: 
    851             return True 
     840        if self.isCheckable(row): 
     841            item = self._model_model.item(row, 1) 
     842            if item.hasChildren(): 
     843                c = item.child(0).data() 
     844                if isinstance(c, Constraint) and c.func and c.active: 
     845                    return True 
    852846        return False 
    853847 
    … …  
    10591053            # Show constraint, if present 
    10601054            row = rows[0].row() 
    1061             if not self.rowHasConstraint(row): 
    1062                 return 
    1063             func = self.getConstraintForRow(row).func 
    1064             if func is not None: 
    1065                 self.communicate.statusBarUpdateSignal.emit("Active constrain: "+func) 
     1055            if self.rowHasConstraint(row): 
     1056                func = self.getConstraintForRow(row).func 
     1057                if func is not None: 
     1058                    self.communicate.statusBarUpdateSignal.emit("Active constrain: "+func) 
    10661059 
    10671060    def replaceConstraintName(self, old_name, new_name=""): 
    … …  
    18141807        # Force data recalculation so existing charts are updated 
    18151808        self.showPlot() 
    1816         # This is an important processEvent. 
    1817         # This allows charts to be properly updated in order 
    1818         # of plots being applied. 
    1819         QtWidgets.QApplication.processEvents() 
    18201809        self.recalculatePlotData() 
    18211810 
    … …  
    21022091            return 
    21032092 
    2104         product_params = None 
    2105  
    21062093        if self.kernel_module is None: 
    21072094            # Structure factor is the only selected model; build it and show all its params 
    … …  
    21092096            s_params = self.kernel_module._model_info.parameters 
    21102097            s_params_orig = s_params 
     2098 
    21112099        else: 
    21122100            s_kernel = self.models[structure_factor]() 
    … …  
    21252113            if "radius_effective_mode" in all_param_names: 
    21262114                # Show all parameters 
    2127                 # In this case, radius_effective is NOT pruned by sasmodels.product 
    21282115                s_params = modelinfo.ParameterTable(all_params[p_pars_len:p_pars_len+s_pars_len]) 
    21292116                s_params_orig = modelinfo.ParameterTable(s_kernel._model_info.parameters.kernel_parameters) 
    2130                 product_params = modelinfo.ParameterTable( 
    2131                         self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len:]) 
    21322117            else: 
    21332118                # Ensure radius_effective is not displayed 
    21342119                s_params_orig = modelinfo.ParameterTable(s_kernel._model_info.parameters.kernel_parameters[1:]) 
    21352120                if "radius_effective" in all_param_names: 
    2136                     # In this case, radius_effective is NOT pruned by sasmodels.product 
    21372121                    s_params = modelinfo.ParameterTable(all_params[p_pars_len+1:p_pars_len+s_pars_len]) 
    2138                     product_params = modelinfo.ParameterTable( 
    2139                             self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len:]) 
    21402122                else: 
    2141                     # In this case, radius_effective is pruned by sasmodels.product 
    21422123                    s_params = modelinfo.ParameterTable(all_params[p_pars_len:p_pars_len+s_pars_len-1]) 
    2143                     product_params = modelinfo.ParameterTable( 
    2144                             self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len-1:]) 
    21452124 
    21462125        # Add heading row 
    … …  
    21502129        # Any renamed parameters are stored as data in the relevant item, for later handling 
    21512130        FittingUtilities.addSimpleParametersToModel( 
    2152                 parameters=s_params, 
    2153                 is2D=self.is2D, 
    2154                 parameters_original=s_params_orig, 
    2155                 model=self._model_model, 
    2156                 view=self.lstParams) 
    2157  
    2158         # Insert product-only params into QModel 
    2159         if product_params: 
    2160             prod_rows = FittingUtilities.addSimpleParametersToModel( 
    2161                     parameters=product_params, 
    2162                     is2D=self.is2D, 
    2163                     parameters_original=None, 
    2164                     model=self._model_model, 
    2165                     view=self.lstParams, 
    2166                     row_num=2) 
    2167  
    2168             # Since this all happens after shells are dealt with and we've inserted rows, fix this counter 
    2169             self._n_shells_row += len(prod_rows) 
     2131                s_params, 
     2132                self.is2D, 
     2133                s_params_orig, 
     2134                self._model_model, 
     2135                self.lstParams) 
    21702136 
    21712137    def haveParamsToFit(self): 
    … …  
    24282394 
    24292395        # Create plots for intermediate product data 
    2430         plots = self.logic.new1DProductPlots(return_data, self.tab_id) 
    2431         for plot in plots: 
    2432             plot.symbol = "Line" 
    2433             self.createNewIndex(plot) 
    2434             new_plots.append(plot) 
     2396        pq_data, sq_data = self.logic.new1DProductPlots(return_data, self.tab_id) 
     2397        if pq_data is not None: 
     2398            pq_data.symbol = "Line" 
     2399            self.createNewIndex(pq_data) 
     2400            # self.communicate.plotUpdateSignal.emit([pq_data]) 
     2401            new_plots.append(pq_data) 
     2402        if sq_data is not None: 
     2403            sq_data.symbol = "Line" 
     2404            self.createNewIndex(sq_data) 
     2405            # self.communicate.plotUpdateSignal.emit([sq_data]) 
     2406            new_plots.append(sq_data) 
    24352407 
    24362408        for plot in new_plots: 
    … …  
    28332805        self._num_shell_params = len(new_rows) 
    28342806        self.current_shell_displayed = index 
    2835  
    2836         # Change 'n' in the parameter model, thereby updating the underlying model 
    2837         self._model_model.item(self._n_shells_row, 1).setText(str(index)) 
    28382807 
    28392808        # Update relevant models 
    … …  
    31803149            formatted_output = FittingUtilities.formatParameters(param_list) 
    31813150        elif format == "Excel": 
    3182             formatted_output = FittingUtilities.formatParametersExcel(param_list[1:]) 
     3151            formatted_output = FittingUtilities.formatParametersExcel(param_list) 
    31833152        elif format == "Latex": 
    3184             formatted_output = FittingUtilities.formatParametersLatex(param_list[1:]) 
     3153            formatted_output = FittingUtilities.formatParametersLatex(param_list) 
    31853154        else: 
    31863155            raise AttributeError("Bad format specifier.") 
    … …  
    33473316        self._poly_model.blockSignals(False) 
    33483317 
    3349  
    3350  

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

    r5181e9b rdcabba7  
    164164        index = (self.qmin <= self.data.x) & (self.data.x <= self.qmax) 
    165165 
    166         intermediate_results = None 
    167  
    168166        # If we use a smearer, also return the unsmeared model 
    169167        unsmeared_output = None 
    … …  
    176174            mask = self.data.x[first_bin:last_bin+1] 
    177175            unsmeared_output = numpy.zeros((len(self.data.x))) 
    178  
    179             return_data = self.model.calculate_Iq(mask) 
    180             if isinstance(return_data, tuple): 
    181                 # see sasmodels beta_approx: SasviewModel.calculate_Iq 
    182                 # TODO: implement intermediate results in smearers 
    183                 return_data, _ = return_data 
    184             unsmeared_output[first_bin:last_bin+1] = return_data 
     176            unsmeared_output[first_bin:last_bin+1] = self.model.evalDistribution(mask) 
    185177            output = self.smearer(unsmeared_output, first_bin, last_bin) 
    186178 
    … …  
    201193                unsmeared_error=unsmeared_error 
    202194        else: 
    203             return_data = self.model.calculate_Iq(self.data.x[index]) 
    204             if isinstance(return_data, tuple): 
    205                 # see sasmodels beta_approx: SasviewModel.calculate_Iq 
    206                 return_data, intermediate_results = return_data 
    207             output[index] = return_data 
    208  
    209         if intermediate_results: 
    210             # the model returns a callable which is then used to retrieve the data 
    211             intermediate_results = intermediate_results() 
    212         else: 
    213             # TODO: this conditional branch needs refactoring 
    214             sq_values = None 
    215             pq_values = None 
    216             s_model = None 
    217             p_model = None 
    218  
    219             if isinstance(self.model, MultiplicationModel): 
    220                 s_model = self.model.s_model 
    221                 p_model = self.model.p_model 
    222  
    223             elif hasattr(self.model, "calc_composition_models"): 
    224                 results = self.model.calc_composition_models(self.data.x[index]) 
    225                 if results is not None: 
    226                     pq_values, sq_values = results 
    227  
    228             if pq_values is None or sq_values is None: 
    229                 if p_model is not None and s_model is not None: 
    230                     sq_values = numpy.zeros((len(self.data.x))) 
    231                     pq_values = numpy.zeros((len(self.data.x))) 
    232                     sq_values[index] = s_model.evalDistribution(self.data.x[index]) 
    233                     pq_values[index] = p_model.evalDistribution(self.data.x[index]) 
    234  
    235             if pq_values is not None and sq_values is not None: 
    236                 intermediate_results  = { 
    237                     "P(Q)": pq_values, 
    238                     "S(Q)": sq_values 
    239                 } 
    240             else: 
    241                 intermediate_results = {} 
     195            output[index] = self.model.evalDistribution(self.data.x[index]) 
     196 
     197        sq_values = None 
     198        pq_values = None 
     199        s_model = None 
     200        p_model = None 
     201        if isinstance(self.model, MultiplicationModel): 
     202            s_model = self.model.s_model 
     203            p_model = self.model.p_model 
     204        elif hasattr(self.model, "calc_composition_models"): 
     205            results = self.model.calc_composition_models(self.data.x[index]) 
     206            if results is not None: 
     207                pq_values, sq_values = results 
     208 
     209        if pq_values is None or sq_values is None: 
     210            if p_model is not None and s_model is not None: 
     211                sq_values = numpy.zeros((len(self.data.x))) 
     212                pq_values = numpy.zeros((len(self.data.x))) 
     213                sq_values[index] = s_model.evalDistribution(self.data.x[index]) 
     214                pq_values[index] = p_model.evalDistribution(self.data.x[index]) 
    242215 
    243216        elapsed = time.time() - self.starttime 
    … …  
    250223            source = self.source, unsmeared_output = unsmeared_output, 
    251224            unsmeared_data = unsmeared_data, unsmeared_error = unsmeared_error, 
    252             intermediate_results = intermediate_results) 
     225            pq_values = pq_values, sq_values = sq_values) 
    253226 
    254227        if LocalConfig.USING_TWISTED: 

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

    r309fa1b r79bd268  
    3232        <item row="0" column="1"> 
    3333         <widget class="QLineEdit" name="txtMinRange"> 
    34           <property name="minimumSize"> 
    35            <size> 
    36             <width>80</width> 
    37             <height>0</height> 
    38            </size> 
    39           </property> 
    4034          <property name="toolTip"> 
    4135           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Minimum value of Q.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string> 
    … …  
    6054        <item row="1" column="1"> 
    6155         <widget class="QLineEdit" name="txtMaxRange"> 
    62           <property name="minimumSize"> 
    63            <size> 
    64             <width>80</width> 
    65             <height>0</height> 
    66            </size> 
    67           </property> 
    6856          <property name="toolTip"> 
    6957           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Maximum value of Q.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string> 

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

    rbfb5d9e re752ab8  
    9999        data.name = "boop" 
    100100        data.id = "poop" 
    101         # Condensed return data (new1DPlot only uses these fields) 
    102         return_data = dict(x = data.x, 
    103                            y = data.y, 
    104                            model = data, 
    105                            data = data) 
    106         # return_data = (data.x,data.y, 7, None, None, 
    107         #                0, True, 0.0, 1, data, 
    108         #                data, False, None, 
    109         #                None, None, None, 
    110         #                None, None) 
     101        return_data = (data.x,data.y, 7, None, None, 
     102                       0, True, 0.0, 1, data, 
     103                       data, False, None, 
     104                       None, None, None, 
     105                       None, None) 
    111106 
    112107        new_plot = self.logic.new1DPlot(return_data=return_data, tab_id=0) 
    … …  
    144139        qmin, qmax, npts = self.logic.computeDataRange() 
    145140 
    146         # Condensed return data (new2DPlot only uses these fields) 
    147         return_data = dict(image = x_0, 
    148                            data = data, 
    149                            page_id = 7, 
    150                            model = data) 
    151         # return_data = (x_0, data, 7, data, None, 
    152         #                 True, 0.0, 1, 0, qmin, qmax, 
    153         #                 0.1, False, None) 
     141        return_data = (x_0, data, 7, data, None, 
     142                        True, 0.0, 1, 0, qmin, qmax, 
     143                        0.1, False, None) 
    154144 
    155145        new_plot = self.logic.new2DPlot(return_data=return_data) 

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

    rbfb5d9e r725d9c06  
    3838        # The combo box 
    3939        self.assertIsInstance(self.widget.cbAlgorithm, QtWidgets.QComboBox) 
    40         self.assertEqual(self.widget.cbAlgorithm.count(), 6) 
     40        self.assertEqual(self.widget.cbAlgorithm.count(), 5) 
    4141        self.assertEqual(self.widget.cbAlgorithm.itemText(0), 'Nelder-Mead Simplex') 
    4242        self.assertEqual(self.widget.cbAlgorithm.itemText(4), 'Levenberg-Marquardt') 

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

    r0cd98a1 rc2f3ca2  
    182182 
    183183        # Update the list of data sets (plots) in chart 
    184         self.plot_dict[self._data.name] = self.data 
    185  
    186         self.plot_lines[self._data.name] = line 
     184        self.plot_dict[self._data.id] = self.data 
     185 
     186        self.plot_lines[self._data.id] = line 
    187187 
    188188        # Now add the legend with some customizations. 
    … …  
    201201        # refresh canvas 
    202202        self.canvas.draw() 
     203        # This is an important processEvent. 
     204        # This allows charts to be properly updated in order 
     205        # of plots being applied. 
     206        QtWidgets.QApplication.processEvents() 
    203207 
    204208    def createContextMenu(self): 
    … …  
    416420        This effectlvely refreshes the chart with changes to one of its plots 
    417421        """ 
     422        import logging 
    418423        self.removePlot(id) 
    419424        self.plot(data=new_plot) 

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

    r339e22b r0eff615  
    265265    # Mask Editor requested 
    266266    maskEditorSignal = QtCore.pyqtSignal(Data2D) 
    267  
    268     #second Mask Editor for external 
    269     extMaskEditorSignal = QtCore.pyqtSignal() 
    270267 
    271268    # Fitting parameter copy to clipboard 
Note: See TracChangeset for help on using the changeset viewer.