Ignore:
Timestamp:
May 7, 2018 6:47:21 AM (7 years ago)
Author:
Piotr Rozyczko <rozyczko@…>
Branches:
ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc
Children:
42787fb
Parents:
b0ba43e (diff), 80468f6 (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_Pr

Location:
src/sas/qtgui/Perspectives/Inversion
Files:
3 added
9 edited
1 moved

Legend:

Unmodified
Added
Removed

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

    rb0ba43e r3c6ecd9  
    376376        Open the P(r) Inversion help browser 
    377377        """ 
    378         tree_location = "/user/sasgui/perspectives/pr/pr_help.html" 
     378        tree_location = "/user/qtgui/Perspectives/Inversion/pr_help.html" 
    379379 
    380380        # Actual file anchor will depend on the combo box index 

  • src/sas/qtgui/Perspectives/Inversion/media/pr_help.rst

    • Property mode changed from 100644 to 100755

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

    rf4480f0 rb0ba43e  
    88 
    99# global 
    10 import sys 
    11 import os 
    1210import logging 
    1311import numpy as np 
    … …  
    4240        super(DmaxWindow, self).__init__() 
    4341        self.setupUi(self) 
     42        self.parent = parent 
    4443 
    4544        self.setWindowTitle("Dₐₓ Explorer") 
    … …  
    5049 
    5150        self.plot = PlotterWidget(self, self) 
    52         self.hasPlot = None 
     51        self.hasPlot = False 
    5352        self.verticalLayout.insertWidget(0, self.plot) 
    5453 
    5554        # Let's choose the Standard Item Model. 
    5655        self.model = QtGui.QStandardItemModel(self) 
    57         self.mapper = None 
     56        self.mapper = QtWidgets.QDataWidgetMapper(self) 
    5857 
    5958        # Add validators on line edits 
    6059        self.setupValidators() 
    6160 
    62         # # Connect buttons to slots. 
    63         # # Needs to be done early so default values propagate properly. 
     61        # Connect buttons to slots. 
     62        # Needs to be done early so default values propagate properly. 
    6463        self.setupSlots() 
    6564 
    … …  
    8281 
    8382    def setupModel(self): 
     83        self.model.blockSignals(True) 
    8484        self.model.setItem(W.NPTS, QtGui.QStandardItem(str(self.nfunc))) 
     85        self.model.blockSignals(False) 
     86        self.model.blockSignals(True) 
    8587        self.model.setItem(W.DMIN, QtGui.QStandardItem("{:.1f}".format(0.9*self.pr_state.d_max))) 
     88        self.model.blockSignals(False) 
     89        self.model.blockSignals(True) 
    8690        self.model.setItem(W.DMAX, QtGui.QStandardItem("{:.1f}".format(1.1*self.pr_state.d_max))) 
     91        self.model.blockSignals(False) 
     92        self.model.blockSignals(True) 
    8793        self.model.setItem(W.VARIABLE, QtGui.QStandardItem( "χ²/dof")) 
     94        self.model.blockSignals(False) 
    8895 
    8996    def setupMapper(self): 
    90         self.mapper = QtWidgets.QDataWidgetMapper(self) 
    9197        self.mapper.setOrientation(QtCore.Qt.Vertical) 
    9298        self.mapper.setModel(self.model) 
    … …  
    111117        chi2 = [] 
    112118 
    113         xs = np.linspace(float(self.model.item(W.DMIN).text()), 
    114                          float(self.model.item(W.DMAX).text()), 
    115                          float(self.model.item(W.NPTS).text())) 
     119        try: 
     120            dmin = float(self.model.item(W.DMIN).text()) 
     121            dmax = float(self.model.item(W.DMAX).text()) 
     122            npts = float(self.model.item(W.NPTS).text()) 
     123            xs = np.linspace(dmin, dmax, npts) 
     124        except ValueError as e: 
     125            msg = ("An input value is not correctly formatted. Please check {}" 
     126                   .format(e.message)) 
     127            logger.error(msg) 
    116128 
    117129        original = self.pr_state.d_max 
    … …  
    132144                msg = "ExploreDialog: inversion failed " 
    133145                msg += "for D_max=%s\n%s" % (str(x), ex) 
    134                 print(msg) 
    135146                logger.error(msg) 
    136147 
    … …  
    142153            msg = "ExploreDialog: inversion failed " 
    143154            msg += "for D_max=%s\n%s" % (str(x), ex) 
    144             print(msg) 
    145155            logger.error(msg) 
    146156 
    … …  
    151161        if plotter == "χ²/dof": 
    152162            ys = chi2 
    153             y_label = "\chi^2/dof" 
     163            y_label = "\\chi^2/dof" 
    154164            y_unit = "a.u." 
    155165        elif plotter == "I(Q=0)": 
    156166            ys = iq0 
    157167            y_label = "I(q=0)" 
    158             y_unit = "\AA^{-1}" 
     168            y_unit = "\\AA^{-1}" 
    159169        elif plotter == "Rg": 
    160170            ys = rg 
    161171            y_label = "R_g" 
    162             y_unit = "\AA" 
     172            y_unit = "\\AA" 
    163173        elif plotter == "Oscillation parameter": 
    164174            ys = osc 
    … …  
    168178            ys = bck 
    169179            y_label = "Bckg" 
    170             y_unit = "\AA^{-1}" 
     180            y_unit = "\\AA^{-1}" 
    171181        elif plotter == "Positive Fraction": 
    172182            ys = pos 
    … …  
    175185        else: 
    176186            ys = pos_err 
    177             y_label = "P^{+}_{1\sigma}" 
     187            y_label = "P^{+}_{1\\sigma}" 
    178188            y_unit = "a.u." 
    179189 
    … …  
    188198        data._yunit = y_unit 
    189199        self.plot.plot(data=data, marker="-") 
     200 
     201    def closeEvent(self, event): 
     202        """Override close event""" 
     203        self.parent.dmaxWindow = None 
     204        event.accept() 

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

    • Property mode changed from 100755 to 100644
    rfa81e94 r6da860a  
    11import math 
    2 import pylab 
     2import logging 
    33import numpy as np 
    44 
    … …  
    1212GROUP_ID_IQ_DATA = r"$I_{obs}(q)$" 
    1313GROUP_ID_PR_FIT = r"$P_{fit}(r)$" 
     14PR_PLOT_PTS = 51 
     15 
     16logger = logging.getLogger(__name__) 
    1417 
    1518 
    … …  
    1922    No QStandardModelIndex here. 
    2023    """ 
    21  
    22     # TODO: Add way to change this value 
    23     _pr_n_pts = 51 
    2424 
    2525    def __init__(self, data=None): 
    … …  
    3737        """ data setter """ 
    3838        self._data = value 
    39         self.data_is_loaded = True 
     39        self.data_is_loaded = (self._data is not None) 
    4040 
    4141    def isLoadedData(self): 
    … …  
    6363            maxq = pr.q_max 
    6464 
    65         x = pylab.arange(minq, maxq, maxq / 301.0) 
     65        x = np.arange(minq, maxq, maxq / 301.0) 
    6666        y = np.zeros(len(x)) 
    6767        err = np.zeros(len(x)) 
    … …  
    7373            except: 
    7474                err[i] = 1.0 
    75                 print(("Error getting error", value, x[i])) 
     75                logger.log(("Error getting error", value, x[i])) 
    7676 
    7777        new_plot = Data1D(x, y) 
    … …  
    8989        # If we have used slit smearing, plot the smeared I(q) too 
    9090        if pr.slit_width > 0 or pr.slit_height > 0: 
    91             x = pylab.arange(minq, maxq, maxq / 301.0) 
     91            x = np.arange(minq, maxq, maxq / 301.0) 
    9292            y = np.zeros(len(x)) 
    9393            err = np.zeros(len(x)) 
    … …  
    9999                except: 
    100100                    err[i] = 1.0 
    101                     print(("Error getting error", value, x[i])) 
     101                    logger.log(("Error getting error", value, x[i])) 
    102102 
    103103            new_plot = Data1D(x, y) 
    … …  
    113113        return new_plot 
    114114 
    115     def update1DPlot(self, plot, out, pr, q=None): 
    116         """ 
    117         Create a new 1D data instance based on fitting results 
    118         """ 
    119  
    120         qtemp = pr.x 
    121         if q is not None: 
    122             qtemp = q 
    123  
    124         # Make a plot 
    125         maxq = max(qtemp) 
    126  
    127         minq = min(qtemp) 
    128  
    129         # Check for user min/max 
    130         if pr.q_min is not None and maxq >= pr.q_min >= minq: 
    131             minq = pr.q_min 
    132         if pr.q_max is not None and maxq >= pr.q_max >= minq: 
    133             maxq = pr.q_max 
    134  
    135         x = pylab.arange(minq, maxq, maxq / 301.0) 
    136         y = np.zeros(len(x)) 
    137         err = np.zeros(len(x)) 
    138         for i in range(len(x)): 
    139             value = pr.iq(out, x[i]) 
    140             y[i] = value 
    141             try: 
    142                 err[i] = math.sqrt(math.fabs(value)) 
    143             except: 
    144                 err[i] = 1.0 
    145                 print(("Error getting error", value, x[i])) 
    146  
    147         plot.x = x 
    148         plot.y = y 
    149  
    150         # If we have used slit smearing, plot the smeared I(q) too 
    151         if pr.slit_width > 0 or pr.slit_height > 0: 
    152             x = pylab.arange(minq, maxq, maxq / 301.0) 
    153             y = np.zeros(len(x)) 
    154             err = np.zeros(len(x)) 
    155             for i in range(len(x)): 
    156                 value = pr.iq_smeared(pr.out, x[i]) 
    157                 y[i] = value 
    158                 try: 
    159                     err[i] = math.sqrt(math.fabs(value)) 
    160                 except: 
    161                     err[i] = 1.0 
    162                     print(("Error getting error", value, x[i])) 
    163  
    164             plot.x = x 
    165             plot.y = y 
    166  
    167         return plot 
    168  
    169115    def newPRPlot(self, out, pr, cov=None): 
    170116        """ 
    171117        """ 
    172118        # Show P(r) 
    173         x = pylab.arange(0.0, pr.d_max, pr.d_max / self._pr_n_pts) 
     119        x = np.arange(0.0, pr.d_max, pr.d_max / PR_PLOT_PTS) 
    174120 
    175121        y = np.zeros(len(x)) 
    … …  
    193139            y[i] = value 
    194140 
    195         # if self._normalize_output == True: 
    196         #     y = y / total 
    197         #     dy = dy / total 
    198         # elif self._scale_output_unity == True: 
    199         #     y = y / pmax 
    200         #     dy = dy / pmax 
    201  
    202141        if cov2 is None: 
    203142            new_plot = Data1D(x, y) 
    … …  
    209148        new_plot.title = "P(r) fit" 
    210149        new_plot.id = PR_FIT_LABEL 
    211         # Make sure that the plot is linear 
    212         new_plot.xtransform = "x" 
    213         new_plot.ytransform = "y" 
     150        new_plot.scale = "linear" 
    214151        new_plot.group_id = GROUP_ID_PR_FIT 
    215152 
    216153        return new_plot 
    217  
    218     def updatePRPlot(self, plot, out, pr, cov=None): 
    219         x = pylab.arange(0.0, pr.d_max, pr.d_max / self._pr_n_pts) 
    220  
    221         y = np.zeros(len(x)) 
    222         dy = np.zeros(len(x)) 
    223  
    224         total = 0.0 
    225         pmax = 0.0 
    226         cov2 = np.ascontiguousarray(cov) 
    227  
    228         for i in range(len(x)): 
    229             if cov2 is None: 
    230                 value = pr.pr(out, x[i]) 
    231             else: 
    232                 (value, dy[i]) = pr.pr_err(out, cov2, x[i]) 
    233             total += value * pr.d_max / len(x) 
    234  
    235             # keep track of the maximum P(r) value 
    236             if value > pmax: 
    237                 pmax = value 
    238  
    239             y[i] = value 
    240  
    241         # if self._normalize_output == True: 
    242         #     y = y / total 
    243         #     dy = dy / total 
    244         # elif self._scale_output_unity == True: 
    245         #     y = y / pmax 
    246         #     dy = dy / pmax 
    247         plot.x = x 
    248         plot.y = y 
    249  
    250         if cov2 is not None: 
    251             plot.dy = dy 
    252  
    253         return plot 
    254154 
    255155    def computeDataRange(self): 

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

    • Property mode changed from 100755 to 100644

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

    • Property mode changed from 100755 to 100644

  • src/sas/qtgui/Perspectives/Inversion/UI/TabbedInversionUI.ui

    • Property mode changed from 100755 to 100644
    r8f83719f r72ecbdf2  
    317317           <widget class="QLabel" name="label_22"> 
    318318            <property name="text"> 
    319              <string>      </string> 
     319             <string/> 
    320320            </property> 
    321321           </widget> 
    … …  
    754754     </item> 
    755755     <item> 
     756      <widget class="QPushButton" name="stopButton"> 
     757       <property name="text"> 
     758        <string>Stop P(r)</string> 
     759       </property> 
     760      </widget> 
     761     </item> 
     762     <item> 
    756763      <spacer name="horizontalSpacer"> 
    757764       <property name="orientation"> 

  • src/sas/qtgui/Perspectives/Inversion/UI/__init__.py

    • Property mode changed from 100755 to 100644

  • src/sas/qtgui/Perspectives/Inversion/UnitTesting/InversionPerspectiveTest.py

    r50bfab0 r72ecbdf2  
    1 import sys 
     1import time 
    22import unittest 
    3 import logging 
    43from unittest.mock import MagicMock 
    54 
    65from PyQt5 import QtGui, QtWidgets 
    7 from PyQt5.QtTest import QTest 
    8 from PyQt5 import QtCore 
    9  
    10 import sas.qtgui.path_prepare 
     6 
     7from sas.qtgui.Utilities.GuiUtils import * 
    118from sas.qtgui.Perspectives.Inversion.InversionPerspective import InversionWindow 
    12 from sas.sascalc.dataloader.loader import Loader 
     9from sas.qtgui.Perspectives.Inversion.InversionUtils import WIDGETS 
    1310from sas.qtgui.Plotting.PlotterData import Data1D 
    1411 
    15 from sas.qtgui.MainWindow.DataManager import DataManager 
    16 import sas.qtgui.Utilities.LocalConfig 
    1712import sas.qtgui.Utilities.GuiUtils as GuiUtils 
    1813 
    … …  
    2015app = QtWidgets.QApplication(sys.argv) 
    2116 
     17 
     18class dummy_manager(object): 
     19    HELP_DIRECTORY_LOCATION = "html" 
     20    communicate = Communicate() 
     21 
     22    def communicator(self): 
     23        return self.communicate 
     24 
     25 
    2226class InversionTest(unittest.TestCase): 
    23     '''Test the Inversion Interface''' 
     27    """ Test the Inversion Perspective GUI """ 
     28 
    2429    def setUp(self): 
    25         '''Create the InversionWindow''' 
    26         self.widget = InversionWindow(None) 
     30        """ Create the InversionWindow """ 
     31        self.widget = InversionWindow(dummy_manager()) 
     32        self.widget.show() 
     33        self.fakeData1 = GuiUtils.HashableStandardItem("A") 
     34        self.fakeData2 = GuiUtils.HashableStandardItem("B") 
     35        reference_data1 = Data1D(x=[0.1, 0.2], y=[0.0, 0.0], dy=[0.0, 0.0]) 
     36        reference_data1.filename = "Test A" 
     37        reference_data2 = Data1D(x=[0.1, 0.2], y=[0.0, 0.0], dy=[0.0, 0.0]) 
     38        reference_data2.filename = "Test B" 
     39        GuiUtils.updateModelItem(self.fakeData1, reference_data1) 
     40        GuiUtils.updateModelItem(self.fakeData2, reference_data2) 
    2741 
    2842    def tearDown(self): 
    29         '''Destroy the InversionWindow''' 
     43        """ Destroy the InversionWindow """ 
     44        self.widget.setClosable(False) 
    3045        self.widget.close() 
    3146        self.widget = None 
    3247 
    33     def testDefaults(self): 
    34         '''Test the GUI in its default state''' 
     48    def removeAllData(self): 
     49        """ Cleanup method to restore widget to its base state """ 
     50        if len(self.widget.dataList) > 0: 
     51            remove_me = list(self.widget._dataList.keys()) 
     52            self.widget.removeData(remove_me) 
     53 
     54    def baseGUIState(self): 
     55        """ Testing base state of Inversion """ 
     56        # base class information 
    3557        self.assertIsInstance(self.widget, QtWidgets.QWidget) 
    3658        self.assertEqual(self.widget.windowTitle(), "P(r) Inversion Perspective") 
    37         self.assertEqual(self.widget.model.columnCount(), 1) 
    38         self.assertEqual(self.widget.model.rowCount(), 22) 
    39         self.assertFalse(self.widget.calculateAllButton.isEnabled()) 
    40         self.assertFalse(self.widget.calculateThisButton.isEnabled()) 
     59        self.assertFalse(self.widget.isClosable()) 
     60        self.assertFalse(self.widget.isCalculating) 
     61        # mapper 
    4162        self.assertIsInstance(self.widget.mapper, QtWidgets.QDataWidgetMapper) 
    42         # make sure the model is assigned and at least the data is mapped 
    43         self.assertEqual(self.widget.mapper.model(), self.widget.model) 
    4463        self.assertNotEqual(self.widget.mapper.mappedSection(self.widget.dataList), -1) 
    45  
    4664        # validators 
    4765        self.assertIsInstance(self.widget.noOfTermsInput.validator(), QtGui.QIntValidator) 
    … …  
    5270        self.assertIsInstance(self.widget.slitHeightInput.validator(), QtGui.QDoubleValidator) 
    5371        self.assertIsInstance(self.widget.slitWidthInput.validator(), QtGui.QDoubleValidator) 
    54  
    5572        # model 
    5673        self.assertEqual(self.widget.model.rowCount(), 22) 
    57  
    58     def testSetData(self): 
    59         ''' Check if sending data works as expected''' 
    60         # Create dummy data 
    61         item1 = GuiUtils.HashableStandardItem("A") 
    62         item2 = GuiUtils.HashableStandardItem("B") 
    63         reference_data = Data1D(x=[0.1, 0.2], y=[0.0, 0.0], dy=[0.0, 0.0]) 
    64         GuiUtils.updateModelItem(item1, [reference_data]) 
    65         GuiUtils.updateModelItem(item2, [reference_data]) 
    66         self.widget.performEstimate = MagicMock() 
    67         self.widget.setData([item1, item2]) 
    68  
    69         # Test the globals 
    70         self.assertEqual(len(self.widget._data_list), 2) 
    71         self.assertEqual(len(self.widget.data_plot_list), 2) 
    72         self.assertEqual(len(self.widget.pr_plot_list), 2) 
    73         self.assertEqual(self.widget.dataList.count(), 2) 
    74  
    75         # See that the buttons are now enabled 
    76         self.assertTrue(self.widget.calculateAllButton.isEnabled()) 
     74        self.assertEqual(self.widget.model.columnCount(), 1) 
     75        self.assertEqual(self.widget.mapper.model(), self.widget.model) 
     76        # buttons 
     77        self.assertFalse(self.widget.calculateThisButton.isEnabled()) 
     78        self.assertFalse(self.widget.removeButton.isEnabled()) 
     79        self.assertTrue(self.widget.stopButton.isEnabled()) 
     80        self.assertFalse(self.widget.stopButton.isVisible()) 
     81        self.assertFalse(self.widget.regConstantSuggestionButton.isEnabled()) 
     82        self.assertFalse(self.widget.noOfTermsSuggestionButton.isEnabled()) 
     83        self.assertFalse(self.widget.explorerButton.isEnabled()) 
     84        self.assertTrue(self.widget.helpButton.isEnabled()) 
     85        # extra windows and charts 
     86        self.assertIsNone(self.widget.dmaxWindow) 
     87        self.assertIsNone(self.widget.prPlot) 
     88        self.assertIsNone(self.widget.dataPlot) 
     89        # threads 
     90        self.assertIsNone(self.widget.calcThread) 
     91        self.assertIsNone(self.widget.estimationThread) 
     92        self.assertIsNone(self.widget.estimationThreadNT) 
     93 
     94    def baseBatchState(self): 
     95        """ Testing the base batch fitting state """ 
     96        self.assertTrue(self.widget.allowBatch()) 
     97        self.assertFalse(self.widget.isBatch) 
     98        self.assertIsNone(self.widget.batchResultsWindow) 
     99        self.assertFalse(self.widget.calculateAllButton.isEnabled()) 
     100        self.assertEqual(len(self.widget.batchResults), 0) 
     101        self.assertEqual(len(self.widget.batchComplete), 0) 
     102        self.widget.closeBatchResults() 
     103        self.assertIsNone(self.widget.batchResultsWindow) 
     104 
     105    def zeroDataSetState(self): 
     106        """ Testing the base data state of the GUI """ 
     107        # data variables 
     108        self.assertIsNone(self.widget._data) 
     109        self.assertEqual(len(self.widget._dataList), 0) 
     110        self.assertEqual(self.widget.nTermsSuggested, 10) 
     111        # inputs 
     112        self.assertEqual(len(self.widget.dataList), 0) 
     113        self.assertEqual(self.widget.backgroundInput.text(), "0.0") 
     114        self.assertEqual(self.widget.minQInput.text(), "") 
     115        self.assertEqual(self.widget.maxQInput.text(), "") 
     116        self.assertEqual(self.widget.regularizationConstantInput.text(), "0.0001") 
     117        self.assertEqual(self.widget.noOfTermsInput.text(), "10") 
     118        self.assertEqual(self.widget.maxDistanceInput.text(), "140.0") 
     119 
     120    def oneDataSetState(self): 
     121        """ Testing the base data state of the GUI """ 
     122        # Test the globals after first sent 
     123        self.assertEqual(len(self.widget._dataList), 1) 
     124        self.assertEqual(self.widget.dataList.count(), 1) 
     125        # See that the buttons are now enabled properly 
     126        self.widget.enableButtons() 
     127        self.assertFalse(self.widget.calculateAllButton.isEnabled()) 
    77128        self.assertTrue(self.widget.calculateThisButton.isEnabled()) 
    78129        self.assertTrue(self.widget.removeButton.isEnabled()) 
    79130        self.assertTrue(self.widget.explorerButton.isEnabled()) 
    80131 
    81     def notestRemoveData(self): 
    82         ''' Test data removal from widget ''' 
    83         # Create dummy data 
    84         item1 = GuiUtils.HashableStandardItem("A") 
    85         item2 = GuiUtils.HashableStandardItem("B") 
    86         reference_data1 = Data1D(x=[0.1, 0.2], y=[0.0, 0.0], dy=[0.0, 0.0]) 
    87         reference_data2 = Data1D(x=[0.1, 0.2], y=[0.0, 0.0], dy=[0.0, 0.0]) 
    88         GuiUtils.updateModelItem(item1, [reference_data1]) 
    89         GuiUtils.updateModelItem(item2, [reference_data2]) 
    90         self.widget.performEstimate = MagicMock() 
    91         self.widget.setData([item1, item2]) 
    92  
     132    def twoDataSetState(self): 
     133        """ Testing the base data state of the GUI """ 
     134        # Test the globals after first sent 
     135        self.assertEqual(len(self.widget._dataList), 2) 
     136        self.assertEqual(self.widget.dataList.count(), 2) 
     137        # See that the buttons are now enabled properly 
     138        self.widget.enableButtons() 
     139        self.assertTrue(self.widget.calculateThisButton.isEnabled()) 
     140        self.assertTrue(self.widget.calculateAllButton.isEnabled()) 
     141        self.assertTrue(self.widget.removeButton.isEnabled()) 
     142        self.assertTrue(self.widget.explorerButton.isEnabled()) 
     143 
     144    def testDefaults(self): 
     145        """ Test the GUI in its default state """ 
     146        self.baseGUIState() 
     147        self.zeroDataSetState() 
     148        self.baseBatchState() 
     149        self.removeAllData() 
     150 
     151    def testAllowBatch(self): 
     152        """ Batch P(r) Tests """ 
     153        self.baseBatchState() 
     154        self.widget.setData([self.fakeData1]) 
     155        self.oneDataSetState() 
     156        self.widget.setData([self.fakeData2]) 
     157        self.twoDataSetState() 
     158        self.widget.calculateAllButton.click() 
     159        self.assertTrue(self.widget.isCalculating) 
     160        self.assertTrue(self.widget.isBatch) 
     161        self.assertTrue(self.widget.stopButton.isVisible()) 
     162        self.assertTrue(self.widget.stopButton.isEnabled()) 
     163        self.assertIsNotNone(self.widget.batchResultsWindow) 
     164        self.assertTrue(self.widget.batchResultsWindow.cmdHelp.isEnabled()) 
     165        self.assertEqual(self.widget.batchResultsWindow.tblParams.columnCount(), 9) 
     166        self.assertEqual(self.widget.batchResultsWindow.tblParams.rowCount(), 2) 
     167        # Test stop button 
     168        self.widget.stopButton.click() 
     169        self.assertTrue(self.widget.batchResultsWindow.isVisible()) 
     170        self.assertFalse(self.widget.stopButton.isVisible()) 
     171        self.assertTrue(self.widget.stopButton.isEnabled()) 
     172        self.assertFalse(self.widget.isBatch) 
     173        self.assertFalse(self.widget.isCalculating) 
     174        self.widget.batchResultsWindow.close() 
     175        self.assertIsNone(self.widget.batchResultsWindow) 
     176        # Last test 
     177        self.removeAllData() 
     178        self.baseBatchState() 
     179 
     180    def testSetData(self): 
     181        """ Check if sending data works as expected """ 
     182        self.zeroDataSetState() 
     183        self.widget.setData([self.fakeData1]) 
     184        self.oneDataSetState() 
     185        self.widget.setData([self.fakeData1]) 
     186        self.oneDataSetState() 
     187        self.widget.setData([self.fakeData2]) 
     188        self.twoDataSetState() 
     189        self.removeAllData() 
     190        self.zeroDataSetState() 
     191        self.removeAllData() 
     192 
     193    def testRemoveData(self): 
     194        """ Test data removal from widget """ 
     195        self.widget.setData([self.fakeData1, self.fakeData2]) 
     196        self.twoDataSetState() 
    93197        # Remove data 0 
    94198        self.widget.removeData() 
    95  
    96         # Test the globals 
    97         self.assertEqual(len(self.widget._data_list), 1) 
    98         self.assertEqual(len(self.widget.data_plot_list), 1) 
    99         self.assertEqual(len(self.widget.pr_plot_list), 1) 
    100         self.assertEqual(self.widget.dataList.count(), 1) 
    101  
    102  
    103     def testAllowBatch(self): 
    104         ''' Batch is allowed for this perspective''' 
    105         self.assertTrue(self.widget.allowBatch()) 
    106  
    107     def notestModelChanged(self): 
    108         ''' test the model update ''' 
    109         # unfinished functionality 
    110         pass 
    111  
    112     def notestHelp(self): 
    113         ''' test help widget show ''' 
    114         # unfinished functionality 
    115         pass 
    116  
    117     def testOpenExplorerWindow(self): 
    118         ''' open Dx window ''' 
    119         self.widget.openExplorerWindow() 
    120         self.assertTrue(self.widget.dmaxWindow.isVisible()) 
     199        self.oneDataSetState() 
     200        self.removeAllData() 
     201 
     202    def testClose(self): 
     203        """ Test methods related to closing the window """ 
     204        self.assertFalse(self.widget.isClosable()) 
     205        self.widget.close() 
     206        self.assertTrue(self.widget.isMinimized()) 
     207        self.assertIsNone(self.widget.dmaxWindow) 
     208        self.assertIsNone(self.widget.batchResultsWindow) 
     209        self.widget.setClosable(False) 
     210        self.assertFalse(self.widget.isClosable()) 
     211        self.widget.close() 
     212        self.assertTrue(self.widget.isMinimized()) 
     213        self.widget.setClosable(True) 
     214        self.assertTrue(self.widget.isClosable()) 
     215        self.widget.setClosable() 
     216        self.assertTrue(self.widget.isClosable()) 
     217        self.removeAllData() 
    121218 
    122219    def testGetNFunc(self): 
    123         ''' test nfunc getter ''' 
     220        """ test nfunc getter """ 
    124221        # Float 
    125222        self.widget.noOfTermsInput.setText("10.0") 
    … …  
    132229            self.widget.noOfTermsInput.setText("") 
    133230            n = self.widget.getNFunc() 
    134             self.assertEqual(cm.output, ['ERROR:root:Incorrect number of terms specified: ']) 
     231            self.assertEqual(cm.output, ['ERROR:sas.qtgui.Perspectives.Inversion.InversionPerspective:Incorrect number of terms specified: ']) 
    135232        self.assertEqual(self.widget.getNFunc(), 10) 
    136233        # string 
    … …  
    138235            self.widget.noOfTermsInput.setText("Nordvest Pizza") 
    139236            n = self.widget.getNFunc() 
    140             self.assertEqual(cm.output, ['ERROR:root:Incorrect number of terms specified: Nordvest Pizza']) 
     237            self.assertEqual(cm.output, ['ERROR:sas.qtgui.Perspectives.Inversion.InversionPerspective:Incorrect number of terms specified: Nordvest Pizza']) 
    141238        self.assertEqual(self.widget.getNFunc(), 10) 
     239        self.removeAllData() 
    142240 
    143241    def testSetCurrentData(self): 
    144         ''' test current data setter ''' 
    145         # Create dummy data 
    146         item1 = GuiUtils.HashableStandardItem("A") 
    147         item2 = GuiUtils.HashableStandardItem("B") 
    148         reference_data1 = Data1D(x=[0.1, 0.2], y=[0.0, 0.0], dy=[0.0, 0.0]) 
    149         reference_data2 = Data1D(x=[0.1, 0.2], y=[0.0, 0.0], dy=[0.0, 0.0]) 
    150         GuiUtils.updateModelItem(item1, [reference_data1]) 
    151         GuiUtils.updateModelItem(item2, [reference_data2]) 
    152         self.widget.performEstimate = MagicMock() 
    153         self.widget.setData([item1, item2]) 
     242        """ test current data setter """ 
     243        self.widget.setData([self.fakeData1, self.fakeData2]) 
    154244 
    155245        # Check that the current data is reference2 
    156         self.assertEqual(self.widget._data, item2) 
    157  
     246        self.assertEqual(self.widget._data, self.fakeData2) 
    158247        # Set the ref to none 
    159248        self.widget.setCurrentData(None) 
    160         self.assertEqual(self.widget._data, item2) 
    161  
     249        self.assertEqual(self.widget._data, self.fakeData2) 
    162250        # Set the ref to wrong type 
    163251        with self.assertRaises(AttributeError): 
    164252            self.widget.setCurrentData("Afandi Kebab") 
    165  
    166         # Set the reference to ref2 
    167         self.widget.setCurrentData(item1) 
    168         self.assertEqual(self.widget._data, item1) 
     253        # Set the reference to ref1 
     254        self.widget.setCurrentData(self.fakeData1) 
     255        self.assertEqual(self.widget._data, self.fakeData1) 
     256        self.removeAllData() 
     257 
     258    def testModelChanged(self): 
     259        """ Test setting the input and the model and vice-versa """ 
     260        # Initial values 
     261        self.assertEqual(self.widget._calculator.get_dmax(), 140.0) 
     262        self.assertEqual(self.widget._calculator.get_qmax(), -1.0) 
     263        self.assertEqual(self.widget._calculator.get_qmin(), -1.0) 
     264        self.assertEqual(self.widget._calculator.slit_height, 0.0) 
     265        self.assertEqual(self.widget._calculator.slit_width, 0.0) 
     266        self.assertEqual(self.widget._calculator.alpha, 0.0001) 
     267        # Set new values 
     268        self.widget.maxDistanceInput.setText("1.0") 
     269        self.widget.maxQInput.setText("3.0") 
     270        self.widget.minQInput.setText("5.0") 
     271        self.widget.slitHeightInput.setText("7.0") 
     272        self.widget.slitWidthInput.setText("9.0") 
     273        self.widget.regularizationConstantInput.setText("11.0") 
     274        # Check new values 
     275        self.assertEqual(self.widget._calculator.get_dmax(), 1.0) 
     276        self.assertEqual(self.widget._calculator.get_qmax(), 3.0) 
     277        self.assertEqual(self.widget._calculator.get_qmin(), 5.0) 
     278        self.assertEqual(self.widget._calculator.slit_height, 7.0) 
     279        self.assertEqual(self.widget._calculator.slit_width, 9.0) 
     280        self.assertEqual(self.widget._calculator.alpha, 11.0) 
     281        # Change model directly 
     282        self.widget.model.setItem(WIDGETS.W_MAX_DIST, QtGui.QStandardItem("2.0")) 
     283        self.widget.model.setItem(WIDGETS.W_QMIN, QtGui.QStandardItem("4.0")) 
     284        self.widget.model.setItem(WIDGETS.W_QMAX, QtGui.QStandardItem("6.0")) 
     285        self.widget.model.setItem(WIDGETS.W_SLIT_HEIGHT, QtGui.QStandardItem("8.0")) 
     286        self.widget.model.setItem(WIDGETS.W_SLIT_WIDTH, QtGui.QStandardItem("10.0")) 
     287        self.widget.model.setItem(WIDGETS.W_REGULARIZATION, QtGui.QStandardItem("12.0")) 
     288        # Check values 
     289        self.assertEqual(self.widget._calculator.get_dmax(), 2.0) 
     290        self.assertEqual(self.widget._calculator.get_qmin(), 4.0) 
     291        self.assertEqual(self.widget._calculator.get_qmax(), 6.0) 
     292        self.assertEqual(self.widget._calculator.slit_height, 8.0) 
     293        self.assertEqual(self.widget._calculator.slit_width, 10.0) 
     294        self.assertEqual(self.widget._calculator.alpha, 12.0) 
     295        self.removeAllData() 
     296 
     297    def testOpenExplorerWindow(self): 
     298        """ open Dx window """ 
     299        self.assertIsNone(self.widget.dmaxWindow) 
     300        self.assertFalse(self.widget.explorerButton.isEnabled()) 
     301        self.widget.openExplorerWindow() 
     302        self.assertIsNotNone(self.widget.dmaxWindow) 
     303        self.assertTrue(self.widget.dmaxWindow.isVisible()) 
     304        self.assertTrue(self.widget.dmaxWindow.windowTitle() == "Dₐₓ Explorer") 
     305 
    169306 
    170307if __name__ == "__main__": 

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

    • Property mode changed from 100755 to 100644
Note: See TracChangeset for help on using the changeset viewer.