Changes in / [5e0891b:d4ba565] in sasview

Location:

src/sas/qtgui/Perspectives/Fitting

Files:

• FittingLogic.py (modified) (2 diffs)
• FittingUtilities.py (modified) (2 diffs)
• FittingWidget.py (modified) (6 diffs)
• ModelThread.py (modified) (4 diffs)

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

@@ -161 +161 @@
         Create a new 1D data instance based on fitting results
         """
+
         return self._create1DPlot(tab_id, return_data['x'], return_data['y'],
                                   return_data['model'], return_data['data'])
@@ -211 +212 @@
         (pq_plot, sq_plot). If either are unavailable, the corresponding plot is None.
         """
-        plots = []
-        for name, result in return_data['intermediate_results'].items():
-            plots.append(self._create1DPlot(tab_id, return_data['x'], result,
-                         return_data['model'], return_data['data'],
-                         component=name))
-        return plots
+
+        pq_plot = None
+        sq_plot = None
+
+        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
 
     def computeDataRange(self):

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

@@ -167 +167 @@
     return rows
 
-def addSimpleParametersToModel(parameters, is2D, parameters_original=None, model=None, view=None, row_num=None):
+def addSimpleParametersToModel(parameters, is2D, parameters_original=None, model=None, view=None):
     """
     Update local ModelModel with sasmodel parameters (non-dispersed, non-magnetic)
@@ -216 +216 @@
         # Append to the model and use the combobox, if required
         if None not in (model, view):
-            if row_num is None:
-                model.appendRow(row)
-            else:
-                model.insertRow(row_num, row)
-                row_num += 1
-
+            model.appendRow(row)
             if cbox:
                 view.setIndexWidget(item2.index(), cbox)
-
         rows.append(row)
 

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

@@ -2102 +2102 @@
             return
 
-        product_params = None
-
         if self.kernel_module is None:
             # Structure factor is the only selected model; build it and show all its params
@@ -2109 +2107 @@
             s_params = self.kernel_module._model_info.parameters
             s_params_orig = s_params
+
         else:
             s_kernel = self.models[structure_factor]()
@@ -2125 +2124 @@
             if "radius_effective_mode" in all_param_names:
                 # Show all parameters
-                # In this case, radius_effective is NOT pruned by sasmodels.product
                 s_params = modelinfo.ParameterTable(all_params[p_pars_len:p_pars_len+s_pars_len])
                 s_params_orig = modelinfo.ParameterTable(s_kernel._model_info.parameters.kernel_parameters)
-                product_params = modelinfo.ParameterTable(
-                        self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len:])
             else:
                 # Ensure radius_effective is not displayed
                 s_params_orig = modelinfo.ParameterTable(s_kernel._model_info.parameters.kernel_parameters[1:])
                 if "radius_effective" in all_param_names:
-                    # In this case, radius_effective is NOT pruned by sasmodels.product
                     s_params = modelinfo.ParameterTable(all_params[p_pars_len+1:p_pars_len+s_pars_len])
-                    product_params = modelinfo.ParameterTable(
-                            self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len:])
                 else:
-                    # In this case, radius_effective is pruned by sasmodels.product
                     s_params = modelinfo.ParameterTable(all_params[p_pars_len:p_pars_len+s_pars_len-1])
-                    product_params = modelinfo.ParameterTable(
-                            self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len-1:])
 
         # Add heading row
@@ -2150 +2140 @@
         # Any renamed parameters are stored as data in the relevant item, for later handling
         FittingUtilities.addSimpleParametersToModel(
-                parameters=s_params,
-                is2D=self.is2D,
-                parameters_original=s_params_orig,
-                model=self._model_model,
-                view=self.lstParams)
-
-        # Insert product-only params into QModel
-        if product_params:
-            prod_rows = FittingUtilities.addSimpleParametersToModel(
-                    parameters=product_params,
-                    is2D=self.is2D,
-                    parameters_original=None,
-                    model=self._model_model,
-                    view=self.lstParams,
-                    row_num=2)
-
-            # Since this all happens after shells are dealt with and we've inserted rows, fix this counter
-            self._n_shells_row += len(prod_rows)
+                s_params,
+                self.is2D,
+                s_params_orig,
+                self._model_model,
+                self.lstParams)
 
     def haveParamsToFit(self):
@@ -2428 +2405 @@
 
         # Create plots for intermediate product data
-        plots = self.logic.new1DProductPlots(return_data, self.tab_id)
-        for plot in plots:
-            plot.symbol = "Line"
-            self.createNewIndex(plot)
-            new_plots.append(plot)
+        pq_data, sq_data = self.logic.new1DProductPlots(return_data, self.tab_id)
+        if pq_data is not None:
+            pq_data.symbol = "Line"
+            self.createNewIndex(pq_data)
+            # self.communicate.plotUpdateSignal.emit([pq_data])
+            new_plots.append(pq_data)
+        if sq_data is not None:
+            sq_data.symbol = "Line"
+            self.createNewIndex(sq_data)
+            # self.communicate.plotUpdateSignal.emit([sq_data])
+            new_plots.append(sq_data)
 
         for plot in new_plots:
@@ -2833 +2816 @@
         self._num_shell_params = len(new_rows)
         self.current_shell_displayed = index
-
-        # Change 'n' in the parameter model, thereby updating the underlying model
-        self._model_model.item(self._n_shells_row, 1).setText(str(index))
 
         # Update relevant models

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

@@ -164 +164 @@
         index = (self.qmin <= self.data.x) & (self.data.x <= self.qmax)
 
-        intermediate_results = None
-
         # If we use a smearer, also return the unsmeared model
         unsmeared_output = None
@@ -176 +174 @@
             mask = self.data.x[first_bin:last_bin+1]
             unsmeared_output = numpy.zeros((len(self.data.x)))
-
-            return_data = self.model.calculate_Iq(mask)
-            if isinstance(return_data, tuple):
-                # see sasmodels beta_approx: SasviewModel.calculate_Iq
-                # TODO: implement intermediate results in smearers
-                return_data, _ = return_data
-            unsmeared_output[first_bin:last_bin+1] = return_data
+            unsmeared_output[first_bin:last_bin+1] = self.model.evalDistribution(mask)
             output = self.smearer(unsmeared_output, first_bin, last_bin)
 
@@ -201 +193 @@
                 unsmeared_error=unsmeared_error
         else:
-            return_data = self.model.calculate_Iq(self.data.x[index])
-            if isinstance(return_data, tuple):
-                # see sasmodels beta_approx: SasviewModel.calculate_Iq
-                return_data, intermediate_results = return_data
-            output[index] = return_data
-
-        if intermediate_results:
-            # the model returns a callable which is then used to retrieve the data
-            intermediate_results = intermediate_results()
-        else:
-            # TODO: this conditional branch needs refactoring
-            sq_values = None
-            pq_values = None
-            s_model = None
-            p_model = None
-
-            if isinstance(self.model, MultiplicationModel):
-                s_model = self.model.s_model
-                p_model = self.model.p_model
-
-            elif hasattr(self.model, "calc_composition_models"):
-                results = self.model.calc_composition_models(self.data.x[index])
-                if results is not None:
-                    pq_values, sq_values = results
-
-            if pq_values is None or sq_values is None:
-                if p_model is not None and s_model is not None:
-                    sq_values = numpy.zeros((len(self.data.x)))
-                    pq_values = numpy.zeros((len(self.data.x)))
-                    sq_values[index] = s_model.evalDistribution(self.data.x[index])
-                    pq_values[index] = p_model.evalDistribution(self.data.x[index])
-
-            if pq_values is not None and sq_values is not None:
-                intermediate_results  = {
-                    "P(Q)": pq_values,
-                    "S(Q)": sq_values
-                }
-            else:
-                intermediate_results = {}
+            output[index] = self.model.evalDistribution(self.data.x[index])
+
+        sq_values = None
+        pq_values = None
+        s_model = None
+        p_model = None
+        if isinstance(self.model, MultiplicationModel):
+            s_model = self.model.s_model
+            p_model = self.model.p_model
+        elif hasattr(self.model, "calc_composition_models"):
+            results = self.model.calc_composition_models(self.data.x[index])
+            if results is not None:
+                pq_values, sq_values = results
+
+        if pq_values is None or sq_values is None:
+            if p_model is not None and s_model is not None:
+                sq_values = numpy.zeros((len(self.data.x)))
+                pq_values = numpy.zeros((len(self.data.x)))
+                sq_values[index] = s_model.evalDistribution(self.data.x[index])
+                pq_values[index] = p_model.evalDistribution(self.data.x[index])
 
         elapsed = time.time() - self.starttime
@@ -250 +223 @@
             source = self.source, unsmeared_output = unsmeared_output,
             unsmeared_data = unsmeared_data, unsmeared_error = unsmeared_error,
-            intermediate_results = intermediate_results)
+            pq_values = pq_values, sq_values = sq_values)
 
         if LocalConfig.USING_TWISTED: