Changeset d4dac80 in sasview for src/sas/qtgui/Perspectives/Fitting

Timestamp:

Apr 25, 2018 6:59:33 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:

017b285

Parents:

93c79b5

git-author:

Piotr Rozyczko <rozyczko@…> (03/22/18 16:46:19)

git-committer:

Piotr Rozyczko <rozyczko@…> (04/25/18 06:59:33)

Message:

Merge branch 'ESS_GUI' into ESS_GUI_better_batch

Location:

src/sas/qtgui/Perspectives/Fitting

Files:

• ConstraintWidget.py (modified) (1 diff)
• FittingUtilities.py (modified) (1 diff)
• FittingWidget.py (modified) (20 diffs)
• ModelThread.py (modified) (3 diffs)
• ModelUtilities.py (modified) (1 diff)
• UI/FittingWidgetUI.ui (modified) (1 diff)

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

@@ -358 +358 @@
         elapsed = result[1]
 
-        # ADD THE BATCH FIT VIEW HERE
-        #
+        if result is None:
+            msg = "Fitting failed."
+            self.parent.communicate.statusBarUpdateSignal.emit(msg)
+            return
+
+        # Show the grid panel
+        self.parent.communicate.sendDataToGridSignal.emit(result[0])
 
         msg = "Fitting completed successfully in: %s s.\n" % GuiUtils.formatNumber(elapsed)

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

@@ -421 +421 @@
         weight = numpy.abs(data)
     return weight
+
+def updateKernelWithResults(kernel, results):
+    """
+    Takes model kernel and applies results dict to its parameters,
+    returning the modified (deep) copy of the kernel.
+    """
+    assert(isinstance(results, dict))
+    local_kernel = copy.deepcopy(kernel)
+
+    for parameter in results.keys():
+        # Update the parameter value - note: this supports +/-inf as well
+        local_kernel.setParam(parameter, results[parameter][0])
+
+    return local_kernel
+
+

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

@@ -3 +3 @@
 from collections import defaultdict
 
-
+import copy
 import logging
 import traceback
@@ -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
@@ -88 +87 @@
     fittingFinishedSignal = QtCore.pyqtSignal(tuple)
     batchFittingFinishedSignal = QtCore.pyqtSignal(tuple)
+    Calc1DFinishedSignal = QtCore.pyqtSignal(tuple)
+    Calc2DFinishedSignal = QtCore.pyqtSignal(tuple)
 
     def __init__(self, parent=None, data=None, tab_id=1):
@@ -99 +100 @@
         self.tab_id = tab_id
 
-        # Main Data[12]D holder
-        self.logic = FittingLogic()
-
         # Globals
         self.initializeGlobals()
@@ -107 +105 @@
         # Set up desired logging level
         logging.disable(LocalConfig.DISABLE_LOGGING)
+
+        # data index for the batch set
+        self.data_index = 0
+        # Main Data[12]D holders
+        # Logics.data contains a single Data1D/Data2D object
+        self._logic = [FittingLogic()]
 
         # Main GUI setup up
@@ -134 +138 @@
         self.initializeControls()
 
-        # Display HTML content
-        #self.setupHelp()
+        if data is not None:
+            self.data = data
 
         # New font to display angstrom symbol
@@ -142 +146 @@
         self.label_19.setStyleSheet(new_font)
 
-        self._index = None
-        if data is not None:
-            self.data = data
+    @property
+    def logic(self):
+        # make sure the logic contains at least one element
+        assert(self._logic)
+        # logic connected to the currently shown data
+        return self._logic[self.data_index]
 
     @property
@@ -161 +168 @@
 
         assert isinstance(value[0], QtGui.QStandardItem)
-        # _index contains the QIndex with data
-        self._index = value[0]
 
         # Keep reference to all datasets for batch
         self.all_data = value
 
-        # Update logics with data items
+        # Create logics with data items
+        self._logic=[]
         # Logics.data contains only a single Data1D/Data2D object
-        self.logic.data = GuiUtils.dataFromItem(value[0])
+        for data_item in value:
+            self._logic.append(FittingLogic())
+            self._logic[-1].data = GuiUtils.dataFromItem(data_item)
 
         # Overwrite data type descriptor
@@ -226 +234 @@
         # Polydisp widget table default index for function combobox
         self.orig_poly_index = 3
+        # copy of current kernel model
+        self.kernel_module_copy = None
 
         # Page id for fitting
@@ -488 +498 @@
         self.batchFittingFinishedSignal.connect(self.batchFitComplete)
         self.fittingFinishedSignal.connect(self.fitComplete)
+        self.Calc1DFinishedSignal.connect(self.complete1D)
+        self.Calc2DFinishedSignal.connect(self.complete2D)
 
         # Signals from separate tabs asking for replot
@@ -930 +942 @@
         Update the logic based on the selected file in batch fitting
         """
-        self._index = self.all_data[data_index]
-        self.logic.data = GuiUtils.dataFromItem(self.all_data[data_index])
+        self.data_index = data_index
         self.updateQRange()
 
@@ -1231 +1242 @@
             return
 
+        # keep local copy of kernel parameters, as they will change during the update
+        self.kernel_module_copy = copy.deepcopy(self.kernel_module)
+
         # Create the fitting thread, based on the fitter
         completefn = self.batchFittingCompleted if self.is_batch_fitting else self.fittingCompleted
@@ -1297 +1311 @@
         #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):
-        """
-        Receive and display fitting results
-        "result" is a tuple of actual result list and the fit time in seconds
-        """
-        #re-enable the Fit button
-        self.setFittingStopped()
 
         if result is None:
@@ -1320 +1317 @@
             return
 
+        # Show the grid panel
+        self.communicate.sendDataToGridSignal.emit(result[0])
+
+        elapsed = result[1]
+        msg = "Fitting completed successfully in: %s s.\n" % GuiUtils.formatNumber(elapsed)
+        self.communicate.statusBarUpdateSignal.emit(msg)
+
+        # Run over the list of results and update the items
+        for res_index, res_list in enumerate(result[0]):
+            # results
+            res = res_list[0]
+            param_dict = self.paramDictFromResults(res)
+
+            # create local kernel_module
+            kernel_module = FittingUtilities.updateKernelWithResults(self.kernel_module, param_dict)
+            # pull out current data
+            data = self._logic[res_index].data
+
+            # Switch indexes
+            self.onSelectBatchFilename(res_index)
+
+            method = self.complete1D if isinstance(self.data, Data1D) else self.complete2D
+            self.calculateQGridForModelExt(data=data, model=kernel_module, completefn=method, use_threads=False)
+
+        # Restore original kernel_module, so subsequent fits on the same model don't pick up the new params
+        if self.kernel_module is not None:
+            self.kernel_module = copy.deepcopy(self.kernel_module_copy)
+
+    def paramDictFromResults(self, results):
+        """
+        Given the fit results structure, pull out optimized parameters and return them as nicely
+        formatted dict
+        """
+        if results.fitness is None or \
+            not np.isfinite(results.fitness) or \
+            np.any(results.pvec is None) or \
+            not np.all(np.isfinite(results.pvec)):
+            msg = "Fitting did not converge!"
+            self.communicate.statusBarUpdateSignal.emit(msg)
+            msg += results.mesg
+            logging.error(msg)
+            return
+
+        param_list = results.param_list # ['radius', 'radius.width']
+        param_values = results.pvec     # array([ 0.36221662,  0.0146783 ])
+        param_stderr = results.stderr   # array([ 1.71293015,  1.71294233])
+        params_and_errors = list(zip(param_values, param_stderr))
+        param_dict = dict(zip(param_list, params_and_errors))
+
+        return param_dict
+
+    def fittingCompleted(self, result):
+        """
+        Send the finish message from calculate threads to main thread
+        """
+        self.fittingFinishedSignal.emit(result)
+
+    def fitComplete(self, result):
+        """
+        Receive and display fitting results
+        "result" is a tuple of actual result list and the fit time in seconds
+        """
+        #re-enable the Fit button
+        self.setFittingStopped()
+
+        if result is None:
+            msg = "Fitting failed."
+            self.communicate.statusBarUpdateSignal.emit(msg)
+            return
+
         res_list = result[0][0]
         res = res_list[0]
-        if res.fitness is None or \
-            not np.isfinite(res.fitness) or \
-            np.any(res.pvec is None) or \
-            not np.all(np.isfinite(res.pvec)):
-            msg = "Fitting did not converge!"
-            self.communicate.statusBarUpdateSignal.emit(msg)
-            msg += res.mesg
-            logging.error(msg)
-            return
+        self.chi2 = res.fitness
+        param_dict = self.paramDictFromResults(res)
 
         elapsed = result[1]
@@ -1339 +1399 @@
             msg = "Fitting completed successfully in: %s s." % GuiUtils.formatNumber(elapsed)
         self.communicate.statusBarUpdateSignal.emit(msg)
-
-        self.chi2 = res.fitness
-        param_list = res.param_list # ['radius', 'radius.width']
-        param_values = res.pvec     # array([ 0.36221662,  0.0146783 ])
-        param_stderr = res.stderr   # array([ 1.71293015,  1.71294233])
-        params_and_errors = list(zip(param_values, param_stderr))
-        param_dict = dict(zip(param_list, params_and_errors))
 
         # Dictionary of fitted parameter: value, error
@@ -2001 +2054 @@
             fitted_data.symbol = 'Line'
         # Notify the GUI manager so it can update the main model in DataExplorer
-        GuiUtils.updateModelItemWithPlot(self._index, fitted_data, name)
+        GuiUtils.updateModelItemWithPlot(self.all_data[self.data_index], fitted_data, name)
 
     def createTheoryIndex(self, fitted_data):
@@ -2031 +2084 @@
     def methodCompleteForData(self):
         '''return the method for result parsin on calc complete '''
-        return self.complete1D if isinstance(self.data, Data1D) else self.complete2D
-
-    def calculateQGridForModel(self):
-        """
-        Prepare the fitting data object, based on current ModelModel
-        """
-        if self.kernel_module is None:
-            return
+        return self.completed1D if isinstance(self.data, Data1D) else self.completed2D
+
+    def calculateQGridForModelExt(self, data=None, model=None, completefn=None, use_threads=True):
+        """
+        Wrapper for Calc1D/2D calls
+        """
+        if data is None:
+            data = self.data
+        if model is None:
+            model = self.kernel_module
+        if completefn is None:
+            completefn = self.methodCompleteForData()
+
         # Awful API to a backend method.
-        method = self.methodCalculateForData()(data=self.data,
-                                               model=self.kernel_module,
+        calc_thread = self.methodCalculateForData()(data=data,
+                                               model=model,
                                                page_id=0,
                                                qmin=self.q_range_min,
@@ -2050 +2108 @@
                                                fid=None,
                                                toggle_mode_on=False,
-                                               completefn=None,
+                                               completefn=completefn,
                                                update_chisqr=True,
                                                exception_handler=self.calcException,
                                                source=None)
-
-        calc_thread = threads.deferToThread(method.compute)
-        calc_thread.addCallback(self.methodCompleteForData())
-        calc_thread.addErrback(self.calculateDataFailed)
+        if use_threads:
+            if LocalConfig.USING_TWISTED:
+                # start the thread with twisted
+                thread = threads.deferToThread(calc_thread.compute)
+                thread.addCallback(completefn)
+                thread.addErrback(self.calculateDataFailed)
+            else:
+                # Use the old python threads + Queue
+                calc_thread.queue()
+                calc_thread.ready(2.5)
+        else:
+            results = calc_thread.compute()
+            completefn(results)
+
+    def calculateQGridForModel(self):
+        """
+        Prepare the fitting data object, based on current ModelModel
+        """
+        if self.kernel_module is None:
+            return
+        self.calculateQGridForModelExt()
 
     def calculateDataFailed(self, reason):
@@ -2064 +2139 @@
         """
         print("Calculate Data failed with ", reason)
+
+    def completed1D(self, return_data):
+        self.Calc1DFinishedSignal.emit(return_data)
+
+    def completed2D(self, return_data):
+        self.Calc2DFinishedSignal.emit(return_data)
 
     def complete1D(self, return_data):
@@ -2107 +2188 @@
         residuals_plot.id = "Residual " + residuals_plot.id
         self.createNewIndex(residuals_plot)
-        #self.communicate.plotUpdateSignal.emit([residuals_plot])
 
     def calcException(self, etype, value, tb):

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

@@ -8 +8 @@
 from sas.sascalc.data_util.calcthread import CalcThread
 from sas.sascalc.fit.MultiplicationModel import MultiplicationModel
+import sas.qtgui.Utilities.LocalConfig as LocalConfig
 
 class Calc2D(CalcThread):
@@ -99 +100 @@
         output[index_model] = value
         elapsed = time.time() - self.starttime
-        #self.complete(image=output,
-        #               data=self.data,
-        #               page_id=self.page_id,
-        #               model=self.model,
-        #               state=self.state,
-        #               toggle_mode_on=self.toggle_mode_on,
-        #               elapsed=elapsed,
-        #               index=index_model,
-        #               fid=self.fid,
-        #               qmin=self.qmin,
-        #               qmax=self.qmax,
-        #               weight=self.weight,
-        #               #qstep=self.qstep,
-        #               update_chisqr=self.update_chisqr,
-        #               source=self.source)
-        return (output,
-                self.data,
-                self.page_id,
-                self.model,
-                self.state,
-                self.toggle_mode_on,
-                elapsed,
-                index_model,
-                self.fid,
-                self.qmin,
-                self.qmax,
-                self.weight,
-                self.update_chisqr,
-                self.source)
+
+        if LocalConfig.USING_TWISTED:
+            return (output,
+                    self.data,
+                    self.page_id,
+                    self.model,
+                    self.state,
+                    self.toggle_mode_on,
+                    elapsed,
+                    index_model,
+                    self.fid,
+                    self.qmin,
+                    self.qmax,
+                    self.weight,
+                    self.update_chisqr,
+                    self.source)
+        else:
+            self.complete(image=output,
+                           data=self.data,
+                           page_id=self.page_id,
+                           model=self.model,
+                           state=self.state,
+                           toggle_mode_on=self.toggle_mode_on,
+                           elapsed=elapsed,
+                           index=index_model,
+                           fid=self.fid,
+                           qmin=self.qmin,
+                           qmax=self.qmax,
+                           weight=self.weight,
+                           #qstep=self.qstep,
+                           update_chisqr=self.update_chisqr,
+                           source=self.source)
 
 
@@ -229 +233 @@
         elapsed = time.time() - self.starttime
 
-        return (self.data.x[index], output[index],
-                self.page_id,
-                self.state,
-                self.weight,
-                self.fid,
-                self.toggle_mode_on,
-                elapsed, index, self.model,
-                self.data,
-                self.update_chisqr,
-                self.source)
-
-        # TODO: as of 4.1, the output contains more items:
-        # unsmeared_* and pq_model/sq_model
-        # Need to add these too
-
-        #self.complete(x=self.data.x[index], y=output[index],
-        #              page_id=self.page_id,
-        #              state=self.state,
-        #              weight=self.weight,
-        #              fid=self.fid,
-        #              toggle_mode_on=self.toggle_mode_on,
-        #              elapsed=elapsed, index=index, model=self.model,
-        #              data=self.data,
-        #              update_chisqr=self.update_chisqr,
-        #              source=self.source,
-        #              unsmeared_model=unsmeared_output,
-        #              unsmeared_data=unsmeared_data,
-        #              unsmeared_error=unsmeared_error,
-        #              pq_model=pq_values,
-        #              sq_model=sq_values)
+        if LocalConfig.USING_TWISTED:
+            return (self.data.x[index], output[index],
+                    self.page_id,
+                    self.state,
+                    self.weight,
+                    self.fid,
+                    self.toggle_mode_on,
+                    elapsed, index, self.model,
+                    self.data,
+                    self.update_chisqr,
+                    self.source)
+        else:
+            self.complete(x=self.data.x[index], y=output[index],
+                          page_id=self.page_id,
+                          state=self.state,
+                          weight=self.weight,
+                          fid=self.fid,
+                          toggle_mode_on=self.toggle_mode_on,
+                          elapsed=elapsed, index=index, model=self.model,
+                          data=self.data,
+                          update_chisqr=self.update_chisqr,
+                          source=self.source,
+                          unsmeared_model=unsmeared_output,
+                          unsmeared_data=unsmeared_data,
+                          unsmeared_error=unsmeared_error,
+                          pq_model=pq_values,
+                          sq_model=sq_values)
 
     def results(self):

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

@@ -173 +173 @@
         return {}
 
-    plugin_log("looking for models in: %s" % str(directory))
-    # compile_file(directory)  #always recompile the folder plugin
-    logging.info("plugin model dir: %s" % str(directory))
-
     plugins = {}
     for filename in os.listdir(directory):

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

@@ -216 +216 @@
             </property>
             <property name="toolTip">
-             <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>
+             <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>
             </property>
             <property name="text">