Ignore:
File:
1 edited

Legend:

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

    r2df558e r5181e9b  
    101101        elapsed = time.time() - self.starttime 
    102102 
     103        res = dict(image = output, data = self.data, page_id = self.page_id, 
     104            model = self.model, state = self.state, 
     105            toggle_mode_on = self.toggle_mode_on, elapsed = elapsed, 
     106            index = index_model, fid = self.fid, 
     107            qmin = self.qmin, qmax = self.qmax, 
     108            weight = self.weight, update_chisqr = self.update_chisqr, 
     109            source = self.source) 
     110 
    103111        if LocalConfig.USING_TWISTED: 
    104             return (output, 
    105                     self.data, 
    106                     self.page_id, 
    107                     self.model, 
    108                     self.state, 
    109                     self.toggle_mode_on, 
    110                     elapsed, 
    111                     index_model, 
    112                     self.fid, 
    113                     self.qmin, 
    114                     self.qmax, 
    115                     self.weight, 
    116                     self.update_chisqr, 
    117                     self.source) 
    118         else: 
    119             self.completefn((output, 
    120                            self.data, 
    121                            self.page_id, 
    122                            self.model, 
    123                            self.state, 
    124                            self.toggle_mode_on, 
    125                            elapsed, 
    126                            index_model, 
    127                            self.fid, 
    128                            self.qmin, 
    129                            self.qmax, 
    130                            self.weight, 
    131                            #qstep=self.qstep, 
    132                            self.update_chisqr, 
    133                            self.source)) 
    134  
     112            return res 
     113        else: 
     114            self.completefn(res) 
    135115 
    136116class Calc1D(CalcThread): 
     
    184164        index = (self.qmin <= self.data.x) & (self.data.x <= self.qmax) 
    185165 
     166        intermediate_results = None 
     167 
    186168        # If we use a smearer, also return the unsmeared model 
    187169        unsmeared_output = None 
     
    194176            mask = self.data.x[first_bin:last_bin+1] 
    195177            unsmeared_output = numpy.zeros((len(self.data.x))) 
    196             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 
    197185            output = self.smearer(unsmeared_output, first_bin, last_bin) 
    198186 
     
    213201                unsmeared_error=unsmeared_error 
    214202        else: 
    215             output[index] = self.model.evalDistribution(self.data.x[index]) 
    216  
    217         sq_values = None 
    218         pq_values = None 
    219         s_model = None 
    220         p_model = None 
    221         if isinstance(self.model, MultiplicationModel): 
    222             s_model = self.model.s_model 
    223             p_model = self.model.p_model 
    224         elif hasattr(self.model, "calc_composition_models"): 
    225             results = self.model.calc_composition_models(self.data.x[index]) 
    226             if results is not None: 
    227                 pq_values, sq_values = results 
    228  
    229         if pq_values is None or sq_values is None: 
    230             if p_model is not None and s_model is not None: 
    231                 sq_values = numpy.zeros((len(self.data.x))) 
    232                 pq_values = numpy.zeros((len(self.data.x))) 
    233                 sq_values[index] = s_model.evalDistribution(self.data.x[index]) 
    234                 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 = {} 
    235242 
    236243        elapsed = time.time() - self.starttime 
    237244 
     245        res = dict(x = self.data.x[index], y = output[index], 
     246            page_id = self.page_id, state = self.state, weight = self.weight, 
     247            fid = self.fid, toggle_mode_on = self.toggle_mode_on, 
     248            elapsed = elapsed, index = index, model = self.model, 
     249            data = self.data, update_chisqr = self.update_chisqr, 
     250            source = self.source, unsmeared_output = unsmeared_output, 
     251            unsmeared_data = unsmeared_data, unsmeared_error = unsmeared_error, 
     252            intermediate_results = intermediate_results) 
     253 
    238254        if LocalConfig.USING_TWISTED: 
    239             return (self.data.x[index], output[index], 
    240                     self.page_id, 
    241                     self.state, 
    242                     self.weight, 
    243                     self.fid, 
    244                     self.toggle_mode_on, 
    245                     elapsed, index, self.model, 
    246                     self.data, 
    247                     self.update_chisqr, 
    248                     self.source, 
    249                     unsmeared_output, unsmeared_data, unsmeared_error, 
    250                     pq_values, sq_values) 
    251         else: 
    252             self.completefn((self.data.x[index], output[index], 
    253                         self.page_id, 
    254                         self.state, 
    255                         self.weight, 
    256                         self.fid, 
    257                         self.toggle_mode_on, 
    258                         elapsed, index, self.model, 
    259                         self.data, 
    260                         self.update_chisqr, 
    261                         self.source, 
    262                         unsmeared_output, unsmeared_data, unsmeared_error, 
    263                         pq_values, sq_values)) 
     255            return res 
     256        else: 
     257            self.completefn(res) 
    264258 
    265259    def results(self): 
Note: See TracChangeset for help on using the changeset viewer.