Changes in / [8289ae3:304e42f] in sasview


Ignore:
Files:
17 deleted
15 edited

Legend:

Unmodified
Added
Removed

  • setup.py

    • Property mode changed from 100755 to 100644
    r3b3b40b r14ec91c5  
    351351    "src", "sas", "qtgui", "Utilities") 
    352352packages.append("sas.qtgui.Utilities") 
    353 package_dir["sas.qtgui.UtilitiesUI"] = os.path.join( 
    354     "src", "sas", "qtgui", "Utilities","UI") 
    355 packages.append("sas.qtgui.Utilities.UI") 
    356353 
    357354package_dir["sas.qtgui.Calculators"] = os.path.join( 

  • src/sas/qtgui/GUITests.py

    r3b3b40b rda9a0722  
    4444from Utilities.UnitTesting import GuiUtilsTest 
    4545from Utilities.UnitTesting import SasviewLoggerTest 
    46 from Utilities.UnitTesting import GridPanelTest 
    47 from Utilities.UnitTesting import ModelEditorTest 
    48 from Utilities.UnitTesting import PluginDefinitionTest 
    49 from Utilities.UnitTesting import TabbedModelEditorTest 
    5046 
    5147# Unit Testing 
    … …  
    10399        unittest.makeSuite(GuiUtilsTest.DoubleValidatorTest,      'test'), 
    104100        unittest.makeSuite(GuiUtilsTest.HashableStandardItemTest, 'test'), 
    105         unittest.makeSuite(GridPanelTest.BatchOutputPanelTest,    'test'), 
    106         unittest.makeSuite(ModelEditorTest.ModelEditorTest,            'test'), 
    107         unittest.makeSuite(PluginDefinitionTest.PluginDefinitionTest,  'test'), 
    108         unittest.makeSuite(TabbedModelEditorTest.TabbedModelEditorTest,'test'), 
    109101 
    110102        # Calculators 

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

    r8ac3551 re90988c  
    473473        Notify the gui manager about the new perspective chosen. 
    474474        """ 
    475         self.communicator.perspectiveChangedSignal.emit(self.cbFitting.itemText(index)) 
     475        self.communicator.perspectiveChangedSignal.emit(self.cbFitting.currentText()) 
    476476        self.chkBatch.setEnabled(self.parent.perspective().allowBatch()) 
    477477 
    478     def displayFile(self, filename=None, is_data=True): 
     478    def displayData(self, data_list): 
    479479        """ 
    480480        Forces display of charts for the given filename 
    481481        """ 
    482         model = self.model if is_data else self.theory_model 
     482        plot_to_show = data_list[0] 
     483 
     484        # passed plot is used ONLY to figure out its title, 
     485        # so all the charts related by it can be pulled from  
     486        # the data explorer indices. 
     487        filename = plot_to_show.filename 
     488        model = self.model if plot_to_show.is_data else self.theory_model 
     489 
    483490        # Now query the model item for available plots 
    484491        plots = GuiUtils.plotsFromFilename(filename, model) 
    … …  
    499506        if new_plots: 
    500507            self.plotData(new_plots) 
    501  
    502     def displayData(self, data_list): 
    503         """ 
    504         Forces display of charts for the given data set 
    505         """ 
    506         plot_to_show = data_list[0] 
    507         # passed plot is used ONLY to figure out its title, 
    508         # so all the charts related by it can be pulled from  
    509         # the data explorer indices. 
    510         filename = plot_to_show.filename 
    511         self.displayFile(filename=filename, is_data=plot_to_show.is_data) 
    512508 
    513509    def addDataPlot2D(self, plot_set, item): 
    … …  
    10311027        pass 
    10321028 
    1033     def onAnalysisUpdate(self, new_perspective=""): 
    1034         """ 
    1035         Update the perspective combo index based on passed string 
    1036         """ 
    1037         assert new_perspective in Perspectives.PERSPECTIVES.keys() 
    1038         self.cbFitting.blockSignals(True) 
    1039         self.cbFitting.setCurrentIndex(self.cbFitting.findText(new_perspective)) 
    1040         self.cbFitting.blockSignals(False) 
    1041         pass 
    1042  
    10431029    def loadComplete(self, output): 
    10441030        """ 

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

    r8ac3551 r14ec91c5  
    1919 
    2020import sas.qtgui.Utilities.ObjectLibrary as ObjectLibrary 
    21 from sas.qtgui.Utilities.TabbedModelEditor import TabbedModelEditor 
    22 from sas.qtgui.Utilities.PluginManager import PluginManager 
    2321from sas.qtgui.MainWindow.UI.AcknowledgementsUI import Ui_Acknowledgements 
    2422from sas.qtgui.MainWindow.AboutBox import AboutBox 
    … …  
    4947    Main SasView window functionality 
    5048    """ 
     49 
    5150    def __init__(self, parent=None): 
    5251        """ 
    … …  
    183182        Respond to change of the perspective signal 
    184183        """ 
     184 
     185        # Save users from themselves... 
     186        #if isinstance(self._current_perspective, Perspectives.PERSPECTIVES[str(perspective_name)]): 
     187        self.setupPerspectiveMenubarOptions(self._current_perspective) 
     188        #    return 
     189 
    185190        # Close the previous perspective 
    186191        self.clearPerspectiveMenubarOptions(self._current_perspective) 
    … …  
    192197        # Default perspective 
    193198        self._current_perspective = Perspectives.PERSPECTIVES[str(perspective_name)](parent=self) 
    194  
    195         self.setupPerspectiveMenubarOptions(self._current_perspective) 
    196199 
    197200        subwindow = self._workspace.workspace.addSubWindow(self._current_perspective) 
    … …  
    355358        self.communicate.updateTheoryFromPerspectiveSignal.connect(self.updateTheoryFromPerspective) 
    356359        self.communicate.plotRequestedSignal.connect(self.showPlot) 
    357         self.communicate.plotFromFilenameSignal.connect(self.showPlotFromFilename) 
    358360        self.communicate.updateModelFromDataOperationPanelSignal.connect(self.updateModelFromDataOperationPanel) 
    359361 
    … …  
    404406        self._workspace.actionFit_Results.triggered.connect(self.actionFit_Results) 
    405407        self._workspace.actionChain_Fitting.triggered.connect(self.actionChain_Fitting) 
    406         self._workspace.actionAdd_Custom_Model.triggered.connect(self.actionAdd_Custom_Model) 
    407408        self._workspace.actionEdit_Custom_Model.triggered.connect(self.actionEdit_Custom_Model) 
    408         self._workspace.actionManage_Custom_Models.triggered.connect(self.actionManage_Custom_Models) 
    409409        # Window 
    410410        self._workspace.actionCascade.triggered.connect(self.actionCascade) 
    … …  
    417417        self._workspace.actionInversion.triggered.connect(self.actionInversion) 
    418418        self._workspace.actionInvariant.triggered.connect(self.actionInvariant) 
    419         self._workspace.actionCorfunc.triggered.connect(self.actionCorfunc) 
    420419        # Help 
    421420        self._workspace.actionDocumentation.triggered.connect(self.actionDocumentation) 
    … …  
    663662        pass 
    664663 
    665     def actionAdd_Custom_Model(self): 
    666         """ 
    667         """ 
    668         self.model_editor = TabbedModelEditor(self) 
    669         self.model_editor.show() 
    670  
    671664    def actionEdit_Custom_Model(self): 
    672665        """ 
    673666        """ 
    674         self.model_editor = TabbedModelEditor(self, edit_only=True) 
    675         self.model_editor.show() 
    676  
    677     def actionManage_Custom_Models(self): 
    678         """ 
    679         """ 
    680         self.model_manager = PluginManager(self) 
    681         self.model_manager.show() 
     667        print("actionEdit_Custom_Model TRIGGERED") 
     668        pass 
    682669 
    683670    #============ ANALYSIS ================= 
    … …  
    687674        """ 
    688675        self.perspectiveChanged("Fitting") 
    689         # Notify other widgets 
    690         self.filesWidget.onAnalysisUpdate("Fitting") 
    691676 
    692677    def actionInversion(self): 
    … …  
    694679        Change to the Inversion perspective 
    695680        """ 
     681        # For now we'll just update the analysis menu status but when the inversion is implemented delete from here 
     682        self.checkAnalysisOption(self._workspace.actionInversion) 
     683        # to here and uncomment the following line 
    696684        self.perspectiveChanged("Inversion") 
    697         self.filesWidget.onAnalysisUpdate("Inversion") 
    698685 
    699686    def actionInvariant(self): 
    … …  
    702689        """ 
    703690        self.perspectiveChanged("Invariant") 
    704         self.filesWidget.onAnalysisUpdate("Invariant") 
    705  
    706     def actionCorfunc(self): 
    707         """ 
    708         Change to the Corfunc perspective 
    709         """ 
    710         self.perspectiveChanged("Corfunc") 
    711         self.filesWidget.onAnalysisUpdate("Corfunc") 
    712691 
    713692    #============ WINDOW ================= 
    … …  
    800779        self.filesWidget.model.appendRow(new_item) 
    801780        self._data_manager.add_data(new_datalist_item) 
    802  
    803     def showPlotFromFilename(self, filename): 
    804         """ 
    805         Pass the show plot request to the data explorer 
    806         """ 
    807         if hasattr(self, "filesWidget"): 
    808             self.filesWidget.displayFile(filename=filename, is_data=True) 
    809781 
    810782    def showPlot(self, plot): 
    … …  
    856828        elif isinstance(perspective, Perspectives.PERSPECTIVES["Invariant"]): 
    857829            self.checkAnalysisOption(self._workspace.actionInvariant) 
    858         elif isinstance(perspective, Perspectives.PERSPECTIVES["Inversion"]): 
    859             self.checkAnalysisOption(self._workspace.actionInversion) 
    860         elif isinstance(perspective, Perspectives.PERSPECTIVES["Corfunc"]): 
    861             self.checkAnalysisOption(self._workspace.actionCorfunc) 
     830        # elif isinstance(perspective, Perspectives.PERSPECTIVES["Inversion"]): 
     831        #     self.checkAnalysisOption(self._workspace.actionInversion) 

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

    r8ac3551 r8353d90  
    3030        except Exception as ex: 
    3131            import logging 
    32             logging.error("Application failed with: " + str(ex)) 
     32            logging.error("Application failed with: ", ex) 
    3333            print("Application failed with: ", ex) 
    3434 

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

    r8ac3551 r1543f0c  
    88    <y>0</y> 
    99    <width>915</width> 
    10     <height>762</height> 
     10    <height>527</height> 
    1111   </rect> 
    1212  </property> 
    … …  
    2525     <y>0</y> 
    2626     <width>915</width> 
    27      <height>26</height> 
     27     <height>21</height> 
    2828    </rect> 
    2929   </property> 
    … …  
    108108    <addaction name="actionChain_Fitting"/> 
    109109    <addaction name="separator"/> 
    110     <addaction name="actionAdd_Custom_Model"/> 
    111110    <addaction name="actionEdit_Custom_Model"/> 
    112     <addaction name="actionManage_Custom_Models"/> 
    113111   </widget> 
    114112   <widget class="QMenu" name="menuWindow"> 
    … …  
    128126     <string>Analysis</string> 
    129127    </property> 
    130     <addaction name="actionCorfunc"/> 
    131128    <addaction name="actionFitting"/> 
     129    <addaction name="actionInversion"/> 
    132130    <addaction name="actionInvariant"/> 
    133     <addaction name="actionInversion"/> 
    134131   </widget> 
    135132   <widget class="QMenu" name="menuHelp"> 
    … …  
    508505   </property> 
    509506  </action> 
    510   <action name="actionAdd_Custom_Model"> 
    511    <property name="text"> 
    512     <string>Add Custom Model</string> 
    513    </property> 
    514   </action> 
    515   <action name="actionManage_Custom_Models"> 
    516    <property name="text"> 
    517     <string>Manage Custom Models</string> 
    518    </property> 
    519   </action> 
    520   <action name="actionCorfunc"> 
    521    <property name="checkable"> 
    522     <bool>true</bool> 
    523    </property> 
    524    <property name="text"> 
    525     <string>Correlation Function</string> 
    526    </property> 
    527   </action> 
    528507 </widget> 
    529508 <resources/> 

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

    r8b480d27 re4c475b7  
    111111 
    112112        # Disconnect all local slots 
    113         #tab_object.disconnect() 
     113        tab_object.disconnect() 
    114114 
    115115        # Reconnect tab signals to local slots 
    … …  
    171171                    # No such tab! 
    172172                    return 
    173                 sim_fitter_list, fitter_id = \ 
    174                     tab_object.prepareFitters(fitter=sim_fitter_list[0], fit_id=fitter_id) 
     173                sim_fitter_list, fitter_id = tab_object.prepareFitters(fitter=sim_fitter_list[0], fit_id=fitter_id) 
    175174                page_ids.append([tab_object.page_id]) 
    176175        except ValueError: 
    … …  
    179178                            "Not all tabs chosen for fitting have parameters selected for fitting." 
    180179            QtWidgets.QMessageBox.warning(self, 
    181                                           'Warning', 
    182                                            no_params_msg, 
    183                                            QtWidgets.QMessageBox.Ok) 
     180                                           'Warning', 
     181                                            no_params_msg, 
     182                                            QtWidgets.QMessageBox.Ok) 
    184183 
    185184            return 
    … …  
    675674 
    676675        constraint.func = constraint_text 
    677         # param1 is the parameter we're constraining 
    678676        constraint.param = param1 
    679  
    680677        # Find the right tab 
    681678        constrained_tab = self.getObjectByName(model1) 

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

    r3b3b40b r14ec91c5  
    88from bumps import fitters 
    99 
    10 import sas.qtgui.Utilities.LocalConfig as LocalConfig 
    1110import sas.qtgui.Utilities.ObjectLibrary as ObjectLibrary 
    1211 
    … …  
    117116        tab     = FittingWidget(parent=self.parent, data=data, tab_id=self.maxIndex+1) 
    118117        tab.is_batch_fitting = is_batch 
    119  
    120118        # Add this tab to the object library so it can be retrieved by scripting/jupyter 
    121119        tab_name = self.getTabName(is_batch=is_batch) 
    … …  
    125123            self.updateFitDict(data, tab_name) 
    126124        self.maxIndex += 1 
    127         icon = QtGui.QIcon() 
    128         if is_batch: 
    129             icon.addPixmap(QtGui.QPixmap("src/sas/qtgui/images/icons/layers.svg")) 
    130         self.addTab(tab, icon, tab_name) 
    131         # Show the new tab 
    132         self.setCurrentIndex(self.maxIndex-1) 
    133         # Notify listeners 
     125        self.addTab(tab, tab_name) 
    134126        self.tabsModifiedSignal.emit() 
    135127 
    … …  
    148140        ObjectLibrary.addObject(tab_name, tab) 
    149141        self.tabs.append(tab) 
    150         icon = QtGui.QIcon() 
    151         icon.addPixmap(QtGui.QPixmap("src/sas/qtgui/images/icons/link.svg")) 
    152         self.addTab(tab, icon, tab_name) 
    153  
    154         # This will be the last tab, so set the index accordingly 
    155         self.setCurrentIndex(self.count()-1) 
     142        self.addTab(tab, tab_name) 
    156143 
    157144    def updateFitDict(self, item_key, tab_name): 

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

    r8b480d27 re4c475b7  
    2424import sas.qtgui.Utilities.GuiUtils as GuiUtils 
    2525import sas.qtgui.Utilities.LocalConfig as LocalConfig 
    26 from sas.qtgui.Utilities.GridPanel import BatchOutputPanel 
    2726from sas.qtgui.Utilities.CategoryInstaller import CategoryInstaller 
    2827from sas.qtgui.Plotting.PlotterData import Data1D 
    … …  
    3736from sas.qtgui.Perspectives.Fitting.FittingLogic import FittingLogic 
    3837from sas.qtgui.Perspectives.Fitting import FittingUtilities 
    39 from sas.qtgui.Perspectives.Fitting import ModelUtilities 
    4038from sas.qtgui.Perspectives.Fitting.SmearingWidget import SmearingWidget 
    4139from sas.qtgui.Perspectives.Fitting.OptionsWidget import OptionsWidget 
    … …  
    5250CATEGORY_DEFAULT = "Choose category..." 
    5351CATEGORY_STRUCTURE = "Structure Factor" 
    54 CATEGORY_CUSTOM = "Plugin Models" 
    5552STRUCTURE_DEFAULT = "None" 
    5653 
    … …  
    8683    constraintAddedSignal = QtCore.pyqtSignal(list) 
    8784    newModelSignal = QtCore.pyqtSignal() 
    88     fittingFinishedSignal = QtCore.pyqtSignal(tuple) 
    89     batchFittingFinishedSignal = QtCore.pyqtSignal(tuple) 
    90  
    9185    def __init__(self, parent=None, data=None, tab_id=1): 
    9286 
    … …  
    217211        self.page_stack = [] 
    218212        self.all_data = [] 
    219         # custom plugin models 
    220         # {model.name:model} 
    221         self.custom_models = self.customModels() 
    222213        # Polydisp widget table default index for function combobox 
    223214        self.orig_poly_index = 3 
    … …  
    424415            self.onSelectModel() 
    425416 
    426     @classmethod 
    427     def customModels(cls): 
    428         """ Reads in file names in the custom plugin directory """ 
    429         return ModelUtilities._find_models() 
    430  
    431417    def initializeControls(self): 
    432418        """ 
    … …  
    479465        self._poly_model.itemChanged.connect(self.onPolyModelChange) 
    480466        self._magnet_model.itemChanged.connect(self.onMagnetModelChange) 
    481         self.lstParams.selectionModel().selectionChanged.connect(self.onSelectionChanged) 
    482  
    483         # Local signals 
    484         self.batchFittingFinishedSignal.connect(self.batchFitComplete) 
    485         self.fittingFinishedSignal.connect(self.fitComplete) 
    486467 
    487468        # Signals from separate tabs asking for replot 
    488469        self.options_widget.plot_signal.connect(self.onOptionsUpdate) 
    489  
    490         # Signals from other widgets 
    491         self.communicate.customModelDirectoryChanged.connect(self.onCustomModelChange) 
    492470 
    493471    def modelName(self): 
    … …  
    598576        # widget.params[0] is the parameter we're constraining 
    599577        constraint.param = mc_widget.params[0] 
    600         # parameter should have the model name preamble 
     578        # Function should have the model name preamble 
    601579        model_name = self.kernel_module.name 
    602         # param_used is the parameter we're using in constraining function 
    603         param_used = mc_widget.params[1] 
    604         # Replace param_used with model_name.param_used 
    605         updated_param_used = model_name + "." + param_used 
    606         new_func = c_text.replace(param_used, updated_param_used) 
    607         constraint.func = new_func 
     580        constraint.func = model_name + "." + c_text 
    608581        # Which row is the constrained parameter in? 
    609582        row = self.getRowFromName(constraint.param) 
    … …  
    704677        Delete constraints from selected parameters. 
    705678        """ 
    706         params =  [s.data() for s in self.lstParams.selectionModel().selectedRows() 
    707                    if self.isCheckable(s.row())] 
    708         for param in params: 
    709             self.deleteConstraintOnParameter(param=param) 
     679        self.deleteConstraintOnParameter(param=None) 
    710680 
    711681    def deleteConstraintOnParameter(self, param=None): 
    … …  
    716686        max_col = self.lstParams.itemDelegate().param_max 
    717687        for row in range(self._model_model.rowCount()): 
    718             if not self.rowHasConstraint(row): 
    719                 continue 
    720688            # Get the Constraint object from of the model item 
    721689            item = self._model_model.item(row, 1) 
    722             constraint = self.getConstraintForRow(row) 
     690            if not item.hasChildren(): 
     691                continue 
     692            constraint = item.child(0).data() 
    723693            if constraint is None: 
    724694                continue 
    … …  
    846816        return constraints 
    847817 
    848     def getConstraintsForFitting(self): 
    849         """ 
    850         Return a list of constraints in format ready for use in fiting 
    851         """ 
    852         # Get constraints 
    853         constraints = self.getComplexConstraintsForModel() 
    854         # See if there are any constraints across models 
    855         multi_constraints = [cons for cons in constraints if self.isConstraintMultimodel(cons[1])] 
    856  
    857         if multi_constraints: 
    858             # Let users choose what to do 
    859             msg = "The current fit contains constraints relying on other fit pages.\n" 
    860             msg += "Parameters with those constraints are:\n" +\ 
    861                 '\n'.join([cons[0] for cons in multi_constraints]) 
    862             msg += "\n\nWould you like to remove these constraints or cancel fitting?" 
    863             msgbox = QtWidgets.QMessageBox(self) 
    864             msgbox.setIcon(QtWidgets.QMessageBox.Warning) 
    865             msgbox.setText(msg) 
    866             msgbox.setWindowTitle("Existing Constraints") 
    867             # custom buttons 
    868             button_remove = QtWidgets.QPushButton("Remove") 
    869             msgbox.addButton(button_remove, QtWidgets.QMessageBox.YesRole) 
    870             button_cancel = QtWidgets.QPushButton("Cancel") 
    871             msgbox.addButton(button_cancel, QtWidgets.QMessageBox.RejectRole) 
    872             retval = msgbox.exec_() 
    873             if retval == QtWidgets.QMessageBox.RejectRole: 
    874                 # cancel fit 
    875                 raise ValueError("Fitting cancelled") 
    876             else: 
    877                 # remove constraint 
    878                 for cons in multi_constraints: 
    879                     self.deleteConstraintOnParameter(param=cons[0]) 
    880                 # re-read the constraints 
    881                 constraints = self.getComplexConstraintsForModel() 
    882  
    883         return constraints 
    884  
    885818    def showModelDescription(self): 
    886819        """ 
    … …  
    941874        self.respondToModelStructure(model=model, structure_factor=structure) 
    942875 
    943     def onCustomModelChange(self): 
    944         """ 
    945         Reload the custom model combobox 
    946         """ 
    947         self.custom_models = self.customModels() 
    948         self.readCustomCategoryInfo() 
    949         # See if we need to update the combo in-place 
    950         if self.cbCategory.currentText() != CATEGORY_CUSTOM: return 
    951  
    952         current_text = self.cbModel.currentText() 
    953         self.cbModel.blockSignals(True) 
    954         self.cbModel.clear() 
    955         self.cbModel.blockSignals(False) 
    956         self.enableModelCombo() 
    957         self.disableStructureCombo() 
    958         # Retrieve the list of models 
    959         model_list = self.master_category_dict[CATEGORY_CUSTOM] 
    960         # Populate the models combobox 
    961         self.cbModel.addItems(sorted([model for (model, _) in model_list])) 
    962         new_index = self.cbModel.findText(current_text) 
    963         if new_index != -1: 
    964             self.cbModel.setCurrentIndex(self.cbModel.findText(current_text)) 
    965  
    966     def onSelectionChanged(self): 
    967         """ 
    968         React to parameter selection 
    969         """ 
    970         rows = self.lstParams.selectionModel().selectedRows() 
    971         # Clean previous messages 
    972         self.communicate.statusBarUpdateSignal.emit("") 
    973         if len(rows) == 1: 
    974             # Show constraint, if present 
    975             row = rows[0].row() 
    976             if self.rowHasConstraint(row): 
    977                 func = self.getConstraintForRow(row).func 
    978                 if func is not None: 
    979                     self.communicate.statusBarUpdateSignal.emit("Active constrain: "+func) 
    980  
    981876    def replaceConstraintName(self, old_name, new_name=""): 
    982877        """ 
    … …  
    991886                    new_func = func.replace(old_name, new_name) 
    992887                    self._model_model.item(row, 1).child(0).data().func = new_func 
    993  
    994     def isConstraintMultimodel(self, constraint): 
    995         """ 
    996         Check if the constraint function text contains current model name 
    997         """ 
    998         current_model_name = self.kernel_module.name 
    999         if current_model_name in constraint: 
    1000             return False 
    1001         else: 
    1002             return True 
    1003888 
    1004889    def updateData(self): 
    … …  
    12201105        except ValueError as ex: 
    12211106            # This should not happen! GUI explicitly forbids this situation 
    1222             self.communicate.statusBarUpdateSignal.emit(str(ex)) 
     1107            self.communicate.statusBarUpdateSignal.emit('Fitting attempt without parameters.') 
    12231108            return 
    12241109 
    12251110        # Create the fitting thread, based on the fitter 
    1226         completefn = self.batchFittingCompleted if self.is_batch_fitting else self.fittingCompleted 
     1111        completefn = self.batchFitComplete if self.is_batch_fitting else self.fitComplete 
    12271112 
    12281113        calc_fit = FitThread(handler=handler, 
    … …  
    12611146        pass 
    12621147 
    1263     def batchFittingCompleted(self, result): 
    1264         """ 
    1265         Send the finish message from calculate threads to main thread 
    1266         """ 
    1267         self.batchFittingFinishedSignal.emit(result) 
    1268  
    12691148    def batchFitComplete(self, result): 
    12701149        """ 
    … …  
    12731152        #re-enable the Fit button 
    12741153        self.setFittingStopped() 
    1275         # Show the grid panel 
    1276         self.grid_window = BatchOutputPanel(parent=self, output_data=result[0]) 
    1277         self.grid_window.show() 
    1278  
    1279     def fittingCompleted(self, result): 
    1280         """ 
    1281         Send the finish message from calculate threads to main thread 
    1282         """ 
    1283         self.fittingFinishedSignal.emit(result) 
    12841154 
    12851155    def fitComplete(self, result): 
    … …  
    12921162 
    12931163        if result is None: 
    1294             msg = "Fitting failed." 
     1164            msg = "Fitting failed after: %s s.\n" % GuiUtils.formatNumber(elapsed) 
    12951165            self.communicate.statusBarUpdateSignal.emit(msg) 
    12961166            return 
    … …  
    13581228        smearing, accuracy, smearing_min, smearing_max = self.smearing_widget.state() 
    13591229 
    1360         # Get the constraints. 
    13611230        constraints = self.getComplexConstraintsForModel() 
    1362         if fitter is None: 
    1363             # For single fits - check for inter-model constraints 
    1364             constraints = self.getConstraintsForFitting() 
    1365  
    13661231        smearer = None 
    13671232        handler = None 
    … …  
    13771242                             constraints=constraints) 
    13781243            except ValueError as ex: 
    1379                 raise ValueError("Setting model parameters failed with: %s" % ex) 
     1244                logging.error("Setting model parameters failed with: %s" % ex) 
     1245                return 
    13801246 
    13811247            qmin, qmax, _ = self.logic.computeRangeFromData(data) 
    … …  
    15431409        if not dict: 
    15441410            return 
    1545         if self._magnet_model.rowCount() == 0: 
     1411        if self._model_model.rowCount() == 0: 
    15461412            return 
    15471413 
    … …  
    16891555            self.models[model.name] = model 
    16901556 
    1691         self.readCustomCategoryInfo() 
    1692  
    1693     def readCustomCategoryInfo(self): 
    1694         """ 
    1695         Reads the custom model category 
    1696         """ 
    1697         #Looking for plugins 
    1698         self.plugins = list(self.custom_models.values()) 
    1699         plugin_list = [] 
    1700         for name, plug in self.custom_models.items(): 
    1701             self.models[name] = plug 
    1702             plugin_list.append([name, True]) 
    1703         self.master_category_dict[CATEGORY_CUSTOM] = plugin_list 
    1704  
    17051557    def regenerateModelDict(self): 
    17061558        """ 
    … …  
    18101662        Setting model parameters into QStandardItemModel based on selected _model_ 
    18111663        """ 
    1812         name = model_name 
    1813         if self.cbCategory.currentText() == CATEGORY_CUSTOM: 
    1814             # custom kernel load requires full path 
    1815             name = os.path.join(ModelUtilities.find_plugins_dir(), model_name+".py") 
    1816         kernel_module = generate.load_kernel_module(name) 
     1664        kernel_module = generate.load_kernel_module(model_name) 
    18171665        self.model_parameters = modelinfo.make_parameter_table(getattr(kernel_module, 'parameters', [])) 
    18181666 

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

    • Property mode changed from 100644 to 100755
    r3b3b40b rb3e8629  
    179179    plugins = {} 
    180180    for filename in os.listdir(directory): 
    181  
    182181        name, ext = os.path.splitext(filename) 
    183182        if ext == '.py' and not name == '__init__': 
    … …  
    185184            try: 
    186185                model = load_custom_model(path) 
    187                 #model.name = PLUGIN_NAME_BASE + model.name 
     186                model.name = PLUGIN_NAME_BASE + model.name 
    188187                plugins[model.name] = model 
    189188            except Exception: 
    … …  
    416415    implement model 
    417416    """ 
    418     def __init__(self): 
    419         self.__modelmanager = ModelManagerBase() 
    420         self.cat_model_list = [self.__modelmanager.model_dictionary[model_name] for model_name \ 
    421                           in list(self.__modelmanager.model_dictionary.keys()) \ 
    422                           if model_name not in list(self.__modelmanager.stored_plugins.keys())] 
    423  
    424         CategoryInstaller.check_install(model_list=self.cat_model_list) 
    425  
     417    __modelmanager = ModelManagerBase() 
     418    cat_model_list = [__modelmanager.model_dictionary[model_name] for model_name \ 
     419                      in list(__modelmanager.model_dictionary.keys()) \ 
     420                      if model_name not in list(__modelmanager.stored_plugins.keys())] 
     421 
     422    CategoryInstaller.check_install(model_list=cat_model_list) 
    426423    def findModels(self): 
    427424        return self.__modelmanager.findModels() 

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

    r3b3b40b r14ec91c5  
    114114 
    115115        # 3. parameter name should be a separate word, but can have "()[]*+-/ " around 
    116         #valid_neighbours = "()[]*+-/ " 
    117         #start_loc = parameter_string_start -1 
    118         #end_loc = parameter_string_end 
    119         #if not any([constraint_text[start_loc] == ch for ch in valid_neighbours]): 
    120         #    return False 
    121         #if end_loc < len(constraint_text): 
    122         #    if not any([constraint_text[end_loc] == ch for ch in valid_neighbours]): 
    123         #        return False 
     116        valid_neighbours = "()[]*+-/ " 
     117        start_loc = parameter_string_start -1 
     118        end_loc = parameter_string_end 
     119        if not any([constraint_text[start_loc] == ch for ch in valid_neighbours]): 
     120            return False 
     121        if end_loc < len(constraint_text): 
     122            if not any([constraint_text[end_loc] == ch for ch in valid_neighbours]): 
     123                return False 
    124124 
    125125        # 4. replace parameter name with "1" and try to evaluate the expression 

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

    r3b3b40b re4c475b7  
    77    <x>0</x> 
    88    <y>0</y> 
    9     <width>680</width> 
     9    <width>568</width> 
    1010    <height>605</height> 
    1111   </rect> 

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

    • Property mode changed from 100644 to 100755
    r3b3b40b r725d9c06  
    2222if not QtWidgets.QApplication.instance(): 
    2323    app = QtWidgets.QApplication(sys.argv) 
     24#app = QtWidgets.QApplication(sys.argv) 
    2425 
    2526class ConstraintWidgetTest(unittest.TestCase): 
    … …  
    7071        # click on "batch" 
    7172        QTest.mouseClick(self.widget.btnBatch, QtCore.Qt.LeftButton) 
    72         QtWidgets.QApplication.processEvents() 
     73        app.processEvents() 
    7374        # See what the current type is now 
    7475        self.assertEqual(self.widget.currentType, "BatchPage") 
    … …  
    7778        # Go back to single fit 
    7879        QTest.mouseClick(self.widget.btnSingle, QtCore.Qt.LeftButton) 
    79         QtWidgets.QApplication.processEvents() 
     80        app.processEvents() 
    8081        # See what the current type is now 
    8182        self.assertEqual(self.widget.currentType, "FitPage") 

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

    r3b3b40b r63319b0  
    213213    plotRequestedSignal = QtCore.pyqtSignal(list) 
    214214 
    215     # Plot from file names 
    216     plotFromFilenameSignal = QtCore.pyqtSignal(str) 
    217  
    218215    # Plot update requested from a perspective 
    219216    plotUpdateSignal = QtCore.pyqtSignal(list) 
    … …  
    239236    # Send result of Data Operation Utility panel to Data Explorer 
    240237    updateModelFromDataOperationPanelSignal = QtCore.pyqtSignal(QtGui.QStandardItem, dict) 
    241  
    242     # Notify about a new custom plugin being written/deleted/modified 
    243     customModelDirectoryChanged = QtCore.pyqtSignal() 
    244238 
    245239def updateModelItemWithPlot(item, update_data, name=""): 
    … …  
    878872        raise TypeError 
    879873 
    880 def findNextFilename(filename, directory): 
    881     """ 
    882     Finds the next available (non-existing) name for 'filename' in 'directory'. 
    883     plugin.py -> plugin (n).py  - for first 'n' for which the file doesn't exist 
    884     """ 
    885     basename, ext = os.path.splitext(filename) 
    886     # limit the number of copies 
    887     MAX_FILENAMES = 1000 
    888     # Start with (1) 
    889     number_ext = 1 
    890     proposed_filename = "" 
    891     found_filename = False 
    892     # Find the next available filename or exit if too many copies 
    893     while not found_filename or number_ext > MAX_FILENAMES: 
    894         proposed_filename = basename + " ("+str(number_ext)+")" + ext 
    895         if os.path.exists(os.path.join(directory, proposed_filename)): 
    896             number_ext += 1 
    897         else: 
    898             found_filename = True 
    899  
    900     return proposed_filename 
    901  
    902  
    903874class DoubleValidator(QtGui.QDoubleValidator): 
    904875    """ 

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

    r3b3b40b rc3eb858  
    141141# Time out for updating sasview 
    142142UPDATE_TIMEOUT = 2 
    143  
    144 # Logging levels to disable, if any 
    145 DISABLE_LOGGING = logging.DEBUG 
    146  
    147143def printEVT(message): 
    148144    """ 
Note: See TracChangeset for help on using the changeset viewer.