Changeset 5e0891b in sasview


Ignore:
Timestamp:
Sep 8, 2018 9:48:20 AM (10 days ago)
Author:
Laura Forster <Awork@…>
Branches:
ESS_GUI, ESS_GUI_Pr_fixes, ESS_GUI_iss1052, ESS_GUI_poly_plot2
Children:
68dc2873, 685602a, 5a96a72, dd2c2a31
Parents:
d4ba565 (diff), 35e36fd (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' of https://github.com/SasView/sasview into ESS_GUI

Location:
src/sas/qtgui/Perspectives/Fitting
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • src/sas/qtgui/Perspectives/Fitting/FittingLogic.py

    rdcabba7 r9ba91b7  
    161161        Create a new 1D data instance based on fitting results 
    162162        """ 
    163  
    164163        return self._create1DPlot(tab_id, return_data['x'], return_data['y'], 
    165164                                  return_data['model'], return_data['data']) 
     
    212211        (pq_plot, sq_plot). If either are unavailable, the corresponding plot is None. 
    213212        """ 
    214  
    215         pq_plot = None 
    216         sq_plot = None 
    217  
    218         if return_data.get('pq_values', None) is not None: 
    219             pq_plot = self._create1DPlot(tab_id, return_data['x'], 
    220                     return_data['pq_values'], return_data['model'], 
    221                     return_data['data'], component="P(Q)") 
    222         if return_data.get('sq_values', None) is not None: 
    223             sq_plot = self._create1DPlot(tab_id, return_data['x'], 
    224                     return_data['sq_values'], return_data['model'], 
    225                     return_data['data'], component="S(Q)") 
    226  
    227         return pq_plot, sq_plot 
     213        plots = [] 
     214        for name, result in return_data['intermediate_results'].items(): 
     215            plots.append(self._create1DPlot(tab_id, return_data['x'], result, 
     216                         return_data['model'], return_data['data'], 
     217                         component=name)) 
     218        return plots 
    228219 
    229220    def computeDataRange(self): 
  • src/sas/qtgui/Perspectives/Fitting/FittingUtilities.py

    rb69b549 r01b4877  
    167167    return rows 
    168168 
    169 def addSimpleParametersToModel(parameters, is2D, parameters_original=None, model=None, view=None): 
     169def addSimpleParametersToModel(parameters, is2D, parameters_original=None, model=None, view=None, row_num=None): 
    170170    """ 
    171171    Update local ModelModel with sasmodel parameters (non-dispersed, non-magnetic) 
     
    216216        # Append to the model and use the combobox, if required 
    217217        if None not in (model, view): 
    218             model.appendRow(row) 
     218            if row_num is None: 
     219                model.appendRow(row) 
     220            else: 
     221                model.insertRow(row_num, row) 
     222                row_num += 1 
     223 
    219224            if cbox: 
    220225                view.setIndexWidget(item2.index(), cbox) 
     226 
    221227        rows.append(row) 
    222228 
  • src/sas/qtgui/Perspectives/Fitting/FittingWidget.py

    rd4ba565 r5e0891b  
    21022102            return 
    21032103 
     2104        product_params = None 
     2105 
    21042106        if self.kernel_module is None: 
    21052107            # Structure factor is the only selected model; build it and show all its params 
     
    21072109            s_params = self.kernel_module._model_info.parameters 
    21082110            s_params_orig = s_params 
    2109  
    21102111        else: 
    21112112            s_kernel = self.models[structure_factor]() 
     
    21242125            if "radius_effective_mode" in all_param_names: 
    21252126                # Show all parameters 
     2127                # In this case, radius_effective is NOT pruned by sasmodels.product 
    21262128                s_params = modelinfo.ParameterTable(all_params[p_pars_len:p_pars_len+s_pars_len]) 
    21272129                s_params_orig = modelinfo.ParameterTable(s_kernel._model_info.parameters.kernel_parameters) 
     2130                product_params = modelinfo.ParameterTable( 
     2131                        self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len:]) 
    21282132            else: 
    21292133                # Ensure radius_effective is not displayed 
    21302134                s_params_orig = modelinfo.ParameterTable(s_kernel._model_info.parameters.kernel_parameters[1:]) 
    21312135                if "radius_effective" in all_param_names: 
     2136                    # In this case, radius_effective is NOT pruned by sasmodels.product 
    21322137                    s_params = modelinfo.ParameterTable(all_params[p_pars_len+1:p_pars_len+s_pars_len]) 
     2138                    product_params = modelinfo.ParameterTable( 
     2139                            self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len:]) 
    21332140                else: 
     2141                    # In this case, radius_effective is pruned by sasmodels.product 
    21342142                    s_params = modelinfo.ParameterTable(all_params[p_pars_len:p_pars_len+s_pars_len-1]) 
     2143                    product_params = modelinfo.ParameterTable( 
     2144                            self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len-1:]) 
    21352145 
    21362146        # Add heading row 
     
    21402150        # Any renamed parameters are stored as data in the relevant item, for later handling 
    21412151        FittingUtilities.addSimpleParametersToModel( 
    2142                 s_params, 
    2143                 self.is2D, 
    2144                 s_params_orig, 
    2145                 self._model_model, 
    2146                 self.lstParams) 
     2152                parameters=s_params, 
     2153                is2D=self.is2D, 
     2154                parameters_original=s_params_orig, 
     2155                model=self._model_model, 
     2156                view=self.lstParams) 
     2157 
     2158        # Insert product-only params into QModel 
     2159        if product_params: 
     2160            prod_rows = FittingUtilities.addSimpleParametersToModel( 
     2161                    parameters=product_params, 
     2162                    is2D=self.is2D, 
     2163                    parameters_original=None, 
     2164                    model=self._model_model, 
     2165                    view=self.lstParams, 
     2166                    row_num=2) 
     2167 
     2168            # Since this all happens after shells are dealt with and we've inserted rows, fix this counter 
     2169            self._n_shells_row += len(prod_rows) 
    21472170 
    21482171    def haveParamsToFit(self): 
     
    24052428 
    24062429        # Create plots for intermediate product data 
    2407         pq_data, sq_data = self.logic.new1DProductPlots(return_data, self.tab_id) 
    2408         if pq_data is not None: 
    2409             pq_data.symbol = "Line" 
    2410             self.createNewIndex(pq_data) 
    2411             # self.communicate.plotUpdateSignal.emit([pq_data]) 
    2412             new_plots.append(pq_data) 
    2413         if sq_data is not None: 
    2414             sq_data.symbol = "Line" 
    2415             self.createNewIndex(sq_data) 
    2416             # self.communicate.plotUpdateSignal.emit([sq_data]) 
    2417             new_plots.append(sq_data) 
     2430        plots = self.logic.new1DProductPlots(return_data, self.tab_id) 
     2431        for plot in plots: 
     2432            plot.symbol = "Line" 
     2433            self.createNewIndex(plot) 
     2434            new_plots.append(plot) 
    24182435 
    24192436        for plot in new_plots: 
     
    28162833        self._num_shell_params = len(new_rows) 
    28172834        self.current_shell_displayed = index 
     2835 
     2836        # Change 'n' in the parameter model, thereby updating the underlying model 
     2837        self._model_model.item(self._n_shells_row, 1).setText(str(index)) 
    28182838 
    28192839        # Update relevant models 
  • src/sas/qtgui/Perspectives/Fitting/ModelThread.py

    rdcabba7 r5181e9b  
    164164        index = (self.qmin <= self.data.x) & (self.data.x <= self.qmax) 
    165165 
     166        intermediate_results = None 
     167 
    166168        # If we use a smearer, also return the unsmeared model 
    167169        unsmeared_output = None 
     
    174176            mask = self.data.x[first_bin:last_bin+1] 
    175177            unsmeared_output = numpy.zeros((len(self.data.x))) 
    176             unsmeared_output[first_bin:last_bin+1] = self.model.evalDistribution(mask) 
     178 
     179            return_data = self.model.calculate_Iq(mask) 
     180            if isinstance(return_data, tuple): 
     181                # see sasmodels beta_approx: SasviewModel.calculate_Iq 
     182                # TODO: implement intermediate results in smearers 
     183                return_data, _ = return_data 
     184            unsmeared_output[first_bin:last_bin+1] = return_data 
    177185            output = self.smearer(unsmeared_output, first_bin, last_bin) 
    178186 
     
    193201                unsmeared_error=unsmeared_error 
    194202        else: 
    195             output[index] = self.model.evalDistribution(self.data.x[index]) 
    196  
    197         sq_values = None 
    198         pq_values = None 
    199         s_model = None 
    200         p_model = None 
    201         if isinstance(self.model, MultiplicationModel): 
    202             s_model = self.model.s_model 
    203             p_model = self.model.p_model 
    204         elif hasattr(self.model, "calc_composition_models"): 
    205             results = self.model.calc_composition_models(self.data.x[index]) 
    206             if results is not None: 
    207                 pq_values, sq_values = results 
    208  
    209         if pq_values is None or sq_values is None: 
    210             if p_model is not None and s_model is not None: 
    211                 sq_values = numpy.zeros((len(self.data.x))) 
    212                 pq_values = numpy.zeros((len(self.data.x))) 
    213                 sq_values[index] = s_model.evalDistribution(self.data.x[index]) 
    214                 pq_values[index] = p_model.evalDistribution(self.data.x[index]) 
     203            return_data = self.model.calculate_Iq(self.data.x[index]) 
     204            if isinstance(return_data, tuple): 
     205                # see sasmodels beta_approx: SasviewModel.calculate_Iq 
     206                return_data, intermediate_results = return_data 
     207            output[index] = return_data 
     208 
     209        if intermediate_results: 
     210            # the model returns a callable which is then used to retrieve the data 
     211            intermediate_results = intermediate_results() 
     212        else: 
     213            # TODO: this conditional branch needs refactoring 
     214            sq_values = None 
     215            pq_values = None 
     216            s_model = None 
     217            p_model = None 
     218 
     219            if isinstance(self.model, MultiplicationModel): 
     220                s_model = self.model.s_model 
     221                p_model = self.model.p_model 
     222 
     223            elif hasattr(self.model, "calc_composition_models"): 
     224                results = self.model.calc_composition_models(self.data.x[index]) 
     225                if results is not None: 
     226                    pq_values, sq_values = results 
     227 
     228            if pq_values is None or sq_values is None: 
     229                if p_model is not None and s_model is not None: 
     230                    sq_values = numpy.zeros((len(self.data.x))) 
     231                    pq_values = numpy.zeros((len(self.data.x))) 
     232                    sq_values[index] = s_model.evalDistribution(self.data.x[index]) 
     233                    pq_values[index] = p_model.evalDistribution(self.data.x[index]) 
     234 
     235            if pq_values is not None and sq_values is not None: 
     236                intermediate_results  = { 
     237                    "P(Q)": pq_values, 
     238                    "S(Q)": sq_values 
     239                } 
     240            else: 
     241                intermediate_results = {} 
    215242 
    216243        elapsed = time.time() - self.starttime 
     
    223250            source = self.source, unsmeared_output = unsmeared_output, 
    224251            unsmeared_data = unsmeared_data, unsmeared_error = unsmeared_error, 
    225             pq_values = pq_values, sq_values = sq_values) 
     252            intermediate_results = intermediate_results) 
    226253 
    227254        if LocalConfig.USING_TWISTED: 
Note: See TracChangeset for help on using the changeset viewer.