source: sasview/src/sas/sasgui/perspectives/fitting/model_thread.py @ 250f2393

Last change on this file since 250f2393 was 69363c7, checked in by Paul Kienzle <pkienzle@…>, 7 years ago

Merge branch 'master' into ticket-853-fit-gui-to-calc

  • Property mode set to 100644
File size: 10.0 KB
RevLine 
[f32d144]1"""
[ba8d326]2Calculation thread for modeling
[f32d144]3"""
[5062bbf]4
[bb18ef1]5import time
[7e7e806]6import math
[65f3930]7
8import numpy as np
9
[b699768]10from sas.sascalc.data_util.calcthread import CalcThread
[ca4d985]11from sas.sascalc.fit.MultiplicationModel import MultiplicationModel
[5062bbf]12
[bb18ef1]13class Calc2D(CalcThread):
14    """
[5062bbf]15    Compute 2D model
16    This calculation assumes a 2-fold symmetry of the model
17    where points are computed for one half of the detector
18    and I(qx, qy) = I(-qx, -qy) is assumed.
[bb18ef1]19    """
[f32d144]20    def __init__(self, data, model, smearer, qmin, qmax, page_id,
[5ef55d2]21                 state=None,
[62f851f]22                 weight=None,
[f64a4b7]23                 fid=None,
[fa65e99]24                 toggle_mode_on=False,
[7e7e806]25                 completefn=None,
26                 updatefn=None,
[2296316]27                 update_chisqr=True,
[e3f6ef5]28                 source='model',
[7e7e806]29                 yieldtime=0.04,
[934ce649]30                 worktime=0.04,
31                 exception_handler=None,
[ba8d326]32                ):
[934ce649]33        CalcThread.__init__(self, completefn, updatefn, yieldtime, worktime,
34                            exception_handler=exception_handler)
[7e7e806]35        self.qmin = qmin
36        self.qmax = qmax
[62f851f]37        self.weight = weight
[f64a4b7]38        self.fid = fid
[7e7e806]39        #self.qstep = qstep
[fa65e99]40        self.toggle_mode_on = toggle_mode_on
[7e7e806]41        self.data = data
[66ff250]42        self.page_id = page_id
[5ef55d2]43        self.state = None
[1b001a7]44        # the model on to calculate
[bb18ef1]45        self.model = model
[7e7e806]46        self.smearer = smearer
[f32d144]47        self.starttime = 0
[2296316]48        self.update_chisqr = update_chisqr
[e3f6ef5]49        self.source = source
[2f4b430]50
[bb18ef1]51    def compute(self):
52        """
[5062bbf]53        Compute the data given a model function
[bb18ef1]54        """
[1b001a7]55        self.starttime = time.time()
56        # Determine appropriate q range
[235f514]57        if self.qmin is None:
[c77d859]58            self.qmin = 0
[235f514]59        if self.qmax is None:
[7432acb]60            if self.data is not None:
[ba8d326]61                newx = max(math.fabs(self.data.xmax), math.fabs(self.data.xmin))
62                newy = max(math.fabs(self.data.ymax), math.fabs(self.data.ymin))
63                self.qmax = math.sqrt(newx**2 + newy**2)
[2f4b430]64
[7e7e806]65        if self.data is None:
[f32d144]66            msg = "Compute Calc2D receive data = %s.\n" % str(self.data)
[7e7e806]67            raise ValueError, msg
[2f4b430]68
[f32d144]69        # Define matrix where data will be plotted
[ba8d326]70        radius = np.sqrt(self.data.qx_data**2 + self.data.qy_data**2)
[43e685d]71
[ba8d326]72        # For theory, qmax is based on 1d qmax
[e575db9]73        # so that must be mulitified by sqrt(2) to get actual max for 2d
[7e7e806]74        index_model = (self.qmin <= radius) & (radius <= self.qmax)
[ba8d326]75        index_model &= self.data.mask
76        index_model &= np.isfinite(self.data.data)
[2f4b430]77
[7e7e806]78        if self.smearer is not None:
[f72333f]79            # Set smearer w/ data, model and index.
80            fn = self.smearer
81            fn.set_model(self.model)
82            fn.set_index(index_model)
[f32d144]83            # Calculate smeared Intensity
[7e7e806]84            #(by Gaussian averaging): DataLoader/smearing2d/Smearer2D()
[f72333f]85            value = fn.get_value()
[f32d144]86        else:
[f72333f]87            # calculation w/o smearing
[d3911e3]88            value = self.model.evalDistribution([
89                self.data.qx_data[index_model],
90                self.data.qy_data[index_model]
91            ])
[24b3821]92        # Initialize output to NaN so masked elements do not get plotted.
93        output = np.empty_like(self.data.qx_data)
[43e685d]94        # output default is None
[f32d144]95        # This method is to distinguish between masked
[7e7e806]96        #point(nan) and data point = 0.
[24b3821]97        output[:] = np.NaN
[43e685d]98        # set value for self.mask==True, else still None to Plottools
[f32d144]99        output[index_model] = value
100        elapsed = time.time() - self.starttime
[6bbeacd4]101        self.complete(image=output,
[ba8d326]102                      data=self.data,
103                      page_id=self.page_id,
104                      model=self.model,
105                      state=self.state,
106                      toggle_mode_on=self.toggle_mode_on,
107                      elapsed=elapsed,
108                      index=index_model,
109                      fid=self.fid,
110                      qmin=self.qmin,
111                      qmax=self.qmax,
112                      weight=self.weight,
113                      #qstep=self.qstep,
114                      update_chisqr=self.update_chisqr,
115                      source=self.source)
[2f4b430]116
[bb18ef1]117
118class Calc1D(CalcThread):
[5062bbf]119    """
120    Compute 1D data
121    """
[7e7e806]122    def __init__(self, model,
[66ff250]123                 page_id,
[7e7e806]124                 data,
[f64a4b7]125                 fid=None,
[bb18ef1]126                 qmin=None,
127                 qmax=None,
[62f851f]128                 weight=None,
[bb18ef1]129                 smearer=None,
[fa65e99]130                 toggle_mode_on=False,
[5ef55d2]131                 state=None,
[f32d144]132                 completefn=None,
[2296316]133                 update_chisqr=True,
[e3f6ef5]134                 source='model',
[7e7e806]135                 updatefn=None,
136                 yieldtime=0.01,
[934ce649]137                 worktime=0.01,
138                 exception_handler=None,
[ba8d326]139                ):
[5062bbf]140        """
141        """
[934ce649]142        CalcThread.__init__(self, completefn, updatefn, yieldtime, worktime,
143                            exception_handler=exception_handler)
[f64a4b7]144        self.fid = fid
[fa65e99]145        self.data = data
146        self.qmin = qmin
147        self.qmax = qmax
[bb18ef1]148        self.model = model
[62f851f]149        self.weight = weight
[fa65e99]150        self.toggle_mode_on = toggle_mode_on
[5ef55d2]151        self.state = state
[66ff250]152        self.page_id = page_id
[fa65e99]153        self.smearer = smearer
[bb18ef1]154        self.starttime = 0
[2296316]155        self.update_chisqr = update_chisqr
[e3f6ef5]156        self.source = source
[da7cacb]157        self.out = None
158        self.index = None
[2f4b430]159
[bb18ef1]160    def compute(self):
[c77d859]161        """
[f32d144]162        Compute model 1d value given qmin , qmax , x value
[c77d859]163        """
[bb18ef1]164        self.starttime = time.time()
[9a5097c]165        output = np.zeros((len(self.data.x)))
[f32d144]166        index = (self.qmin <= self.data.x) & (self.data.x <= self.qmax)
[2f4b430]167
[c807957]168        # If we use a smearer, also return the unsmeared model
[804fefa]169        unsmeared_output = None
170        unsmeared_data = None
171        unsmeared_error = None
[f32d144]172        ##smearer the ouput of the plot
[7e7e806]173        if self.smearer is not None:
[f32d144]174            first_bin, last_bin = self.smearer.get_bin_range(self.qmin,
[7e7e806]175                                                             self.qmax)
[a3f125f0]176            mask = self.data.x[first_bin:last_bin+1]
[9a5097c]177            unsmeared_output = np.zeros((len(self.data.x)))
[804fefa]178            unsmeared_output[first_bin:last_bin+1] = self.model.evalDistribution(mask)
[c1c9929]179            self.smearer.model = self.model
[804fefa]180            output = self.smearer(unsmeared_output, first_bin, last_bin)
[286c757]181
[804fefa]182            # Rescale data to unsmeared model
[286c757]183            # Check that the arrays are compatible. If we only have a model but no data,
184            # the length of data.y will be zero.
[9a5097c]185            if isinstance(self.data.y, np.ndarray) and output.shape == self.data.y.shape:
186                unsmeared_data = np.zeros((len(self.data.x)))
187                unsmeared_error = np.zeros((len(self.data.x)))
[286c757]188                unsmeared_data[first_bin:last_bin+1] = self.data.y[first_bin:last_bin+1]\
189                                                        * unsmeared_output[first_bin:last_bin+1]\
190                                                        / output[first_bin:last_bin+1]
191                unsmeared_error[first_bin:last_bin+1] = self.data.dy[first_bin:last_bin+1]\
192                                                        * unsmeared_output[first_bin:last_bin+1]\
193                                                        / output[first_bin:last_bin+1]
[ba8d326]194                unsmeared_output = unsmeared_output[index]
195                unsmeared_data = unsmeared_data[index]
196                unsmeared_error = unsmeared_error
[e627f19]197        else:
[7e7e806]198            output[index] = self.model.evalDistribution(self.data.x[index])
[2f4b430]199
[24b3821]200        x=self.data.x[index]
201        y=output[index]
[b0bebdc]202        sq_values = None
203        pq_values = None
[ca4d985]204        if isinstance(self.model, MultiplicationModel):
[b0bebdc]205            s_model = self.model.s_model
206            p_model = self.model.p_model
[24b3821]207            sq_values = s_model.evalDistribution(x)
208            pq_values = p_model.evalDistribution(x)
209        elif hasattr(self.model, "calc_composition_models"):
210            results = self.model.calc_composition_models(x)
211            if results is not None:
[0f9ea1c]212                pq_values, sq_values = results
[b0bebdc]213
[ca4d985]214
[5062bbf]215        elapsed = time.time() - self.starttime
[2f4b430]216
[24b3821]217        self.complete(x=x, y=y,
[66ff250]218                      page_id=self.page_id,
[5ef55d2]219                      state=self.state,
[62f851f]220                      weight=self.weight,
[f64a4b7]221                      fid=self.fid,
[fa65e99]222                      toggle_mode_on=self.toggle_mode_on,
[f32d144]223                      elapsed=elapsed, index=index, model=self.model,
224                      data=self.data,
225                      update_chisqr=self.update_chisqr,
[c807957]226                      source=self.source,
[804fefa]227                      unsmeared_model=unsmeared_output,
228                      unsmeared_data=unsmeared_data,
[ca4d985]229                      unsmeared_error=unsmeared_error,
[b0bebdc]230                      pq_model=pq_values,
231                      sq_model=sq_values)
[2f4b430]232
[f72333f]233    def results(self):
234        """
[5062bbf]235        Send resuts of the computation
[f72333f]236        """
237        return [self.out, self.index]
[5062bbf]238
239"""
240Example: ::
[2f4b430]241
[5062bbf]242    class CalcCommandline:
243        def __init__(self, n=20000):
[65f3930]244            #print(thread.get_ident())
[2f4b430]245
[65f3930]246            from sasmodels.sasview_model import _make_standard_model
247            cylinder = _make_standard_model('cylinder')
248            model = cylinder()
[2f4b430]249
[65f3930]250            print(model.runXY([0.01, 0.02]))
[2f4b430]251
[5062bbf]252            qmax = 0.01
253            qstep = 0.0001
254            self.done = False
[2f4b430]255
[5062bbf]256            x = numpy.arange(-qmax, qmax+qstep*0.01, qstep)
257            y = numpy.arange(-qmax, qmax+qstep*0.01, qstep)
[2f4b430]258
[5062bbf]259            calc_thread_2D = Calc2D(x, y, None, model.clone(),None,
260                                    -qmax, qmax,qstep,
[65f3930]261                                    completefn=self.complete,
262                                    updatefn=self.update ,
263                                    yieldtime=0.0)
[2f4b430]264
[5062bbf]265            calc_thread_2D.queue()
266            calc_thread_2D.ready(2.5)
[2f4b430]267
[5062bbf]268            while not self.done:
269                time.sleep(1)
[2f4b430]270
[5062bbf]271        def update(self,output):
[65f3930]272            print("update")
[2f4b430]273
[5062bbf]274        def complete(self, image, data, model, elapsed, qmin, qmax,index, qstep ):
[65f3930]275            print("complete")
[5062bbf]276            self.done = True
[2f4b430]277
[5062bbf]278    if __name__ == "__main__":
279        CalcCommandline()
[f32d144]280"""
Note: See TracBrowser for help on using the repository browser.