Changeset bb9610a in sasview


Ignore:
Timestamp:
Aug 8, 2018 11:51:49 AM (2 weeks ago)
Author:
tcbennun
Branches:
ESS_GUI_beta_approx
Children:
cc0556d
Parents:
ea578f6 (diff), cde0611 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'ESS_GUI' into ESS_GUI_beta_approx

Files:
5 added
15 edited

Legend:

Unmodified
Added
Removed
  • build_tools/jenkins_ubuntu_build.sh

    rfb3d974 rbc8750eb  
    33 
    44## Set up path for py36 - conda 
    5 export PATH=/home/sasview/miniconda3/bin:$PATH 
     5export PATH=/home/sasview/anaconda3/bin:$PATH 
    66 
    77 
  • installers/sasview_qt5_osx.spec

    r2ae3edb ra688be1  
    4444# ADDITIONAL DATA ############################################################ 
    4545datas = [('../src/sas/sasview/images', 'images')] 
    46  
    47 datas = [('../src/sas/sasview/images/ball.ico', '.')] 
    48  
    4946datas.append(('../src/sas/sasview/media','media')) 
    5047datas.append(('../src/sas/sasview/test','test')) 
     
    5451datas.append(('../src/sas/logger_config.py','.')) 
    5552datas.append(('../src/sas/logging.ini','.')) 
     53datas.append(('../src/sas/sasview/custom_config.py','sas/sasview')) 
     54datas.append(('../src/sas/sasview/local_config.py','sas/sasview')) 
    5655 
    5756# pyinstaller gets mightily confused by upper/lower case, 
     
    171170          debug=False, 
    172171          upx=UPX, 
    173           icon=os.path.join("../src/sas/sasview/images","ball.ico"), 
     172          icon=os.path.join("../src/sas/sasview/images","ball.icns"), 
    174173          version="version.txt", 
    175174          console=False ) 
     
    187186    app = BUNDLE(coll, 
    188187        name='sasview.app', 
    189         icon='../src/sas/sasview/images/ball.ico', 
     188        icon='../src/sas/sasview/images/ball.icns', 
    190189        bundle_identifier=None) 
    191190 
  • run.py

    r2e27cdb6 rdb05c44  
    145145        import sas.qtgui.convertUI 
    146146 
     147    # initialize OpenCL setting 
     148    SAS_OPENCL = sas.get_custom_config().SAS_OPENCL 
     149    if SAS_OPENCL and "SAS_OPENCL" not in os.environ: 
     150        os.environ["SAS_OPENCL"] = SAS_OPENCL 
     151 
    147152 
    148153if __name__ == "__main__": 
  • src/sas/qtgui/MainWindow/DataExplorer.py

    rfce6c55 rebfe223  
    496496        # Now query the model item for available plots 
    497497        plots = GuiUtils.plotsFromFilename(filename, model) 
     498        ids = [list(self.active_plots.values())[id].data.id for id in range(len(self.active_plots))] 
    498499 
    499500        new_plots = [] 
    500501        for item, plot in plots.items(): 
    501502            plot_id = plot.id 
    502             if plot_id in list(self.active_plots.keys()): 
     503            if plot_id in ids: 
    503504                self.active_plots[plot_id].replacePlot(plot_id, plot) 
    504505            else: 
  • src/sas/qtgui/MainWindow/GuiManager.py

    re4335ae r060413c  
    2727from sas.qtgui.MainWindow.AboutBox import AboutBox 
    2828from sas.qtgui.MainWindow.WelcomePanel import WelcomePanel 
     29from sas.qtgui.MainWindow.CategoryManager import CategoryManager 
    2930 
    3031from sas.qtgui.MainWindow.DataManager import DataManager 
     
    134135        self.ackWidget = Acknowledgements() 
    135136        self.aboutWidget = AboutBox() 
     137        self.categoryManagerWidget = CategoryManager(self._parent, manager=self) 
    136138        self.welcomePanel = WelcomePanel() 
    137139        self.grid_window = None 
     
    419421        self._workspace.actionHide_Toolbar.triggered.connect(self.actionHide_Toolbar) 
    420422        self._workspace.actionStartup_Settings.triggered.connect(self.actionStartup_Settings) 
    421         self._workspace.actionCategry_Manager.triggered.connect(self.actionCategry_Manager) 
     423        self._workspace.actionCategory_Manager.triggered.connect(self.actionCategory_Manager) 
    422424        # Tools 
    423425        self._workspace.actionData_Operation.triggered.connect(self.actionData_Operation) 
     
    520522    def actionCopy(self): 
    521523        """ 
    522         """ 
    523         print("actionCopy TRIGGERED") 
     524        Send a signal to the fitting perspective so parameters 
     525        can be saved to the clipboard 
     526        """ 
     527        self.communicate.copyFitParamsSignal.emit("") 
    524528        pass 
    525529 
    526530    def actionPaste(self): 
    527531        """ 
    528         """ 
    529         print("actionPaste TRIGGERED") 
    530         pass 
     532        Send a signal to the fitting perspective so parameters 
     533        from the clipboard can be used to modify the fit state 
     534        """ 
     535        self.communicate.pasteFitParamsSignal.emit() 
    531536 
    532537    def actionReport(self): 
     
    555560    def actionExcel(self): 
    556561        """ 
    557         """ 
    558         print("actionExcel TRIGGERED") 
    559         pass 
     562        Send a signal to the fitting perspective so parameters 
     563        can be saved to the clipboard 
     564        """ 
     565        self.communicate.copyFitParamsSignal.emit("Excel") 
    560566 
    561567    def actionLatex(self): 
    562568        """ 
    563         """ 
    564         print("actionLatex TRIGGERED") 
    565         pass 
     569        Send a signal to the fitting perspective so parameters 
     570        can be saved to the clipboard 
     571        """ 
     572        self.communicate.copyFitParamsSignal.emit("Latex") 
    566573 
    567574    #============ VIEW ================= 
     
    606613        pass 
    607614 
    608     def actionCategry_Manager(self): 
    609         """ 
    610         """ 
    611         print("actionCategry_Manager TRIGGERED") 
    612         pass 
     615    def actionCategory_Manager(self): 
     616        """ 
     617        """ 
     618        self.categoryManagerWidget.show() 
    613619 
    614620    #============ TOOLS ================= 
  • src/sas/qtgui/MainWindow/MainWindow.py

    re4335ae r3d18691  
    2727        except Exception as ex: 
    2828            import logging 
    29             logging.error("Application failed with: " + str(ex)) 
    30             print("Application failed with: ", ex) 
     29            logging.error("Application failed with: "+str(ex)) 
     30            print("Application failed with: ", str(ex)) 
    3131 
    3232    def closeEvent(self, event): 
  • src/sas/qtgui/MainWindow/UI/MainWindowUI.ui

    r2b39fea r3d18691  
    7575    <addaction name="actionStartup_Settings"/> 
    7676    <addaction name="separator"/> 
    77     <addaction name="actionCategry_Manager"/> 
     77    <addaction name="actionCategory_Manager"/> 
    7878   </widget> 
    7979   <widget class="QMenu" name="menuTool"> 
     
    324324   </property> 
    325325  </action> 
    326   <action name="actionCategry_Manager"> 
     326  <action name="actionCategory_Manager"> 
    327327   <property name="text"> 
    328328    <string>Category Manager</string> 
  • src/sas/qtgui/Perspectives/Fitting/FittingUtilities.py

    r00077cf rbb9610a  
    33from PyQt5 import QtCore 
    44from PyQt5 import QtGui 
    5 from PyQt5 import QtWidgets 
    65 
    76import numpy 
     
    9998                    continue 
    10099                width = kernel_module.getParam(p.name+'.width') 
    101                 type = kernel_module.getParam(p.name+'.type') 
     100                ptype = kernel_module.getParam(p.name+'.type') 
    102101 
    103102                item1_2 = QtGui.QStandardItem(str(width)) 
     
    107106                item1_4 = QtGui.QStandardItem() 
    108107                item1_4.setEditable(False) 
    109                 item1_5 = QtGui.QStandardItem(type) 
     108                item1_5 = QtGui.QStandardItem(ptype) 
    110109                item1_5.setEditable(False) 
    111110                poly_item.appendRow([item1_1, item1_2, item1_3, item1_4, item1_5]) 
     
    474473    returning the modified (deep) copy of the kernel. 
    475474    """ 
    476     assert(isinstance(results, dict)) 
     475    assert isinstance(results, dict) 
    477476    local_kernel = copy.deepcopy(kernel) 
    478477 
     
    495494    for row in range(num_rows): 
    496495        param_name = model.item(row, 0).text() 
    497         checkbox_state = model.item(row,0).checkState() == QtCore.Qt.Checked 
    498         value= model.item(row, 1).text() 
     496        checkbox_state = model.item(row, 0).checkState() == QtCore.Qt.Checked 
     497        value = model.item(row, 1).text() 
    499498        column_shift = 0 
    500499        if model.columnCount() == 5: # no error column 
     
    525524    """ 
    526525    param = [] 
    527     if kernel_module is None:  
     526    if kernel_module is None: 
    528527        return None 
    529528    for param_name in list(kernel_module.params.keys()): 
     
    542541 
    543542    return param 
     543 
     544def formatParameters(parameters): 
     545    """ 
     546    Prepare the parameter string in the standard SasView layout 
     547    """ 
     548    assert parameters is not None 
     549    assert isinstance(parameters, list) 
     550    output_string = "sasview_parameter_values:" 
     551    for parameter in parameters: 
     552        output_string += ",".join([p for p in parameter if p is not None]) 
     553        output_string += ":" 
     554    return output_string 
     555 
     556def formatParametersExcel(parameters): 
     557    """ 
     558    Prepare the parameter string in the Excel format (tab delimited) 
     559    """ 
     560    assert parameters is not None 
     561    assert isinstance(parameters, list) 
     562    crlf = chr(13) + chr(10) 
     563    tab = chr(9) 
     564 
     565    output_string = "" 
     566    # names 
     567    names = "" 
     568    values = "" 
     569    for parameter in parameters: 
     570        names += parameter[0]+tab 
     571        # Add the error column if fitted 
     572        if parameter[1] == "True" and parameter[3] is not None: 
     573            names += parameter[0]+"_err"+tab 
     574 
     575        values += parameter[2]+tab 
     576        if parameter[1] == "True" and parameter[3] is not None: 
     577            values += parameter[3]+tab 
     578        # add .npts and .nsigmas when necessary 
     579        if parameter[0][-6:] == ".width": 
     580            names += parameter[0].replace('.width', '.nsigmas') + tab 
     581            names += parameter[0].replace('.width', '.npts') + tab 
     582            values += parameter[5] + tab + parameter[4] + tab 
     583 
     584    output_string = names + crlf + values 
     585    return output_string 
     586 
     587def formatParametersLatex(parameters): 
     588    """ 
     589    Prepare the parameter string in latex 
     590    """ 
     591    assert parameters is not None 
     592    assert isinstance(parameters, list) 
     593    output_string = r'\begin{table}' 
     594    output_string += r'\begin{tabular}[h]' 
     595 
     596    crlf = chr(13) + chr(10) 
     597    output_string += '{|' 
     598    output_string += 'l|l|'*len(parameters) 
     599    output_string += r'}\hline' 
     600    output_string += crlf 
     601 
     602    for index, parameter in enumerate(parameters): 
     603        name = parameter[0] # Parameter name 
     604        output_string += name.replace('_', r'\_')  # Escape underscores 
     605        # Add the error column if fitted 
     606        if parameter[1] == "True" and parameter[3] is not None: 
     607            output_string += ' & ' 
     608            output_string += parameter[0]+r'\_err' 
     609 
     610        if index < len(parameters) - 1: 
     611            output_string += ' & ' 
     612 
     613        # add .npts and .nsigmas when necessary 
     614        if parameter[0][-6:] == ".width": 
     615            output_string += parameter[0].replace('.width', '.nsigmas') + ' & ' 
     616            output_string += parameter[0].replace('.width', '.npts') 
     617 
     618            if index < len(parameters) - 1: 
     619                output_string += ' & ' 
     620 
     621    output_string += r'\\ \hline' 
     622    output_string += crlf 
     623 
     624    # Construct row of values and errors 
     625    for index, parameter in enumerate(parameters): 
     626        output_string += parameter[2] 
     627        if parameter[1] == "True" and parameter[3] is not None: 
     628            output_string += ' & ' 
     629            output_string += parameter[3] 
     630 
     631        if index < len(parameters) - 1: 
     632            output_string += ' & ' 
     633 
     634        # add .npts and .nsigmas when necessary 
     635        if parameter[0][-6:] == ".width": 
     636            output_string += parameter[5] + ' & ' 
     637            output_string += parameter[4] 
     638 
     639            if index < len(parameters) - 1: 
     640                output_string += ' & ' 
     641 
     642    output_string += r'\\ \hline' 
     643    output_string += crlf 
     644    output_string += r'\end{tabular}' 
     645    output_string += r'\end{table}' 
     646 
     647    return output_string 
  • src/sas/qtgui/Perspectives/Fitting/FittingWidget.py

    rea578f6 rbb9610a  
    11import json 
    22import os 
    3 import copy 
    43from collections import defaultdict 
    54 
     
    7170    """ 
    7271    def __init__(self, parent=None): 
    73         QtGui.QStandardItemModel.__init__(self,parent) 
     72        QtGui.QStandardItemModel.__init__(self, parent) 
    7473 
    7574    def headerData(self, section, orientation, role=QtCore.Qt.DisplayRole): 
     
    137136        self.initializeCategoryCombo() 
    138137 
     138        # Initial control state 
     139        self.initializeControls() 
     140 
     141        QtWidgets.QApplication.processEvents() 
     142 
    139143        # Connect signals to controls 
    140144        self.initializeSignals() 
    141  
    142         # Initial control state 
    143         self.initializeControls() 
    144145 
    145146        if data is not None: 
     
    154155    def logic(self): 
    155156        # make sure the logic contains at least one element 
    156         assert(self._logic) 
     157        assert self._logic 
    157158        # logic connected to the currently shown data 
    158159        return self._logic[self.data_index] 
     
    209210        self.is_chain_fitting = False 
    210211        # Is the fit job running? 
    211         self.fit_started=False 
     212        self.fit_started = False 
    212213        # The current fit thread 
    213214        self.calc_fit = None 
     
    325326            } 
    326327 
     328            QTreeView::item { 
     329                border: 1px; 
     330                padding: 2px 1px; 
     331            } 
     332 
    327333            QTreeView::item:hover { 
    328334                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #e7effd, stop: 1 #cbdaf1); 
     
    370376        self.cbCategory.addItem(CATEGORY_DEFAULT) 
    371377        self.cbCategory.addItems(category_list) 
    372         self.cbCategory.addItem(CATEGORY_STRUCTURE) 
     378        if CATEGORY_STRUCTURE not in category_list: 
     379            self.cbCategory.addItem(CATEGORY_STRUCTURE) 
    373380        self.cbCategory.setCurrentIndex(0) 
    374381 
     
    521528        self.communicate.saveAnalysisSignal.connect(self.savePageState) 
    522529        self.smearing_widget.smearingChangedSignal.connect(self.onSmearingOptionsUpdate) 
    523         #self.communicate.saveReportSignal.connect(self.saveReport) 
     530        self.communicate.copyFitParamsSignal.connect(self.onParameterCopy) 
     531        self.communicate.pasteFitParamsSignal.connect(self.onParameterPaste) 
     532 
     533        # Communicator signal 
     534        self.communicate.updateModelCategoriesSignal.connect(self.onCategoriesChanged) 
    524535 
    525536    def modelName(self): 
     
    561572            return menu 
    562573        # Select for fitting 
    563         param_string = "parameter " if num_rows==1 else "parameters " 
    564         to_string = "to its current value" if num_rows==1 else "to their current values" 
     574        param_string = "parameter " if num_rows == 1 else "parameters " 
     575        to_string = "to its current value" if num_rows == 1 else "to their current values" 
    565576        has_constraints = any([self.rowHasConstraint(i) for i in rows]) 
    566577 
     
    617628        # There have to be only two rows selected. The caller takes care of that 
    618629        # but let's check the correctness. 
    619         assert(len(selected_rows)==2) 
     630        assert len(selected_rows) == 2 
    620631 
    621632        params_list = [s.data() for s in selected_rows] 
     
    686697        """ 
    687698        # Create a new item and add the Constraint object as a child 
    688         assert(isinstance(constraint, Constraint)) 
    689         assert(0<=row<=self._model_model.rowCount()) 
    690         assert(self.isCheckable(row)) 
     699        assert isinstance(constraint, Constraint) 
     700        assert 0 <= row <= self._model_model.rowCount() 
     701        assert self.isCheckable(row) 
    691702 
    692703        item = QtGui.QStandardItem() 
     
    762773        Delete constraints from selected parameters. 
    763774        """ 
    764         params =  [s.data() for s in self.lstParams.selectionModel().selectedRows() 
     775        params = [s.data() for s in self.lstParams.selectionModel().selectedRows() 
    765776                   if self.isCheckable(s.row())] 
    766777        for param in params: 
     
    14891500        qmax = self.q_range_max 
    14901501        params_to_fit = self.parameters_to_fit 
    1491         if (not params_to_fit): 
     1502        if not params_to_fit: 
    14921503            raise ValueError('Fitting requires at least one parameter to optimize.') 
    14931504 
     
    16081619        self.has_error_column = True 
    16091620 
     1621    def iterateOverPolyModel(self, func): 
     1622        """ 
     1623        Take func and throw it inside the poly model row loop 
     1624        """ 
     1625        for row_i in range(self._poly_model.rowCount()): 
     1626            func(row_i) 
     1627 
    16101628    def updatePolyModelFromList(self, param_dict): 
    16111629        """ 
     
    16151633        if not dict: 
    16161634            return 
    1617  
    1618         def iterateOverPolyModel(func): 
    1619             """ 
    1620             Take func and throw it inside the poly model row loop 
    1621             """ 
    1622             for row_i in range(self._poly_model.rowCount()): 
    1623                 func(row_i) 
    16241635 
    16251636        def updateFittedValues(row_i): 
     
    16591670        # updating charts with every single model change on the end of fitting 
    16601671        self._poly_model.blockSignals(True) 
    1661         iterateOverPolyModel(updateFittedValues) 
     1672        self.iterateOverPolyModel(updateFittedValues) 
    16621673        self._poly_model.blockSignals(False) 
    16631674 
     
    16671678        self.lstPoly.itemDelegate().addErrorColumn() 
    16681679        error_column = [] 
    1669         iterateOverPolyModel(createErrorColumn) 
     1680        self.iterateOverPolyModel(createErrorColumn) 
    16701681 
    16711682        # switch off reponse to model change 
     
    16761687 
    16771688        self.has_poly_error_column = True 
     1689 
     1690    def iterateOverMagnetModel(self, func): 
     1691        """ 
     1692        Take func and throw it inside the magnet model row loop 
     1693        """ 
     1694        for row_i in range(self._model_model.rowCount()): 
     1695            func(row_i) 
    16781696 
    16791697    def updateMagnetModelFromList(self, param_dict): 
     
    17291747        # updating charts with every single model change on the end of fitting 
    17301748        self._magnet_model.blockSignals(True) 
    1731         iterateOverMagnetModel(updateFittedValues) 
     1749        self.iterateOverMagnetModel(updateFittedValues) 
    17321750        self._magnet_model.blockSignals(False) 
    17331751 
     
    17371755        self.lstMagnetic.itemDelegate().addErrorColumn() 
    17381756        error_column = [] 
    1739         iterateOverMagnetModel(createErrorColumn) 
     1757        self.iterateOverMagnetModel(createErrorColumn) 
    17401758 
    17411759        # switch off reponse to model change 
     
    19691987            # custom kernel load requires full path 
    19701988            name = os.path.join(ModelUtilities.find_plugins_dir(), model_name+".py") 
    1971         kernel_module = generate.load_kernel_module(name) 
     1989        try: 
     1990            kernel_module = generate.load_kernel_module(name) 
     1991        except ModuleNotFoundError: 
     1992            # maybe it's a recategorised custom model? 
     1993            name = os.path.join(ModelUtilities.find_plugins_dir(), model_name+".py") 
     1994            # If this rises, it's a valid problem. 
     1995            kernel_module = generate.load_kernel_module(name) 
    19721996 
    19731997        if hasattr(kernel_module, 'parameters'): 
     
    23552379        self.createNewIndex(residuals_plot) 
    23562380 
     2381    def onCategoriesChanged(self): 
     2382            """ 
     2383            Reload the category/model comboboxes 
     2384            """ 
     2385            # Store the current combo indices 
     2386            current_cat = self.cbCategory.currentText() 
     2387            current_model = self.cbModel.currentText() 
     2388 
     2389            # reread the category file and repopulate the combo 
     2390            self.cbCategory.blockSignals(True) 
     2391            self.cbCategory.clear() 
     2392            self.readCategoryInfo() 
     2393            self.initializeCategoryCombo() 
     2394 
     2395            # Scroll back to the original index in Categories 
     2396            new_index = self.cbCategory.findText(current_cat) 
     2397            if new_index != -1: 
     2398                self.cbCategory.setCurrentIndex(new_index) 
     2399            self.cbCategory.blockSignals(False) 
     2400            # ...and in the Models 
     2401            self.cbModel.blockSignals(True) 
     2402            new_index = self.cbModel.findText(current_model) 
     2403            if new_index != -1: 
     2404                self.cbModel.setCurrentIndex(new_index) 
     2405            self.cbModel.blockSignals(False) 
     2406 
     2407            return 
     2408 
    23572409    def calcException(self, etype, value, tb): 
    23582410        """ 
     
    29232975        #self._copy_parameters_state(self.fixed_param, self.state.fixed_param) 
    29242976 
    2925  
     2977    def onParameterCopy(self, format=None): 
     2978        """ 
     2979        Copy current parameters into the clipboard 
     2980        """ 
     2981        # run a loop over all parameters and pull out 
     2982        # first - regular params 
     2983        param_list = [] 
     2984        def gatherParams(row): 
     2985            """ 
     2986            Create list of main parameters based on _model_model 
     2987            """ 
     2988            param_name = str(self._model_model.item(row, 0).text()) 
     2989            param_checked = str(self._model_model.item(row, 0).checkState() == QtCore.Qt.Checked) 
     2990            param_value = str(self._model_model.item(row, 1).text()) 
     2991            param_error = None 
     2992            column_offset = 0 
     2993            if self.has_error_column: 
     2994                param_error = str(self._model_model.item(row, 2).text()) 
     2995                column_offset = 1 
     2996            param_min = str(self._model_model.item(row, 2+column_offset).text()) 
     2997            param_max = str(self._model_model.item(row, 3+column_offset).text()) 
     2998            param_list.append([param_name, param_checked, param_value, param_error, param_min, param_max]) 
     2999 
     3000        def gatherPolyParams(row): 
     3001            """ 
     3002            Create list of polydisperse parameters based on _poly_model 
     3003            """ 
     3004            param_name = str(self._poly_model.item(row, 0).text()).split()[-1] 
     3005            param_checked = str(self._poly_model.item(row, 0).checkState() == QtCore.Qt.Checked) 
     3006            param_value = str(self._poly_model.item(row, 1).text()) 
     3007            param_error = None 
     3008            column_offset = 0 
     3009            if self.has_poly_error_column: 
     3010                param_error = str(self._poly_model.item(row, 2).text()) 
     3011                column_offset = 1 
     3012            param_min   = str(self._poly_model.item(row, 2+column_offset).text()) 
     3013            param_max   = str(self._poly_model.item(row, 3+column_offset).text()) 
     3014            param_npts  = str(self._poly_model.item(row, 4+column_offset).text()) 
     3015            param_nsigs = str(self._poly_model.item(row, 5+column_offset).text()) 
     3016            param_fun   = str(self._poly_model.item(row, 6+column_offset).text()).rstrip() 
     3017            # width 
     3018            name = param_name+".width" 
     3019            param_list.append([name, param_checked, param_value, param_error, 
     3020                                param_npts, param_nsigs, param_min, param_max, param_fun]) 
     3021 
     3022        def gatherMagnetParams(row): 
     3023            """ 
     3024            Create list of magnetic parameters based on _magnet_model 
     3025            """ 
     3026            param_name = str(self._magnet_model.item(row, 0).text()) 
     3027            param_checked = str(self._magnet_model.item(row, 0).checkState() == QtCore.Qt.Checked) 
     3028            param_value = str(self._magnet_model.item(row, 1).text()) 
     3029            param_error = None 
     3030            column_offset = 0 
     3031            if self.has_magnet_error_column: 
     3032                param_error = str(self._magnet_model.item(row, 2).text()) 
     3033                column_offset = 1 
     3034            param_min = str(self._magnet_model.item(row, 2+column_offset).text()) 
     3035            param_max = str(self._magnet_model.item(row, 3+column_offset).text()) 
     3036            param_list.append([param_name, param_checked, param_value, param_error, param_min, param_max]) 
     3037 
     3038        self.iterateOverModel(gatherParams) 
     3039        if self.chkPolydispersity.isChecked(): 
     3040            self.iterateOverPolyModel(gatherPolyParams) 
     3041        if self.chkMagnetism.isChecked() and self.chkMagnetism.isEnabled(): 
     3042            self.iterateOverMagnetModel(gatherMagnetParams) 
     3043 
     3044        if format=="": 
     3045            formatted_output = FittingUtilities.formatParameters(param_list) 
     3046        elif format == "Excel": 
     3047            formatted_output = FittingUtilities.formatParametersExcel(param_list) 
     3048        elif format == "Latex": 
     3049            formatted_output = FittingUtilities.formatParametersLatex(param_list) 
     3050        else: 
     3051            raise AttributeError("Bad format specifier.") 
     3052 
     3053        # Dump formatted_output to the clipboard 
     3054        cb = QtWidgets.QApplication.clipboard() 
     3055        cb.setText(formatted_output) 
     3056 
     3057    def onParameterPaste(self): 
     3058        """ 
     3059        Use the clipboard to update fit state 
     3060        """ 
     3061        # Check if the clipboard contains right stuff 
     3062        cb = QtWidgets.QApplication.clipboard() 
     3063        cb_text = cb.text() 
     3064 
     3065        context = {} 
     3066        # put the text into dictionary 
     3067        lines = cb_text.split(':') 
     3068        if lines[0] != 'sasview_parameter_values': 
     3069            return False 
     3070        for line in lines[1:-1]: 
     3071            if len(line) != 0: 
     3072                item = line.split(',') 
     3073                check = item[1] 
     3074                name = item[0] 
     3075                value = item[2] 
     3076                # Transfer the text to content[dictionary] 
     3077                context[name] = [check, value] 
     3078 
     3079                # limits 
     3080                limit_lo = item[3] 
     3081                context[name].append(limit_lo) 
     3082                limit_hi = item[4] 
     3083                context[name].append(limit_hi) 
     3084 
     3085                # Polydisp 
     3086                if len(item) > 5: 
     3087                    value = item[5] 
     3088                    context[name].append(value) 
     3089                    try: 
     3090                        value = item[6] 
     3091                        context[name].append(value) 
     3092                        value = item[7] 
     3093                        context[name].append(value) 
     3094                    except IndexError: 
     3095                        pass 
     3096 
     3097        self.updateFullModel(context) 
     3098        self.updateFullPolyModel(context) 
     3099 
     3100    def updateFullModel(self, param_dict): 
     3101        """ 
     3102        Update the model with new parameters 
     3103        """ 
     3104        assert isinstance(param_dict, dict) 
     3105        if not dict: 
     3106            return 
     3107 
     3108        def updateFittedValues(row): 
     3109            # Utility function for main model update 
     3110            # internal so can use closure for param_dict 
     3111            param_name = str(self._model_model.item(row, 0).text()) 
     3112            if param_name not in list(param_dict.keys()): 
     3113                return 
     3114            # checkbox state 
     3115            param_checked = QtCore.Qt.Checked if param_dict[param_name][0] == "True" else QtCore.Qt.Unchecked 
     3116            self._model_model.item(row, 0).setCheckState(param_checked) 
     3117 
     3118            # modify the param value 
     3119            param_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True) 
     3120            self._model_model.item(row, 1).setText(param_repr) 
     3121 
     3122            # Potentially the error column 
     3123            ioffset = 0 
     3124            if len(param_dict[param_name])>4 and self.has_error_column: 
     3125                # error values are not editable - no need to update 
     3126                #error_repr = GuiUtils.formatNumber(param_dict[param_name][2], high=True) 
     3127                #self._model_model.item(row, 2).setText(error_repr) 
     3128                ioffset = 1 
     3129            # min/max 
     3130            param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True) 
     3131            self._model_model.item(row, 2+ioffset).setText(param_repr) 
     3132            param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True) 
     3133            self._model_model.item(row, 3+ioffset).setText(param_repr) 
     3134 
     3135        # block signals temporarily, so we don't end up 
     3136        # updating charts with every single model change on the end of fitting 
     3137        self._model_model.blockSignals(True) 
     3138        self.iterateOverModel(updateFittedValues) 
     3139        self._model_model.blockSignals(False) 
     3140 
     3141    def updateFullPolyModel(self, param_dict): 
     3142        """ 
     3143        Update the polydispersity model with new parameters, create the errors column 
     3144        """ 
     3145        assert isinstance(param_dict, dict) 
     3146        if not dict: 
     3147            return 
     3148 
     3149        def updateFittedValues(row): 
     3150            # Utility function for main model update 
     3151            # internal so can use closure for param_dict 
     3152            if row >= self._poly_model.rowCount(): 
     3153                return 
     3154            param_name = str(self._poly_model.item(row, 0).text()).rsplit()[-1] + '.width' 
     3155            if param_name not in list(param_dict.keys()): 
     3156                return 
     3157            # checkbox state 
     3158            param_checked = QtCore.Qt.Checked if param_dict[param_name][0] == "True" else QtCore.Qt.Unchecked 
     3159            self._poly_model.item(row,0).setCheckState(param_checked) 
     3160 
     3161            # modify the param value 
     3162            param_repr = GuiUtils.formatNumber(param_dict[param_name][1], high=True) 
     3163            self._poly_model.item(row, 1).setText(param_repr) 
     3164 
     3165            # Potentially the error column 
     3166            ioffset = 0 
     3167            if len(param_dict[param_name])>4 and self.has_poly_error_column: 
     3168                ioffset = 1 
     3169            # min 
     3170            param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True) 
     3171            self._poly_model.item(row, 2+ioffset).setText(param_repr) 
     3172            # max 
     3173            param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True) 
     3174            self._poly_model.item(row, 3+ioffset).setText(param_repr) 
     3175            # Npts 
     3176            param_repr = GuiUtils.formatNumber(param_dict[param_name][4+ioffset], high=True) 
     3177            self._poly_model.item(row, 4+ioffset).setText(param_repr) 
     3178            # Nsigs 
     3179            param_repr = GuiUtils.formatNumber(param_dict[param_name][5+ioffset], high=True) 
     3180            self._poly_model.item(row, 5+ioffset).setText(param_repr) 
     3181 
     3182            param_repr = GuiUtils.formatNumber(param_dict[param_name][5+ioffset], high=True) 
     3183            self._poly_model.item(row, 5+ioffset).setText(param_repr) 
     3184 
     3185        # block signals temporarily, so we don't end up 
     3186        # updating charts with every single model change on the end of fitting 
     3187        self._poly_model.blockSignals(True) 
     3188        self.iterateOverPolyModel(updateFittedValues) 
     3189        self._poly_model.blockSignals(False) 
     3190 
     3191 
  • src/sas/qtgui/Perspectives/Fitting/GPUOptions.py

    raed0532 rdb05c44  
    3434    clicked = False 
    3535    sas_open_cl = None 
     36    cl_options = None 
    3637 
    3738    def __init__(self, parent=None): 
     
    4950        cl_tuple = _get_clinfo() 
    5051        self.sas_open_cl = os.environ.get("SAS_OPENCL", "") 
     52 
     53        # Keys are the names in the form "platform: device". Corresponding values are the combined indices, e.g. 
     54        # "0:1", for setting the SAS_OPENCL env. 
     55        self.cl_options = {} 
     56 
    5157        for title, descr in cl_tuple: 
    5258            # Create an item for each openCL option 
     
    5561            check_box.setText(_translate("GPUOptions", descr, None)) 
    5662            self.optionsLayout.addWidget(check_box) 
    57             if (descr == self.sas_open_cl) or ( 
     63            if (title == self.sas_open_cl) or ( 
    5864                            title == "None" and not self.clicked): 
    5965                check_box.click() 
    6066                self.clicked = True 
     67            self.cl_options[descr] = title 
    6168        self.openCLCheckBoxGroup.setMinimumWidth(self.optionsLayout.sizeHint().width()+10) 
    6269 
     
    7683        checked = None 
    7784        for box in self.openCLCheckBoxGroup.findChildren(QtWidgets.QCheckBox): 
    78             if box.isChecked() and (str(box.text()) == self.sas_open_cl or ( 
     85            if box.isChecked() and (self.cl_options[str(box.text())] == self.sas_open_cl or ( 
    7986                    str(box.text()) == "No OpenCL" and self.sas_open_cl == "")): 
    8087                box.setChecked(False) 
     
    8289                checked = box 
    8390        if hasattr(checked, "text"): 
    84             self.sas_open_cl = str(checked.text()) 
     91            self.sas_open_cl = self.cl_options[str(checked.text())] 
    8592        else: 
    8693            self.sas_open_cl = None 
     
    226233    for cl_platform in cl_platforms: 
    227234        d_index = 0 
    228         cl_platforms = cl_platform.get_devices() 
    229         for cl_platform in cl_platforms: 
    230             if len(cl_platforms) > 1 and len(cl_platforms) > 1: 
     235        cl_devices = cl_platform.get_devices() 
     236        for cl_device in cl_devices: 
     237            if len(cl_platforms) > 1 and len(cl_devices) > 1: 
    231238                combined_index = ":".join([str(p_index), str(d_index)]) 
    232239            elif len(cl_platforms) > 1: 
     
    234241            else: 
    235242                combined_index = str(d_index) 
    236             clinfo.append((combined_index, ":".join([cl_platform.name, 
    237                                                      cl_platform.name]))) 
     243            clinfo.append((combined_index, ": ".join([cl_platform.name, 
     244                                                     cl_device.name]))) 
    238245            d_index += 1 
    239246        p_index += 1 
  • src/sas/qtgui/Perspectives/Fitting/ViewDelegate.py

    r00077cf rbb9610a  
    182182        Overwrite generic painter for certain columns 
    183183        """ 
    184         if index.column() in (self.poly_min, self.poly_max): 
     184        if index.column() in (self.poly_pd, self.poly_min, self.poly_max): 
    185185            # Units - present in nice HTML 
    186186            options = QtWidgets.QStyleOptionViewItem(option) 
     
    265265        Overwrite generic painter for certain columns 
    266266        """ 
    267         if index.column() in (self.mag_min, self.mag_max, self.mag_unit): 
     267        if index.column() in (self.mag_value, self.mag_min, self.mag_max, self.mag_unit): 
    268268            # Units - present in nice HTML 
    269269            options = QtWidgets.QStyleOptionViewItem(option) 
     
    290290            rect = textRect.topLeft() 
    291291            y = rect.y() 
    292             y += 5.0 # magic value for rendering nice display in the table 
     292            y += 6.0 # magic value for rendering nice display in the table 
    293293            rect.setY(y) 
    294294            painter.translate(rect) 
  • src/sas/qtgui/Utilities/GuiUtils.py

    r6ff103a r3d18691  
    254254    # Mask Editor requested 
    255255    maskEditorSignal = QtCore.pyqtSignal(Data2D) 
     256 
     257    # Fitting parameter copy to clipboard 
     258    copyFitParamsSignal = QtCore.pyqtSignal(str) 
     259 
     260    # Fitting parameter paste from clipboard 
     261    pasteFitParamsSignal = QtCore.pyqtSignal() 
     262    # Notify about new categories/models from category manager 
     263    updateModelCategoriesSignal = QtCore.pyqtSignal() 
    256264 
    257265def updateModelItemWithPlot(item, update_data, name=""): 
  • src/sas/qtgui/Utilities/PluginDefinition.py

    rc5e0d84 r060413c  
    3030        self.pd_parameter_dict = {} 
    3131 
     32        # Initialize widgets 
     33        self.addWidgets() 
     34 
     35        # Wait for all widgets to finish processing 
     36        QtWidgets.QApplication.processEvents() 
     37 
    3238        # Initialize signals 
    3339        self.addSignals() 
    34  
    35         # Initialize widgets 
    36         self.addWidgets() 
    3740 
    3841    def addTooltip(self): 
     
    160163        # keep in mind that this is called every time the text changes. 
    161164        # mind the performance! 
    162         self.addTooltip() 
    163         self.model['text'] = self.txtFunction.toPlainText().lstrip().rstrip() 
    164         self.modelModified.emit() 
     165        #self.addTooltip() 
     166        new_text = self.txtFunction.toPlainText().lstrip().rstrip() 
     167        if new_text != self.model['text']: 
     168            self.model['text'] = new_text 
     169            self.modelModified.emit() 
    165170 
    166171    def onOverwrite(self): 
  • src/sas/qtgui/Perspectives/Fitting/UI/FittingWidgetUI.ui

    rd4dac80 rea578f6  
    77    <x>0</x> 
    88    <y>0</y> 
    9     <width>680</width> 
    10     <height>605</height> 
     9    <width>521</width> 
     10    <height>603</height> 
    1111   </rect> 
    1212  </property> 
     
    1919  <property name="minimumSize"> 
    2020   <size> 
    21     <width>434</width> 
     21    <width>521</width> 
    2222    <height>466</height> 
    2323   </size> 
     
    8282      </attribute> 
    8383      <layout class="QGridLayout" name="gridLayout_4"> 
    84        <item row="0" column="0" colspan="4"> 
     84       <item row="1" column="0"> 
     85        <widget class="QGroupBox" name="groupBox_7"> 
     86         <property name="title"> 
     87          <string>Options </string> 
     88         </property> 
     89         <layout class="QVBoxLayout" name="verticalLayout"> 
     90          <item> 
     91           <widget class="QCheckBox" name="chkPolydispersity"> 
     92            <property name="enabled"> 
     93             <bool>true</bool> 
     94            </property> 
     95            <property name="toolTip"> 
     96             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Switch on orientational polydispersity.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string> 
     97            </property> 
     98            <property name="text"> 
     99             <string>Polydispersity</string> 
     100            </property> 
     101            <property name="checkable"> 
     102             <bool>true</bool> 
     103            </property> 
     104           </widget> 
     105          </item> 
     106          <item> 
     107           <widget class="QCheckBox" name="chk2DView"> 
     108            <property name="enabled"> 
     109             <bool>true</bool> 
     110            </property> 
     111            <property name="toolTip"> 
     112             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Switch on 2D view of the model.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string> 
     113            </property> 
     114            <property name="text"> 
     115             <string>2D view</string> 
     116            </property> 
     117            <property name="checkable"> 
     118             <bool>true</bool> 
     119            </property> 
     120           </widget> 
     121          </item> 
     122          <item> 
     123           <widget class="QCheckBox" name="chkMagnetism"> 
     124            <property name="enabled"> 
     125             <bool>true</bool> 
     126            </property> 
     127            <property name="toolTip"> 
     128             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Switch on magnetic scattering parameters.&lt;/p&gt;&lt;p&gt;This option is available only for 2D models.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string> 
     129            </property> 
     130            <property name="text"> 
     131             <string>Magnetism</string> 
     132            </property> 
     133            <property name="checkable"> 
     134             <bool>true</bool> 
     135            </property> 
     136           </widget> 
     137          </item> 
     138          <item> 
     139           <widget class="QCheckBox" name="chkChainFit"> 
     140            <property name="enabled"> 
     141             <bool>true</bool> 
     142            </property> 
     143            <property name="toolTip"> 
     144             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Switch on Chain Fitting (parameter reuse) for batch datasets.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string> 
     145            </property> 
     146            <property name="text"> 
     147             <string>Chain fit</string> 
     148            </property> 
     149            <property name="checkable"> 
     150             <bool>true</bool> 
     151            </property> 
     152           </widget> 
     153          </item> 
     154         </layout> 
     155        </widget> 
     156       </item> 
     157       <item row="1" column="3"> 
     158        <widget class="QGroupBox" name="groupBox_8"> 
     159         <property name="title"> 
     160          <string>Fitting details </string> 
     161         </property> 
     162         <layout class="QGridLayout" name="gridLayout_17"> 
     163          <item row="0" column="0" colspan="2"> 
     164           <layout class="QGridLayout" name="gridLayout_8"> 
     165            <item row="0" column="0"> 
     166             <widget class="QLabel" name="label_16"> 
     167              <property name="text"> 
     168               <string>Min range</string> 
     169              </property> 
     170             </widget> 
     171            </item> 
     172            <item row="0" column="1"> 
     173             <widget class="QLabel" name="lblMinRangeDef"> 
     174              <property name="text"> 
     175               <string>0.005</string> 
     176              </property> 
     177             </widget> 
     178            </item> 
     179            <item row="0" column="2"> 
     180             <widget class="QLabel" name="label_17"> 
     181              <property name="text"> 
     182               <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;à
     183&lt;span style=&quot; vertical-align:super;&quot;&gt;-1&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string> 
     184              </property> 
     185             </widget> 
     186            </item> 
     187            <item row="1" column="0"> 
     188             <widget class="QLabel" name="label_18"> 
     189              <property name="text"> 
     190               <string>Max range</string> 
     191              </property> 
     192             </widget> 
     193            </item> 
     194            <item row="1" column="1"> 
     195             <widget class="QLabel" name="lblMaxRangeDef"> 
     196              <property name="text"> 
     197               <string>0.1</string> 
     198              </property> 
     199             </widget> 
     200            </item> 
     201            <item row="1" column="2"> 
     202             <widget class="QLabel" name="label_19"> 
     203              <property name="text"> 
     204               <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;à
     205&lt;span style=&quot; vertical-align:super;&quot;&gt;-1&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string> 
     206              </property> 
     207             </widget> 
     208            </item> 
     209           </layout> 
     210          </item> 
     211          <item row="1" column="0"> 
     212           <widget class="QLabel" name="label_20"> 
     213            <property name="text"> 
     214             <string>Smearing:</string> 
     215            </property> 
     216           </widget> 
     217          </item> 
     218          <item row="1" column="1"> 
     219           <widget class="QLabel" name="lblCurrentSmearing"> 
     220            <property name="text"> 
     221             <string>None</string> 
     222            </property> 
     223           </widget> 
     224          </item> 
     225         </layout> 
     226        </widget> 
     227       </item> 
     228       <item row="0" column="0" colspan="6"> 
    85229        <widget class="QGroupBox" name="groupBox_6"> 
    86230         <property name="sizePolicy"> 
     
    156300        </widget> 
    157301       </item> 
    158        <item row="1" column="0"> 
    159         <widget class="QGroupBox" name="groupBox_7"> 
    160          <property name="title"> 
    161           <string>Options </string> 
    162          </property> 
    163          <layout class="QVBoxLayout" name="verticalLayout"> 
    164           <item> 
    165            <widget class="QCheckBox" name="chkPolydispersity"> 
    166             <property name="enabled"> 
    167              <bool>true</bool> 
    168             </property> 
    169             <property name="toolTip"> 
    170              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Switch on orientational polydispersity.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string> 
    171             </property> 
    172             <property name="text"> 
    173              <string>Polydispersity</string> 
    174             </property> 
    175             <property name="checkable"> 
    176              <bool>true</bool> 
    177             </property> 
    178            </widget> 
    179           </item> 
    180           <item> 
    181            <widget class="QCheckBox" name="chk2DView"> 
    182             <property name="enabled"> 
    183              <bool>true</bool> 
    184             </property> 
    185             <property name="toolTip"> 
    186              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Switch on 2D view of the model.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string> 
    187             </property> 
    188             <property name="text"> 
    189              <string>2D view</string> 
    190             </property> 
    191             <property name="checkable"> 
    192              <bool>true</bool> 
    193             </property> 
    194            </widget> 
    195           </item> 
    196           <item> 
    197            <widget class="QCheckBox" name="chkMagnetism"> 
    198             <property name="enabled"> 
    199              <bool>true</bool> 
    200             </property> 
    201             <property name="toolTip"> 
    202              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Switch on magnetic scattering parameters.&lt;/p&gt;&lt;p&gt;This option is available only for 2D models.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string> 
    203             </property> 
    204             <property name="text"> 
    205              <string>Magnetism</string> 
    206             </property> 
    207             <property name="checkable"> 
    208              <bool>true</bool> 
    209             </property> 
    210            </widget> 
    211           </item> 
    212           <item> 
    213            <widget class="QCheckBox" name="chkChainFit"> 
    214             <property name="enabled"> 
    215              <bool>true</bool> 
    216             </property> 
    217             <property name="toolTip"> 
    218              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Switch on Chain Fitting (parameter reuse) for batch datasets.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string> 
    219             </property> 
    220             <property name="text"> 
    221              <string>Chain fit</string> 
    222             </property> 
    223             <property name="checkable"> 
    224              <bool>true</bool> 
    225             </property> 
    226            </widget> 
    227           </item> 
    228          </layout> 
    229         </widget> 
    230        </item> 
    231        <item row="1" column="1"> 
    232         <widget class="QGroupBox" name="groupBox_8"> 
    233          <property name="title"> 
    234           <string>Fitting details </string> 
    235          </property> 
    236          <layout class="QGridLayout" name="gridLayout_17"> 
    237           <item row="0" column="0" colspan="2"> 
    238            <layout class="QGridLayout" name="gridLayout_8"> 
    239             <item row="0" column="0"> 
    240              <widget class="QLabel" name="label_16"> 
    241               <property name="text"> 
    242                <string>Min range</string> 
    243               </property> 
    244              </widget> 
    245             </item> 
    246             <item row="0" column="1"> 
    247              <widget class="QLabel" name="lblMinRangeDef"> 
    248               <property name="text"> 
    249                <string>0.005</string> 
    250               </property> 
    251              </widget> 
    252             </item> 
    253             <item row="0" column="2"> 
    254              <widget class="QLabel" name="label_17"> 
    255               <property name="text"> 
    256                <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;à
    257 &lt;span style=&quot; vertical-align:super;&quot;&gt;-1&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string> 
    258               </property> 
    259              </widget> 
    260             </item> 
    261             <item row="1" column="0"> 
    262              <widget class="QLabel" name="label_18"> 
    263               <property name="text"> 
    264                <string>Max range</string> 
    265               </property> 
    266              </widget> 
    267             </item> 
    268             <item row="1" column="1"> 
    269              <widget class="QLabel" name="lblMaxRangeDef"> 
    270               <property name="text"> 
    271                <string>0.1</string> 
    272               </property> 
    273              </widget> 
    274             </item> 
    275             <item row="1" column="2"> 
    276              <widget class="QLabel" name="label_19"> 
    277               <property name="text"> 
    278                <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;à
    279 &lt;span style=&quot; vertical-align:super;&quot;&gt;-1&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string> 
    280               </property> 
    281              </widget> 
    282             </item> 
    283            </layout> 
    284           </item> 
    285           <item row="1" column="0"> 
    286            <widget class="QLabel" name="label_20"> 
    287             <property name="text"> 
    288              <string>Smearing:</string> 
    289             </property> 
    290            </widget> 
    291           </item> 
    292           <item row="1" column="1"> 
    293            <widget class="QLabel" name="lblCurrentSmearing"> 
    294             <property name="text"> 
    295              <string>None</string> 
    296             </property> 
    297            </widget> 
    298           </item> 
    299          </layout> 
    300         </widget> 
    301        </item> 
    302302       <item row="1" column="2"> 
    303303        <spacer name="horizontalSpacer_3"> 
     
    307307         <property name="sizeHint" stdset="0"> 
    308308          <size> 
    309            <width>207</width> 
     309           <width>150</width> 
    310310           <height>20</height> 
    311311          </size> 
     
    313313        </spacer> 
    314314       </item> 
    315        <item row="1" column="3"> 
     315       <item row="1" column="5"> 
    316316        <widget class="QGroupBox" name="groupBox_9"> 
    317317         <property name="title"> 
     
    336336            </item> 
    337337           </layout> 
     338          </item> 
     339         </layout> 
     340        </widget> 
     341       </item> 
     342       <item row="1" column="1"> 
     343        <widget class="QGroupBox" name="groupBox"> 
     344         <property name="title"> 
     345          <string>S(Q) options</string> 
     346         </property> 
     347         <layout class="QVBoxLayout" name="verticalLayout_2"> 
     348          <item> 
     349           <widget class="QLabel" name="label_3"> 
     350            <property name="text"> 
     351             <string>Calculation mode</string> 
     352            </property> 
     353           </widget> 
     354          </item> 
     355          <item> 
     356           <widget class="QComboBox" name="cbCalculationMode"> 
     357            <property name="enabled"> 
     358             <bool>false</bool> 
     359            </property> 
     360            <property name="minimumSize"> 
     361             <size> 
     362              <width>110</width> 
     363              <height>0</height> 
     364             </size> 
     365            </property> 
     366           </widget> 
     367          </item> 
     368          <item> 
     369           <spacer name="verticalSpacer"> 
     370            <property name="orientation"> 
     371             <enum>Qt::Vertical</enum> 
     372            </property> 
     373            <property name="sizeType"> 
     374             <enum>QSizePolicy::Fixed</enum> 
     375            </property> 
     376            <property name="sizeHint" stdset="0"> 
     377             <size> 
     378              <width>20</width> 
     379              <height>40</height> 
     380             </size> 
     381            </property> 
     382           </spacer> 
    338383          </item> 
    339384         </layout> 
  • src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingWidgetTest.py

    r3f5b901 r548f8e2  
    255255 
    256256        # We have 4 more rows now 
    257         self.assertEqual(self.widget._model_model.rowCount(), rowcount+4) 
     257        self.assertEqual(self.widget._model_model.rowCount(), rowcount+5) 
    258258 
    259259        # Switch models 
     
    275275        self.widget.cbStructureFactor.setCurrentIndex(last_index-1) 
    276276        # Do we have all the rows? 
    277         self.assertEqual(self.widget._model_model.rowCount(), 4) 
     277        self.assertEqual(self.widget._model_model.rowCount(), 5) 
    278278 
    279279        # Are the command buttons properly enabled? 
     
    497497        Test opening of the load file dialog for 'array' polydisp. function 
    498498        """ 
     499 
     500        # open a non-existent file 
    499501        filename = os.path.join("UnitTesting", "testdata_noexist.txt") 
     502        with self.assertRaises(OSError, msg="testdata_noexist.txt should be a non-existent file"): 
     503            os.stat(filename) 
    500504        QtWidgets.QFileDialog.getOpenFileName = MagicMock(return_value=(filename,'')) 
    501505        self.widget.show() 
     
    513517 
    514518        # good file 
     519        # TODO: this depends on the working directory being src/sas/qtgui, 
     520        # TODO: which isn't convenient if you want to run this test suite 
     521        # TODO: individually 
    515522        filename = os.path.join("UnitTesting", "testdata.txt") 
     523        try: 
     524            os.stat(filename) 
     525        except OSError: 
     526            self.assertTrue(False, "testdata.txt does not exist") 
    516527        QtWidgets.QFileDialog.getOpenFileName = MagicMock(return_value=(filename,'')) 
    517528 
     
    10121023 
    10131024         # Check the model 
    1014         self.assertEqual(self.widget._model_model.rowCount(), 6) 
     1025        self.assertEqual(self.widget._model_model.rowCount(), 7) 
    10151026        self.assertEqual(self.widget._model_model.columnCount(), 5) 
    10161027 
     
    11281139        # two rows selected 
    11291140        index1 = self.widget.lstParams.model().index(1, 0, QtCore.QModelIndex()) 
    1130         index2 = self.widget.lstParams.model().index(2, 0, QtCore.QModelIndex()) 
     1141        index2 = self.widget.lstParams.model().index(3, 0, QtCore.QModelIndex()) 
    11311142        selection_model = self.widget.lstParams.selectionModel() 
    11321143        selection_model.select(index1, selection_model.Select | selection_model.Rows) 
     
    11641175        # several random parameters 
    11651176        self.assertEqual(self.widget.getRowFromName('scale'), 0) 
    1166         self.assertEqual(self.widget.getRowFromName('length'), 5) 
     1177        self.assertEqual(self.widget.getRowFromName('length'), 6) 
    11671178 
    11681179    def testGetParamNames(self): 
     
    12011212        # Create a constraint object 
    12021213        const = Constraint(parent=None, value=7.0) 
    1203         row = 2 
     1214        row = 3 
    12041215 
    12051216        spy = QtSignalSpy(self.widget, self.widget.constraintAddedSignal) 
     
    12201231        # assign complex constraint now 
    12211232        const = Constraint(parent=None, param='radius', func='5*sld') 
    1222         row = 4 
     1233        row = 5 
    12231234        # call the method tested 
    12241235        self.widget.addConstraintToRow(constraint=const, row=row) 
     
    12791290        self.widget.cbModel.setCurrentIndex(model_index) 
    12801291 
     1292        row1 = 1 
     1293        row2 = 5 
     1294 
     1295        param1 = "background" 
     1296        param2 = "radius" 
     1297 
     1298        #default_value1 = "0.001" 
     1299        default_value2 = "20" 
     1300 
    12811301        # select two rows 
    1282         row1 = 1 
    1283         row2 = 4 
    12841302        index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex()) 
    12851303        index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex()) 
     
    12981316 
    12991317        # delete one of the constraints 
    1300         self.widget.deleteConstraintOnParameter(param='background') 
     1318        self.widget.deleteConstraintOnParameter(param=param1) 
    13011319 
    13021320        # see that the other constraint is still present 
    1303         cons = self.widget.getConstraintForRow(4) # 4 = radius 
    1304         self.assertEqual(cons.param, "radius") 
    1305         self.assertEqual(cons.value, "20") 
     1321        cons = self.widget.getConstraintForRow(row2) 
     1322        self.assertEqual(cons.param, param2) 
     1323        self.assertEqual(cons.value, default_value2) 
    13061324 
    13071325        # kill the other constraint 
     
    13091327 
    13101328        # see that the other constraint is still present 
    1311         self.assertEqual(self.widget.getConstraintsForModel(), [('radius', None)]) 
     1329        self.assertEqual(self.widget.getConstraintsForModel(), [(param2, None)]) 
    13121330 
    13131331    def testGetConstraintForRow(self): 
     
    13291347        self.widget.cbModel.setCurrentIndex(model_index) 
    13301348 
     1349        row1 = 1 
     1350        row2 = 5 
     1351 
    13311352        # select two rows 
    1332         row1 = 1 
    1333         row2 = 4 
    13341353        index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex()) 
    13351354        index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex()) 
     
    13411360        self.widget.addSimpleConstraint() 
    13421361 
    1343         con_list = [False, True, False, False, True, False] 
     1362        con_list = [False, True, False, False, False, True, False] 
    13441363        new_list = [] 
    13451364        for row in range(self.widget._model_model.rowCount()): 
     
    13591378        self.widget.cbModel.setCurrentIndex(model_index) 
    13601379 
     1380        row1 = 1 
     1381        row2 = 5 
     1382 
    13611383        # select two rows 
    1362         row1 = 1 
    1363         row2 = 4 
    13641384        index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex()) 
    13651385        index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex()) 
     
    13751395        constraint_objects[0].active = False 
    13761396 
    1377         con_list = [False, False, False, False, True, False] 
     1397        con_list = [False, False, False, False, False, True, False] 
    13781398        new_list = [] 
    13791399        for row in range(self.widget._model_model.rowCount()): 
     
    13961416        self.assertEqual(self.widget.getConstraintsForModel(),[]) 
    13971417 
     1418        row1 = 1 
     1419        row2 = 5 
     1420 
     1421        param1 = "background" 
     1422        param2 = "radius" 
     1423 
     1424        default_value1 = "0.001" 
     1425        default_value2 = "20" 
     1426 
    13981427        # select two rows 
    1399         row1 = 1 
    1400         row2 = 4 
    14011428        index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex()) 
    14021429        index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex()) 
     
    14101437        # simple constraints 
    14111438        # self.assertEqual(self.widget.getConstraintsForModel(), [('background', '0.001'), ('radius', '20')]) 
    1412         cons = self.widget.getConstraintForRow(1) # 1 - background 
    1413         self.assertEqual(cons.param, "background") 
    1414         self.assertEqual(cons.value, "0.001") 
    1415         cons = self.widget.getConstraintForRow(4) # 4 = radius 
    1416         self.assertEqual(cons.param, "radius") 
    1417         self.assertEqual(cons.value, "20") 
     1439        cons = self.widget.getConstraintForRow(row1) 
     1440        self.assertEqual(cons.param, param1) 
     1441        self.assertEqual(cons.value, default_value1) 
     1442        cons = self.widget.getConstraintForRow(row2) 
     1443        self.assertEqual(cons.param, param2) 
     1444        self.assertEqual(cons.value, default_value2) 
    14181445 
    14191446        objects = self.widget.getConstraintObjectsForModel() 
    14201447        self.assertEqual(len(objects), 2) 
    1421         self.assertEqual(objects[1].value, '20') 
    1422         self.assertEqual(objects[0].param, 'background') 
     1448        self.assertEqual(objects[1].value, default_value2) 
     1449        self.assertEqual(objects[0].param, param1) 
     1450 
     1451        row = 0 
     1452        param = "scale" 
     1453        func = "5*sld" 
    14231454 
    14241455        # add complex constraint 
    1425         const = Constraint(parent=None, param='scale', func='5*sld') 
    1426         row = 0 
     1456        const = Constraint(parent=None, param=param, func=func) 
    14271457        self.widget.addConstraintToRow(constraint=const, row=row) 
    14281458        #self.assertEqual(self.widget.getConstraintsForModel(),[('scale', '5*sld'), ('background', '0.001'), ('radius', None)]) 
    1429         cons = self.widget.getConstraintForRow(4) # 4 = radius 
    1430         self.assertEqual(cons.param, "radius") 
    1431         self.assertEqual(cons.value, "20") 
     1459        cons = self.widget.getConstraintForRow(row2) 
     1460        self.assertEqual(cons.param, param2) 
     1461        self.assertEqual(cons.value, default_value2) 
    14321462 
    14331463        objects = self.widget.getConstraintObjectsForModel() 
    14341464        self.assertEqual(len(objects), 3) 
    1435         self.assertEqual(objects[0].func, '5*sld') 
     1465        self.assertEqual(objects[0].func, func) 
    14361466 
    14371467    def testReplaceConstraintName(self): 
Note: See TracChangeset for help on using the changeset viewer.