source: sasview/sansview/perspectives/fitting/model_thread.py @ 64017a8

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 64017a8 was 43e685d, checked in by Jae Cho <jhjcho@…>, 15 years ago

Made sure that if I ==None the I point is not taken account into the calculation.

  • Property mode set to 100644
File size: 6.5 KB
Line 
1import time
2from data_util.calcthread import CalcThread
3import sys
4import numpy,math
5
6class Calc2D(CalcThread):
7    """
8        Compute 2D model
9        This calculation assumes a 2-fold symmetry of the model
10        where points are computed for one half of the detector
11        and I(qx, qy) = I(-qx, -qy) is assumed.
12    """
13   
14    def __init__(self, x, y, data,model,qmin, qmax,qstep,
15                 completefn = None,
16                 updatefn   = None,
17                 yieldtime  = 0.01,
18                 worktime   = 0.01
19                 ):
20        CalcThread.__init__(self,completefn,
21                 updatefn,
22                 yieldtime,
23                 worktime)
24        self.qmin= qmin
25        self.qmax= qmax
26        self.qstep= qstep
27
28        self.x = x
29        self.y = y
30        self.data= data
31        # the model on to calculate
32        self.model = model
33        self.starttime = 0 
34       
35    def compute(self):
36        """
37            Compute the data given a model function
38        """
39        self.starttime = time.time()
40        # Determine appropriate q range
41        if self.qmin==None:
42            self.qmin = 0
43        if self.qmax== None:
44            if self.data !=None:
45                newx= math.pow(max(math.fabs(self.data.xmax),math.fabs(self.data.xmin)),2)
46                newy= math.pow(max(math.fabs(self.data.ymax),math.fabs(self.data.ymin)),2)
47                self.qmax=math.sqrt( newx + newy )
48       
49        if self.data != None:
50            self.I_data = self.data.data
51            self.qx_data = self.data.qx_data
52            self.qy_data = self.data.qy_data
53            self.mask    = self.data.mask
54        else:         
55            xbin =  numpy.linspace(start= -1*self.qmax,
56                                   stop= self.qmax,
57                                   num= self.qstep,
58                                   endpoint=True ) 
59            ybin = numpy.linspace(start= -1*self.qmax,
60                                   stop= self.qmax,
61                                   num= self.qstep,
62                                   endpoint=True )           
63           
64            new_xbin = numpy.tile(xbin, (len(ybin),1))
65            new_ybin = numpy.tile(ybin, (len(xbin),1))
66            new_ybin = new_ybin.swapaxes(0,1)
67            new_xbin = new_xbin.flatten()
68            new_ybin = new_ybin.flatten()
69            self.qy_data = new_ybin
70            self.qx_data = new_xbin
71            # fake data
72            self.I_data = numpy.ones(len(self.qx_data))
73           
74            self.mask = numpy.ones(len(self.qx_data),dtype=bool)
75           
76        # Define matrix where data will be plotted   
77        radius= numpy.sqrt( self.qx_data*self.qx_data + self.qy_data*self.qy_data )
78        index_data= (self.qmin<= radius)&(self.mask)
79
80        # For theory, qmax is based on 1d qmax
81        # so that must be mulitified by sqrt(2) to get actual max for 2d
82        index_model = ((self.qmin <= radius)&(radius<= self.qmax))
83        self.mask = (index_model)&(self.mask)
84        self.mask = (self.mask)&(numpy.isfinite(self.I_data))
85        if self.data ==None:
86            # Only qmin value will be consider for the detector
87            self.mask = index_data 
88             
89        value = self.model.evalDistribution([self.qx_data[self.mask],self.qy_data[self.mask]] )
90
91        output = numpy.zeros(len(self.mask))
92       
93        # output default is None
94        # This method is to distinguish between masked point and data point = 0.
95        output = output/output
96        # set value for self.mask==True, else still None to Plottools
97        output[self.mask] = value
98
99        elapsed = time.time()-self.starttime
100        self.complete( image = output,
101                       data = self.data , 
102                       model = self.model,
103                       elapsed = elapsed,
104                       qmin = self.qmin,
105                       qmax = self.qmax,
106                       qstep = self.qstep )
107       
108   
109   
110
111class Calc1D(CalcThread):
112    """Compute 1D data"""
113   
114    def __init__(self, x, model,
115                 data=None,
116                 qmin=None,
117                 qmax=None,
118                 smearer=None,
119                 completefn = None,
120                 updatefn   = None,
121                 yieldtime  = 0.01,
122                 worktime   = 0.01
123                 ):
124        CalcThread.__init__(self,completefn,
125                 updatefn,
126                 yieldtime,
127                 worktime)
128        self.x = numpy.array(x)
129        self.data= data
130        self.qmin= qmin
131        self.qmax= qmax
132        self.model = model
133        self.smearer= smearer
134        self.starttime = 0
135       
136    def compute(self):
137        """
138            Compute model 1d value given qmin , qmax , x value
139        """
140       
141        self.starttime = time.time()
142        output = numpy.zeros((len(self.x)))
143        index= (self.qmin <= self.x)& (self.x <= self.qmax)
144     
145        ##smearer the ouput of the plot   
146        if self.smearer!=None:
147            first_bin, last_bin = self.smearer.get_bin_range(self.qmin, self.qmax)
148            output[first_bin:last_bin] = self.model.evalDistribution(self.x[first_bin:last_bin])
149            output = self.smearer(output, first_bin, last_bin) 
150        else:
151            output[index] = self.model.evalDistribution(self.x[index])
152         
153        elapsed = time.time()-self.starttime
154       
155        self.complete(x= self.x[index], y= output[index], 
156                      elapsed=elapsed, model= self.model, data=self.data)
157       
158 
159               
160class CalcCommandline:
161    def __init__(self, n=20000):
162        #print thread.get_ident()
163        from sans.models.CylinderModel import CylinderModel
164       
165        model = CylinderModel()
166       
167         
168        print model.runXY([0.01, 0.02])
169       
170        qmax = 0.01
171        qstep = 0.0001
172        self.done = False
173       
174        x = numpy.arange(-qmax, qmax+qstep*0.01, qstep)
175        y = numpy.arange(-qmax, qmax+qstep*0.01, qstep)
176   
177   
178        calc_thread_2D = Calc2D(x, y, None, model.clone(),-qmax, qmax,qstep,
179                                        completefn=self.complete,
180                                        updatefn=self.update ,
181                                        yieldtime=0.0)
182     
183        calc_thread_2D.queue()
184        calc_thread_2D.ready(2.5)
185       
186        while not self.done:
187            time.sleep(1)
188
189    def update(self,output):
190        print "update"
191
192    def complete(self, image, data, model, elapsed, qmin, qmax, qstep ):
193        print "complete"
194        self.done = True
195
196if __name__ == "__main__":
197    CalcCommandline()
198   
Note: See TracBrowser for help on using the repository browser.