Changeset 8289ae3 in sasview for src/sas/qtgui/Perspectives

Timestamp:

Mar 23, 2018 8:24:10 AM (7 years ago)

Author:

krzywon

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:

ba4e3ba

Parents:

304e42f (diff), 8ac3551 (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

Files:

• Fitting/ConstraintWidget.py (modified) (4 diffs)
• Fitting/FittingPerspective.py (modified) (4 diffs)
• Fitting/FittingWidget.py (modified) (22 diffs)
• Fitting/ModelUtilities.py (modified) (3 diffs, 1 prop)
• Fitting/MultiConstraint.py (modified) (1 diff)
• Fitting/UI/FittingWidgetUI.ui (modified) (1 diff)
• Fitting/UnitTesting/ConstraintWidgetTest.py (modified) (3 diffs, 1 prop)
• Inversion/InversionLogic.py (modified) (1 prop)
• Inversion/InversionPerspective.py (modified) (14 diffs)
• Inversion/InversionUtils.py (modified) (1 prop)
• Inversion/Thread.py (modified) (1 prop)
• Inversion/UI/TabbedInversionUI.ui (modified) (1 prop)
• Inversion/UI/__init__.py (modified) (1 prop)
• Inversion/UI/convert_all.bat (added)
• Inversion/UI/convert_all.sh (added)
• Inversion/UI/convert_ui.sh (added)
• Inversion/UI/dmax.ui (added)
• Inversion/__init__.py (modified) (1 prop)
• Inversion/dmax.py (added)
• __init__.py (modified) (1 prop)

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

@@ -111 +111 @@
 
         # Disconnect all local slots
-        tab_object.disconnect()
+        #tab_object.disconnect()
 
         # Reconnect tab signals to local slots
@@ -171 +171 @@
                     # No such tab!
                     return
-                sim_fitter_list, fitter_id = tab_object.prepareFitters(fitter=sim_fitter_list[0], fit_id=fitter_id)
+                sim_fitter_list, fitter_id = \
+                    tab_object.prepareFitters(fitter=sim_fitter_list[0], fit_id=fitter_id)
                 page_ids.append([tab_object.page_id])
         except ValueError:
@@ -178 +179 @@
                             "Not all tabs chosen for fitting have parameters selected for fitting."
             QtWidgets.QMessageBox.warning(self,
-                                           'Warning',
-                                            no_params_msg,
-                                            QtWidgets.QMessageBox.Ok)
+                                          'Warning',
+                                           no_params_msg,
+                                           QtWidgets.QMessageBox.Ok)
 
             return
@@ -674 +675 @@
 
         constraint.func = constraint_text
+        # param1 is the parameter we're constraining
         constraint.param = param1
+
         # Find the right tab
         constrained_tab = self.getObjectByName(model1)

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

@@ -8 +8 @@
 from bumps import fitters
 
+import sas.qtgui.Utilities.LocalConfig as LocalConfig
 import sas.qtgui.Utilities.ObjectLibrary as ObjectLibrary
 
@@ -116 +117 @@
         tab     = FittingWidget(parent=self.parent, data=data, tab_id=self.maxIndex+1)
         tab.is_batch_fitting = is_batch
+
         # Add this tab to the object library so it can be retrieved by scripting/jupyter
         tab_name = self.getTabName(is_batch=is_batch)
@@ -123 +125 @@
             self.updateFitDict(data, tab_name)
         self.maxIndex += 1
-        self.addTab(tab, tab_name)
+        icon = QtGui.QIcon()
+        if is_batch:
+            icon.addPixmap(QtGui.QPixmap("src/sas/qtgui/images/icons/layers.svg"))
+        self.addTab(tab, icon, tab_name)
+        # Show the new tab
+        self.setCurrentIndex(self.maxIndex-1)
+        # Notify listeners
         self.tabsModifiedSignal.emit()
 
@@ -140 +148 @@
         ObjectLibrary.addObject(tab_name, tab)
         self.tabs.append(tab)
-        self.addTab(tab, tab_name)
+        icon = QtGui.QIcon()
+        icon.addPixmap(QtGui.QPixmap("src/sas/qtgui/images/icons/link.svg"))
+        self.addTab(tab, icon, tab_name)
+
+        # This will be the last tab, so set the index accordingly
+        self.setCurrentIndex(self.count()-1)
 
     def updateFitDict(self, item_key, tab_name):

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

@@ -24 +24 @@
 import sas.qtgui.Utilities.GuiUtils as GuiUtils
 import sas.qtgui.Utilities.LocalConfig as LocalConfig
+from sas.qtgui.Utilities.GridPanel import BatchOutputPanel
 from sas.qtgui.Utilities.CategoryInstaller import CategoryInstaller
 from sas.qtgui.Plotting.PlotterData import Data1D
@@ -36 +37 @@
 from sas.qtgui.Perspectives.Fitting.FittingLogic import FittingLogic
 from sas.qtgui.Perspectives.Fitting import FittingUtilities
+from sas.qtgui.Perspectives.Fitting import ModelUtilities
 from sas.qtgui.Perspectives.Fitting.SmearingWidget import SmearingWidget
 from sas.qtgui.Perspectives.Fitting.OptionsWidget import OptionsWidget
@@ -50 +52 @@
 CATEGORY_DEFAULT = "Choose category..."
 CATEGORY_STRUCTURE = "Structure Factor"
+CATEGORY_CUSTOM = "Plugin Models"
 STRUCTURE_DEFAULT = "None"
 
@@ -83 +86 @@
     constraintAddedSignal = QtCore.pyqtSignal(list)
     newModelSignal = QtCore.pyqtSignal()
+    fittingFinishedSignal = QtCore.pyqtSignal(tuple)
+    batchFittingFinishedSignal = QtCore.pyqtSignal(tuple)
+
     def __init__(self, parent=None, data=None, tab_id=1):
 
@@ -211 +217 @@
         self.page_stack = []
         self.all_data = []
+        # custom plugin models
+        # {model.name:model}
+        self.custom_models = self.customModels()
         # Polydisp widget table default index for function combobox
         self.orig_poly_index = 3
@@ -415 +424 @@
             self.onSelectModel()
 
+    @classmethod
+    def customModels(cls):
+        """ Reads in file names in the custom plugin directory """
+        return ModelUtilities._find_models()
+
     def initializeControls(self):
         """
@@ -465 +479 @@
         self._poly_model.itemChanged.connect(self.onPolyModelChange)
         self._magnet_model.itemChanged.connect(self.onMagnetModelChange)
+        self.lstParams.selectionModel().selectionChanged.connect(self.onSelectionChanged)
+
+        # Local signals
+        self.batchFittingFinishedSignal.connect(self.batchFitComplete)
+        self.fittingFinishedSignal.connect(self.fitComplete)
 
         # Signals from separate tabs asking for replot
         self.options_widget.plot_signal.connect(self.onOptionsUpdate)
+
+        # Signals from other widgets
+        self.communicate.customModelDirectoryChanged.connect(self.onCustomModelChange)
 
     def modelName(self):
@@ -576 +598 @@
         # widget.params[0] is the parameter we're constraining
         constraint.param = mc_widget.params[0]
-        # Function should have the model name preamble
+        # parameter should have the model name preamble
         model_name = self.kernel_module.name
-        constraint.func = model_name + "." + c_text
+        # param_used is the parameter we're using in constraining function
+        param_used = mc_widget.params[1]
+        # Replace param_used with model_name.param_used
+        updated_param_used = model_name + "." + param_used
+        new_func = c_text.replace(param_used, updated_param_used)
+        constraint.func = new_func
         # Which row is the constrained parameter in?
         row = self.getRowFromName(constraint.param)
@@ -677 +704 @@
         Delete constraints from selected parameters.
         """
-        self.deleteConstraintOnParameter(param=None)
+        params =  [s.data() for s in self.lstParams.selectionModel().selectedRows()
+                   if self.isCheckable(s.row())]
+        for param in params:
+            self.deleteConstraintOnParameter(param=param)
 
     def deleteConstraintOnParameter(self, param=None):
@@ -686 +716 @@
         max_col = self.lstParams.itemDelegate().param_max
         for row in range(self._model_model.rowCount()):
+            if not self.rowHasConstraint(row):
+                continue
             # Get the Constraint object from of the model item
             item = self._model_model.item(row, 1)
-            if not item.hasChildren():
-                continue
-            constraint = item.child(0).data()
+            constraint = self.getConstraintForRow(row)
             if constraint is None:
                 continue
@@ -816 +846 @@
         return constraints
 
+    def getConstraintsForFitting(self):
+        """
+        Return a list of constraints in format ready for use in fiting
+        """
+        # Get constraints
+        constraints = self.getComplexConstraintsForModel()
+        # See if there are any constraints across models
+        multi_constraints = [cons for cons in constraints if self.isConstraintMultimodel(cons[1])]
+
+        if multi_constraints:
+            # Let users choose what to do
+            msg = "The current fit contains constraints relying on other fit pages.\n"
+            msg += "Parameters with those constraints are:\n" +\
+                '\n'.join([cons[0] for cons in multi_constraints])
+            msg += "\n\nWould you like to remove these constraints or cancel fitting?"
+            msgbox = QtWidgets.QMessageBox(self)
+            msgbox.setIcon(QtWidgets.QMessageBox.Warning)
+            msgbox.setText(msg)
+            msgbox.setWindowTitle("Existing Constraints")
+            # custom buttons
+            button_remove = QtWidgets.QPushButton("Remove")
+            msgbox.addButton(button_remove, QtWidgets.QMessageBox.YesRole)
+            button_cancel = QtWidgets.QPushButton("Cancel")
+            msgbox.addButton(button_cancel, QtWidgets.QMessageBox.RejectRole)
+            retval = msgbox.exec_()
+            if retval == QtWidgets.QMessageBox.RejectRole:
+                # cancel fit
+                raise ValueError("Fitting cancelled")
+            else:
+                # remove constraint
+                for cons in multi_constraints:
+                    self.deleteConstraintOnParameter(param=cons[0])
+                # re-read the constraints
+                constraints = self.getComplexConstraintsForModel()
+
+        return constraints
+
     def showModelDescription(self):
         """
@@ -874 +941 @@
         self.respondToModelStructure(model=model, structure_factor=structure)
 
+    def onCustomModelChange(self):
+        """
+        Reload the custom model combobox
+        """
+        self.custom_models = self.customModels()
+        self.readCustomCategoryInfo()
+        # See if we need to update the combo in-place
+        if self.cbCategory.currentText() != CATEGORY_CUSTOM: return
+
+        current_text = self.cbModel.currentText()
+        self.cbModel.blockSignals(True)
+        self.cbModel.clear()
+        self.cbModel.blockSignals(False)
+        self.enableModelCombo()
+        self.disableStructureCombo()
+        # Retrieve the list of models
+        model_list = self.master_category_dict[CATEGORY_CUSTOM]
+        # Populate the models combobox
+        self.cbModel.addItems(sorted([model for (model, _) in model_list]))
+        new_index = self.cbModel.findText(current_text)
+        if new_index != -1:
+            self.cbModel.setCurrentIndex(self.cbModel.findText(current_text))
+
+    def onSelectionChanged(self):
+        """
+        React to parameter selection
+        """
+        rows = self.lstParams.selectionModel().selectedRows()
+        # Clean previous messages
+        self.communicate.statusBarUpdateSignal.emit("")
+        if len(rows) == 1:
+            # Show constraint, if present
+            row = rows[0].row()
+            if self.rowHasConstraint(row):
+                func = self.getConstraintForRow(row).func
+                if func is not None:
+                    self.communicate.statusBarUpdateSignal.emit("Active constrain: "+func)
+
     def replaceConstraintName(self, old_name, new_name=""):
         """
@@ -886 +991 @@
                     new_func = func.replace(old_name, new_name)
                     self._model_model.item(row, 1).child(0).data().func = new_func
+
+    def isConstraintMultimodel(self, constraint):
+        """
+        Check if the constraint function text contains current model name
+        """
+        current_model_name = self.kernel_module.name
+        if current_model_name in constraint:
+            return False
+        else:
+            return True
 
     def updateData(self):
@@ -1105 +1220 @@
         except ValueError as ex:
             # This should not happen! GUI explicitly forbids this situation
-            self.communicate.statusBarUpdateSignal.emit('Fitting attempt without parameters.')
+            self.communicate.statusBarUpdateSignal.emit(str(ex))
             return
 
         # Create the fitting thread, based on the fitter
-        completefn = self.batchFitComplete if self.is_batch_fitting else self.fitComplete
+        completefn = self.batchFittingCompleted if self.is_batch_fitting else self.fittingCompleted
 
         calc_fit = FitThread(handler=handler,
@@ -1146 +1261 @@
         pass
 
+    def batchFittingCompleted(self, result):
+        """
+        Send the finish message from calculate threads to main thread
+        """
+        self.batchFittingFinishedSignal.emit(result)
+
     def batchFitComplete(self, result):
         """
@@ -1152 +1273 @@
         #re-enable the Fit button
         self.setFittingStopped()
+        # Show the grid panel
+        self.grid_window = BatchOutputPanel(parent=self, output_data=result[0])
+        self.grid_window.show()
+
+    def fittingCompleted(self, result):
+        """
+        Send the finish message from calculate threads to main thread
+        """
+        self.fittingFinishedSignal.emit(result)
 
     def fitComplete(self, result):
@@ -1162 +1292 @@
 
         if result is None:
-            msg = "Fitting failed after: %s s.\n" % GuiUtils.formatNumber(elapsed)
+            msg = "Fitting failed."
             self.communicate.statusBarUpdateSignal.emit(msg)
             return
@@ -1228 +1358 @@
         smearing, accuracy, smearing_min, smearing_max = self.smearing_widget.state()
 
+        # Get the constraints.
         constraints = self.getComplexConstraintsForModel()
+        if fitter is None:
+            # For single fits - check for inter-model constraints
+            constraints = self.getConstraintsForFitting()
+
         smearer = None
         handler = None
@@ -1242 +1377 @@
                              constraints=constraints)
             except ValueError as ex:
-                logging.error("Setting model parameters failed with: %s" % ex)
-                return
+                raise ValueError("Setting model parameters failed with: %s" % ex)
 
             qmin, qmax, _ = self.logic.computeRangeFromData(data)
@@ -1409 +1543 @@
         if not dict:
             return
-        if self._model_model.rowCount() == 0:
+        if self._magnet_model.rowCount() == 0:
             return
 
@@ -1555 +1689 @@
             self.models[model.name] = model
 
+        self.readCustomCategoryInfo()
+
+    def readCustomCategoryInfo(self):
+        """
+        Reads the custom model category
+        """
+        #Looking for plugins
+        self.plugins = list(self.custom_models.values())
+        plugin_list = []
+        for name, plug in self.custom_models.items():
+            self.models[name] = plug
+            plugin_list.append([name, True])
+        self.master_category_dict[CATEGORY_CUSTOM] = plugin_list
+
     def regenerateModelDict(self):
         """
@@ -1662 +1810 @@
         Setting model parameters into QStandardItemModel based on selected _model_
         """
-        kernel_module = generate.load_kernel_module(model_name)
+        name = model_name
+        if self.cbCategory.currentText() == CATEGORY_CUSTOM:
+            # custom kernel load requires full path
+            name = os.path.join(ModelUtilities.find_plugins_dir(), model_name+".py")
+        kernel_module = generate.load_kernel_module(name)
         self.model_parameters = modelinfo.make_parameter_table(getattr(kernel_module, 'parameters', []))
 

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

@@ -179 +179 @@
     plugins = {}
     for filename in os.listdir(directory):
+
         name, ext = os.path.splitext(filename)
         if ext == '.py' and not name == '__init__':
@@ -184 +185 @@
             try:
                 model = load_custom_model(path)
-                model.name = PLUGIN_NAME_BASE + model.name
+                #model.name = PLUGIN_NAME_BASE + model.name
                 plugins[model.name] = model
             except Exception:
@@ -415 +416 @@
     implement model
     """
-    __modelmanager = ModelManagerBase()
-    cat_model_list = [__modelmanager.model_dictionary[model_name] for model_name \
-                      in list(__modelmanager.model_dictionary.keys()) \
-                      if model_name not in list(__modelmanager.stored_plugins.keys())]
-
-    CategoryInstaller.check_install(model_list=cat_model_list)
+    def __init__(self):
+        self.__modelmanager = ModelManagerBase()
+        self.cat_model_list = [self.__modelmanager.model_dictionary[model_name] for model_name \
+                          in list(self.__modelmanager.model_dictionary.keys()) \
+                          if model_name not in list(self.__modelmanager.stored_plugins.keys())]
+
+        CategoryInstaller.check_install(model_list=self.cat_model_list)
+
     def findModels(self):
         return self.__modelmanager.findModels()

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

@@ -114 +114 @@
 
         # 3. parameter name should be a separate word, but can have "()[]*+-/ " around
-        valid_neighbours = "()[]*+-/ "
-        start_loc = parameter_string_start -1
-        end_loc = parameter_string_end
-        if not any([constraint_text[start_loc] == ch for ch in valid_neighbours]):
-            return False
-        if end_loc < len(constraint_text):
-            if not any([constraint_text[end_loc] == ch for ch in valid_neighbours]):
-                return False
+        #valid_neighbours = "()[]*+-/ "
+        #start_loc = parameter_string_start -1
+        #end_loc = parameter_string_end
+        #if not any([constraint_text[start_loc] == ch for ch in valid_neighbours]):
+        #    return False
+        #if end_loc < len(constraint_text):
+        #    if not any([constraint_text[end_loc] == ch for ch in valid_neighbours]):
+        #        return False
 
         # 4. replace parameter name with "1" and try to evaluate the expression

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

@@ -7 +7 @@
     <x>0</x>
     <y>0</y>
-    <width>568</width>
+    <width>680</width>
     <height>605</height>
    </rect>

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

@@ -22 +22 @@
 if not QtWidgets.QApplication.instance():
     app = QtWidgets.QApplication(sys.argv)
-#app = QtWidgets.QApplication(sys.argv)
 
 class ConstraintWidgetTest(unittest.TestCase):
@@ -71 +70 @@
         # click on "batch"
         QTest.mouseClick(self.widget.btnBatch, QtCore.Qt.LeftButton)
-        app.processEvents()
+        QtWidgets.QApplication.processEvents()
         # See what the current type is now
         self.assertEqual(self.widget.currentType, "BatchPage")
@@ -78 +77 @@
         # Go back to single fit
         QTest.mouseClick(self.widget.btnSingle, QtCore.Qt.LeftButton)
-        app.processEvents()
+        QtWidgets.QApplication.processEvents()
         # See what the current type is now
         self.assertEqual(self.widget.currentType, "FitPage")

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

@@ -29 +29 @@
 BACKGROUND_INPUT = 0.0
 MAX_DIST = 140.0
-
-# TODO: Modify plot references, don't just send new
+DICT_KEYS = ["Calculator", "PrPlot", "DataPlot", "DMaxWindow",
+             "Logic", "NFuncEst"]
+
+
+# TODO: Remove not working
+# TODO: Explore window not working
 # TODO: Update help with batch capabilities
 # TODO: Method to export results in some meaningful way
@@ -50 +54 @@
 
         self._manager = parent
-        self._model_item = QtGui.QStandardItem()
         self.communicate = GuiUtils.Communicate()
 
         self.logic = InversionLogic()
-
-        # Reference to Dmax window
-        self.dmaxWindow = None
 
         # The window should not close
         self._allow_close = False
 
+        # Visible data set items
         # current QStandardItem showing on the panel
         self._data = None
         # current Data1D as referenced by self._data
         self._data_set = None
-
-        # p(r) calculator
+        # Reference to Dmax window for self._data
+        self.dmaxWindow = None
+        # p(r) calculator for self._data
         self._calculator = Invertor()
-        self._last_calculator = None
+        # Default to background estimate
+        self._calculator.set_est_bck(True)
+        # plots of self._data
+        self.pr_plot = None
+        self.data_plot = None
+        # suggested nTerms
+        self.nTermsSuggested = NUMBER_OF_TERMS
+
+        # Calculation threads used by all data items
         self.calc_thread = None
         self.estimation_thread = None
 
-        # Current data object in view
-        self._data_index = 0
-        # list mapping data to p(r) calculation
+        # Mapping for all data items
+        # list mapping data to all parameters
         self._data_list = {}
         if not isinstance(data, list):
@@ -80 +89 @@
         if data is not None:
             for datum in data_list:
-                self._data_list[datum] = self._calculator.clone()
-
-        # dict of models for quick update after calculation
-        # {item:model}
-        self._models = {}
-
-        self.calculateAllButton.setEnabled(False)
-        self.calculateThisButton.setEnabled(False)
-
-        # plots for current data
-        self.pr_plot = None
-        self.data_plot = None
-        # plot references for all data in perspective
-        self.pr_plot_list = {}
-        self.data_plot_list = {}
+                self.updateDataList(datum)
+
+        self.enableButtons()
 
         self.model = QtGui.QStandardItemModel(self)
@@ -158 +155 @@
 
         self.backgroundInput.editingFinished.connect(
-            lambda: self._calculator.set_est_bck(int(is_float(self.backgroundInput.text()))))
+            lambda: self._calculator.set_background(is_float(self.backgroundInput.text())))
         self.minQInput.editingFinished.connect(
             lambda: self._calculator.set_qmin(is_float(self.minQInput.text())))
@@ -308 +305 @@
 
     def displayChange(self):
+        """Switch to another item in the data list"""
         ref_item = self.dataList.itemData(self.dataList.currentIndex())
-        self._model_item = ref_item
+        self.updateDataList(ref_item)
         self.setCurrentData(ref_item)
-        self.setCurrentModel(ref_item)
-
-    def removeData(self):
-        """Remove the existing data reference from the P(r) Persepective"""
-        self._data_list.pop(self._data)
-        self.pr_plot_list.pop(self._data)
-        self.data_plot_list.pop(self._data)
-        if self.dmaxWindow is not None:
-            self.dmaxWindow = None
-        self.dataList.removeItem(self.dataList.currentIndex())
-        self.dataList.setCurrentIndex(0)
-        # Last file removed
-        if not self._data_list:
-            self._data = None
-            self.pr_plot = None
-            self._data_set = None
-            self.calculateThisButton.setEnabled(False)
-            self.calculateAllButton.setEnabled(False)
-            self.explorerButton.setEnabled(False)
+        self.updateGuiValues()
 
     ######################################################################
     # GUI Interaction Events
-
-    def setCurrentModel(self, ref_item):
-        '''update the current model with stored values'''
-        if ref_item in self._models:
-            self.model = self._models[ref_item]
 
     def update_calculator(self):
@@ -355 +330 @@
             InversionWindow.__init__(self.parent(), list(self._data_list.keys()))
             exit(0)
-        # TODO: Only send plot first time - otherwise, update in complete
         if self.pr_plot is not None:
             title = self.pr_plot.name
@@ -363 +337 @@
             GuiUtils.updateModelItemWithPlot(self._data, self.data_plot, title)
         if self.dmaxWindow is not None:
-             self.dmaxWindow.pr_state = self._calculator
-             self.dmaxWindow.nfunc = self.getNFunc()
-
+            self.dmaxWindow.pr_state = self._calculator
+            self.dmaxWindow.nfunc = self.getNFunc()
+            self.dmaxWindow.modelChanged()
         self.mapper.toFirst()
 
@@ -386 +360 @@
         if sender is self.estimateBgd:
             self.backgroundInput.setEnabled(False)
+            self._calculator.set_est_bck = True
         else:
             self.backgroundInput.setEnabled(True)
+            self._calculator.set_est_bck = False
 
     def openExplorerWindow(self):
@@ -410 +386 @@
         if not isinstance(data_item, list):
             msg = "Incorrect type passed to the P(r) Perspective"
-            raise AttributeError
+            raise AttributeError(msg)
 
         for data in data_item:
@@ -417 +393 @@
                 return
             # Create initial internal mappings
-            self._data_list[data] = self._calculator.clone()
             self._data_set = GuiUtils.dataFromItem(data)
-            self.data_plot_list[data] = self.data_plot
-            self.pr_plot_list[data] = self.pr_plot
+            self.logic = InversionLogic(self._data_set)
             self.populateDataComboBox(self._data_set.filename, data)
+            # Estimate q range
+            qmin, qmax = self.logic.computeDataRange()
+            self._calculator.set_qmin(qmin)
+            self._calculator.set_qmax(qmax)
+            self.updateDataList(data)
             self.setCurrentData(data)
-
             # Estimate initial values from data
             self.performEstimate()
-            self.logic = InversionLogic(self._data_set)
-
-            # Estimate q range
-            qmin, qmax = self.logic.computeDataRange()
-            self.model.setItem(WIDGETS.W_QMIN, QtGui.QStandardItem("{:.4g}".format(qmin)))
-            self.model.setItem(WIDGETS.W_QMAX, QtGui.QStandardItem("{:.4g}".format(qmax)))
-            self._models[data] = self.model
-            self.model_item = data
-
         self.enableButtons()
+        self.updateGuiValues()
+
+    def updateDataList(self, dataRef):
+        """Save the current data state of the window into self._data_list"""
+        if dataRef is None:
+            return
+        self._data_list[dataRef] = {
+            DICT_KEYS[0]: self._calculator,
+            DICT_KEYS[1]: self.pr_plot,
+            DICT_KEYS[2]: self.data_plot,
+            DICT_KEYS[3]: self.dmaxWindow,
+            DICT_KEYS[4]: self.logic,
+            DICT_KEYS[5]: self.nTermsSuggested
+        }
 
     def getNFunc(self):
@@ -448 +431 @@
 
     def setCurrentData(self, data_ref):
-        """Get the current data and display as necessary"""
-
+        """Get the data by reference and display as necessary"""
         if data_ref is None:
             return
-
         if not isinstance(data_ref, QtGui.QStandardItem):
             msg = "Incorrect type passed to the P(r) Perspective"
-            raise AttributeError
-
+            raise AttributeError(msg)
         # Data references
         self._data = data_ref
         self._data_set = GuiUtils.dataFromItem(data_ref)
-        self._calculator = self._data_list[data_ref]
-        self.pr_plot = self.pr_plot_list[data_ref]
-        self.data_plot = self.data_plot_list[data_ref]
+        self._calculator = self._data_list[data_ref].get(DICT_KEYS[0])
+        self.pr_plot = self._data_list[data_ref].get(DICT_KEYS[1])
+        self.data_plot = self._data_list[data_ref].get(DICT_KEYS[2])
+        self.dmaxWindow = self._data_list[data_ref].get(DICT_KEYS[3])
+        self.logic = self._data_list[data_ref].get(DICT_KEYS[4])
+        self.nTermsSuggested = self._data_list[data_ref].get(DICT_KEYS[5])
+        self.updateGuiValues()
+
+    def updateGuiValues(self):
+        pr = self._calculator
+        out = self._calculator.out
+        cov = self._calculator.cov
+        elapsed = self._calculator.elapsed
+        alpha = self._calculator.suggested_alpha
+        nterms = self._calculator.nfunc
+        self.model.setItem(WIDGETS.W_QMIN,
+                           QtGui.QStandardItem("{:.4g}".format(pr.get_qmin())))
+        self.model.setItem(WIDGETS.W_QMAX,
+                           QtGui.QStandardItem("{:.4g}".format(pr.get_qmax())))
+        self.model.setItem(WIDGETS.W_BACKGROUND_INPUT,
+                           QtGui.QStandardItem("{:.3f}".format(pr.background)))
+        self.model.setItem(WIDGETS.W_BACKGROUND_OUTPUT,
+                           QtGui.QStandardItem("{:.3g}".format(pr.background)))
+        self.model.setItem(WIDGETS.W_COMP_TIME,
+                           QtGui.QStandardItem("{:.4g}".format(elapsed)))
+        if alpha != 0:
+            self.regConstantSuggestionButton.setText("{:-3.2g}".format(alpha))
+        self.regConstantSuggestionButton.setEnabled(alpha != self._calculator.alpha)
+        if nterms != self.nTermsSuggested:
+            self.noOfTermsSuggestionButton.setText(
+                "{:n}".format(self.nTermsSuggested))
+        self.noOfTermsSuggestionButton.setEnabled(nterms != self.nTermsSuggested)
+        self.model.setItem(WIDGETS.W_COMP_TIME,
+                           QtGui.QStandardItem("{:.2g}".format(elapsed)))
+
+        if isinstance(pr.chi2, np.ndarray):
+            self.model.setItem(WIDGETS.W_CHI_SQUARED,
+                               QtGui.QStandardItem("{:.3g}".format(pr.chi2[0])))
+        if out is not None:
+            self.model.setItem(WIDGETS.W_RG,
+                               QtGui.QStandardItem("{:.3g}".format(pr.rg(out))))
+            self.model.setItem(WIDGETS.W_I_ZERO,
+                               QtGui.QStandardItem(
+                                   "{:.3g}".format(pr.iq0(out))))
+            self.model.setItem(WIDGETS.W_OSCILLATION, QtGui.QStandardItem(
+                "{:.3g}".format(pr.oscillations(out))))
+            self.model.setItem(WIDGETS.W_POS_FRACTION, QtGui.QStandardItem(
+                "{:.3g}".format(pr.get_positive(out))))
+            if cov is not None:
+                self.model.setItem(WIDGETS.W_SIGMA_POS_FRACTION,
+                                   QtGui.QStandardItem(
+                                       "{:.3g}".format(
+                                           pr.get_pos_err(out, cov))))
+
+    def removeData(self):
+        """Remove the existing data reference from the P(r) Persepective"""
+        if self.dmaxWindow is not None:
+            self.dmaxWindow = None
+        self.dataList.removeItem(self.dataList.currentIndex())
+        self._data_list.pop(self._data)
+        # Last file removed
+        if len(self._data_list) == 0:
+            self._data = None
+            self.pr_plot = None
+            self._data_set = None
+            self._calculator = Invertor()
+            self.logic = InversionLogic()
+            self.enableButtons()
+        self.dataList.setCurrentIndex(0)
+        self.updateGuiValues()
 
     ######################################################################
     # Thread Creators
     def startThreadAll(self):
-        for data_ref, pr in list(self._data_list.items()):
-            self._data_set = GuiUtils.dataFromItem(data_ref)
-            self._calculator = pr
+        for data_ref in self._data_list.keys():
+            self.setCurrentData(data_ref)
             self.startThread()
 
@@ -554 +600 @@
         """
         alpha, message, elapsed = output_tuple
-        # Save useful info
-        self.model.setItem(WIDGETS.W_COMP_TIME, QtGui.QStandardItem("{:.4g}".format(elapsed)))
-        self.regConstantSuggestionButton.setText("{:-3.2g}".format(alpha))
-        self.regConstantSuggestionButton.setEnabled(True)
+        self.updateGuiValues()
         if message:
             logging.info(message)
@@ -576 +619 @@
         """
         nterms, alpha, message, elapsed = output_tuple
+        self._calculator.elapsed = elapsed
+        self._calculator.suggested_alpha = alpha
+        self.nTermsSuggested = nterms
         # Save useful info
-        self.noOfTermsSuggestionButton.setText("{:n}".format(nterms))
-        self.noOfTermsSuggestionButton.setEnabled(True)
-        self.regConstantSuggestionButton.setText("{:.3g}".format(alpha))
-        self.regConstantSuggestionButton.setEnabled(True)
-        self.model.setItem(WIDGETS.W_COMP_TIME, QtGui.QStandardItem("{:.2g}".format(elapsed)))
+        self.updateGuiValues()
         if message:
             logging.info(message)
@@ -605 +647 @@
         pr.elapsed = elapsed
 
-        # Show result on control panel
-        self.model.setItem(WIDGETS.W_RG, QtGui.QStandardItem("{:.3g}".format(pr.rg(out))))
-        self.model.setItem(WIDGETS.W_I_ZERO, QtGui.QStandardItem("{:.3g}".format(pr.iq0(out))))
-        self.model.setItem(WIDGETS.W_BACKGROUND_INPUT,
-                           QtGui.QStandardItem("{:.3f}".format(pr.est_bck)))
-        self.model.setItem(WIDGETS.W_BACKGROUND_OUTPUT, QtGui.QStandardItem("{:.3g}".format(pr.background)))
-        self.model.setItem(WIDGETS.W_CHI_SQUARED, QtGui.QStandardItem("{:.3g}".format(pr.chi2[0])))
-        self.model.setItem(WIDGETS.W_COMP_TIME, QtGui.QStandardItem("{:.2g}".format(elapsed)))
-        self.model.setItem(WIDGETS.W_OSCILLATION, QtGui.QStandardItem("{:.3g}".format(pr.oscillations(out))))
-        self.model.setItem(WIDGETS.W_POS_FRACTION, QtGui.QStandardItem("{:.3g}".format(pr.get_positive(out))))
-        self.model.setItem(WIDGETS.W_SIGMA_POS_FRACTION,
-                           QtGui.QStandardItem("{:.3g}".format(pr.get_pos_err(out, cov))))
-
         # Save Pr invertor
         self._calculator = pr
-        # Append data to data list
-        self._data_list[self._data] = self._calculator.clone()
-
-        # Update model dict
-        self._models[self.model_item] = self.model
 
         # Create new P(r) and fit plots
         if self.pr_plot is None:
             self.pr_plot = self.logic.newPRPlot(out, self._calculator, cov)
-            self.pr_plot_list[self._data] = self.pr_plot
-        else:
-            # FIXME: this should update the existing plot, not create a new one
-            self.pr_plot = self.logic.newPRPlot(out, self._calculator, cov)
-            self.pr_plot_list[self._data] = self.pr_plot
         if self.data_plot is None:
             self.data_plot = self.logic.new1DPlot(out, self._calculator)
-            self.data_plot_list[self._data] = self.data_plot
-        else:
-            # FIXME: this should update the existing plot, not create a new one
-            self.data_plot = self.logic.new1DPlot(out, self._calculator)
-            self.data_plot_list[self._data] = self.data_plot
+        self.updateDataList(self._data)
+        self.updateGuiValues()
 
     def _threadError(self, error):