Changeset dcabba7 in sasview

Timestamp:

Sep 7, 2018 9:11:28 AM (6 years ago)

Author:

ibressler

Branches:

ESS_GUI, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc

Children:

fb560d2, c0de493

Parents:

60d55a7

git-author:

Ingo Breßler <dev@…> (09/06/18 09:09:57)

git-committer:

Ingo Breßler <dev@…> (09/07/18 09:11:28)

Message:

ModelThread?: passing calc results by dict instead of tuple

• prevents error when unpacking the tuple in completeXY methods later
• and makes it easier to get just a single value from the result

Location:

src/sas/qtgui/Perspectives/Fitting

Files:

• FittingLogic.py (modified) (4 diffs)
• FittingWidget.py (modified) (1 diff)
• ModelThread.py (modified) (2 diffs)

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

@@ -161 +161 @@
         Create a new 1D data instance based on fitting results
         """
-        # Unpack return data from Calc1D
-        x, y, page_id, state, weight,\
-        fid, toggle_mode_on, \
-        elapsed, index, model, \
-        data, update_chisqr, source, \
-        unsmeared_output, unsmeared_data, unsmeared_error, \
-        pq_values, sq_values = return_data
-
-        return self._create1DPlot(tab_id, x, y, model, data)
+
+        return self._create1DPlot(tab_id, return_data['x'], return_data['y'],
+                                  return_data['model'], return_data['data'])
 
     def new2DPlot(self, return_data):
@@ -175 +169 @@
         Create a new 2D data instance based on fitting results
         """
-        image, data, page_id, model, state, toggle_mode_on,\
-        elapsed, index, fid, qmin, qmax, weight, \
-        update_chisqr, source = return_data
+        image = return_data['image']
+        data = return_data['data']
+        model = return_data['model']
 
         np.nan_to_num(image)
@@ -183 +177 @@
         new_plot.name = model.name + '2d'
         new_plot.title = "Analytical model 2D "
-        new_plot.id = str(page_id) + " " + data.name
-        new_plot.group_id = str(page_id) + " Model2D"
+        new_plot.id = str(return_data['page_id']) + " " + data.name
+        new_plot.group_id = str(return_data['page_id']) + " Model2D"
         new_plot.detector = data.detector
         new_plot.source = data.source
@@ -218 +212 @@
         (pq_plot, sq_plot). If either are unavailable, the corresponding plot is None.
         """
-        # Unpack return data from Calc1D
-        x, y, page_id, state, weight, \
-        fid, toggle_mode_on, \
-        elapsed, index, model, \
-        data, update_chisqr, source, \
-        unsmeared_output, unsmeared_data, unsmeared_error, \
-        pq_values, sq_values = return_data
 
         pq_plot = None
         sq_plot = None
 
-        if pq_values is not None:
-            pq_plot = self._create1DPlot(tab_id, x, pq_values, model, data, component="P(Q)")
-        if sq_values is not None:
-            sq_plot = self._create1DPlot(tab_id, x, sq_values, model, data, component="S(Q)")
+        if return_data.get('pq_values', None) is not None:
+            pq_plot = self._create1DPlot(tab_id, return_data['x'],
+                    return_data['pq_values'], return_data['model'],
+                    return_data['data'], component="P(Q)")
+        if return_data.get('sq_values', None) is not None:
+            sq_plot = self._create1DPlot(tab_id, return_data['x'],
+                    return_data['sq_values'], return_data['model'],
+                    return_data['data'], component="S(Q)")
 
         return pq_plot, sq_plot

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

@@ -91 +91 @@
     fittingFinishedSignal = QtCore.pyqtSignal(tuple)
     batchFittingFinishedSignal = QtCore.pyqtSignal(tuple)
-    Calc1DFinishedSignal = QtCore.pyqtSignal(tuple)
-    Calc2DFinishedSignal = QtCore.pyqtSignal(tuple)
+    Calc1DFinishedSignal = QtCore.pyqtSignal(dict)
+    Calc2DFinishedSignal = QtCore.pyqtSignal(dict)
 
     def __init__(self, parent=None, data=None, tab_id=1):

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

@@ -101 +101 @@
         elapsed = time.time() - self.starttime
 
+        res = dict(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, update_chisqr = self.update_chisqr,
+            source = 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.completefn((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,
-                           #qstep=self.qstep,
-                           self.update_chisqr,
-                           self.source))
-
+            return res
+        else:
+            self.completefn(res)
 
 class Calc1D(CalcThread):
@@ -236 +216 @@
         elapsed = time.time() - self.starttime
 
+        res = dict(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_output = unsmeared_output,
+            unsmeared_data = unsmeared_data, unsmeared_error = unsmeared_error,
+            pq_values = pq_values, sq_values = 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,
-                    unsmeared_output, unsmeared_data, unsmeared_error,
-                    pq_values, sq_values)
-        else:
-            self.completefn((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,
-                        unsmeared_output, unsmeared_data, unsmeared_error,
-                        pq_values, sq_values))
+            return res
+        else:
+            self.completefn(res)
 
     def results(self):