model_thread.py @ 847091f

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 847091f was fb8daaaf, checked in by Gervaise Alina <gervyh@…>, 16 years ago
plotting with smearing fixed
Property mode set to `100644`
File size: 10.2 KB

Line
1	import time
2	from calcthread import CalcThread
3	import sys
4	import numpy,math
5
6	class Calc2D_all(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, model,
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
25	self.x = x
26	self.y = y
27	self.model = model
28	self.starttime = 0
29
30	def compute(self):
31	x = self.x
32	y = self.y
33	output = numpy.zeros((len(x),len(y)))
34
35	self.starttime = time.time()
36	lx = len(self.x)
37
38	#for i_x in range(int(len(self.x)/2)):
39	for i_x in range(len(self.x)):
40	if i_x%2==1:
41	continue
42
43	# Check whether we need to bail out
44	self.update(output=output)
45	self.isquit()
46
47	for i_y in range(len(self.y)):
48	value = self.model.runXY([self.x[i_x], self.y[i_y]])
49	output[i_y][i_x] = value
50	#output[lx-i_y-1][lx-i_x-1] = value
51
52	if lx%2==1:
53	i_x = int(len(self.x)/2)
54	for i_y in range(len(self.y)):
55	value = self.model.runXY([self.x[i_x], self.y[i_y]])
56	output[i_y][i_x] = value
57
58	#for i_x in range(int(len(self.x)/2)):
59	for i_x in range(len(self.x)):
60	if not i_x%2==1:
61	continue
62
63	# Check whether we need to bail out
64	self.update(output=output)
65	self.isquit()
66
67	for i_y in range(len(self.y)):
68	value = self.model.runXY([self.x[i_x], self.y[i_y]])
69	output[i_y][i_x] = value
70	#output[lx-i_y-1][lx-i_x-1] = value
71
72	elapsed = time.time()-self.starttime
73	self.complete(output=output, elapsed=elapsed)
74
75
76	class Calc2D(CalcThread):
77	"""
78	Compute 2D model
79	This calculation assumes a 2-fold symmetry of the model
80	where points are computed for one half of the detector
81	and I(qx, qy) = I(-qx, -qy) is assumed.
82	"""
83
84	def __init__(self, x, y, data,model,qmin, qmax,qstep,
85	completefn = None,
86	updatefn = None,
87	yieldtime = 0.01,
88	worktime = 0.01
89	):
90	CalcThread.__init__(self,completefn,
91	updatefn,
92	yieldtime,
93	worktime)
94	self.qmin= qmin
95	self.qmax= qmax
96	self.qstep= qstep
97	self.x = x
98	self.y = y
99	self.data= data
100	## the model on to calculate
101	self.model = model
102	self.starttime = 0
103
104	def compute(self):
105	"""
106	Compute the data given a model function
107	"""
108	x = self.x
109	y = self.y
110	output = numpy.zeros((len(x),len(y)))
111	if self.qmin==None:
112	self.qmin = 0
113	if self.qmax== None:
114	if self.data !=None:
115	newx= math.pow(max(math.fabs(self.data.xmax),math.fabs(self.data.xmin)),2)
116	newy= math.pow(max(math.fabs(self.data.ymax),math.fabs(self.data.ymin)),2)
117	self.qmax=math.sqrt( newx + newy )
118	else:
119	self.qmax= max(self.x)
120
121	self.starttime = time.time()
122	lx = len(self.x)
123	for i_x in range(len(self.x)):
124	# Check whether we need to bail out
125	self.update(output=output )
126	self.isquit()
127
128	for i_y in range(int(len(self.y))):
129	radius = math.sqrt(self.x[i_x]self.x[i_x]+self.y[i_y]self.y[i_y])
130	## for data ignore the qmax
131	if self.data == None:
132	if self.qmin <= radius :
133	value = self.model.runXY( [self.x[i_x], self.y[i_y]] )
134	output[i_y][i_x] =value
135	else:
136	output[i_y][i_x] =0
137	else:
138	if self.qmin <= radius and radius<= self.qmax:
139	value = self.model.runXY( [self.x[i_x], self.y[i_y]] )
140	output[i_y][i_x] =value
141	else:
142	output[i_y][i_x] =0
143
144	elapsed = time.time()-self.starttime
145	self.complete( image = output,
146	data = self.data ,
147	model = self.model,
148	elapsed = elapsed,
149	qmin = self.qmin,
150	qmax =self.qmax,
151	qstep = self.qstep )
152
153
154	class Calc2D_4fold(CalcThread):
155	"""
156	Compute 2D model
157	This calculation assumes a 4-fold symmetry of the model.
158	Really is the same calculation time since we have to
159	calculate points for 0<phi<pi anyway.
160	"""
161
162	def __init__(self, x, y, model,
163	completefn = None,
164	updatefn = None,
165	yieldtime = 0.01,
166	worktime = 0.01
167	):
168	CalcThread.__init__(self,completefn,
169	updatefn,
170	yieldtime,
171	worktime)
172	self.x = x
173	self.y = y
174	self.model = model
175	self.starttime = 0
176
177	def compute(self):
178	x = self.x
179	y = self.y
180	output = numpy.zeros((len(x),len(y)))
181
182	self.starttime = time.time()
183	lx = len(self.x)
184
185	for i_x in range(int(len(self.x)/2)):
186	if i_x%2==1:
187	continue
188
189	# Check whether we need to bail out
190	self.update(output=output)
191	self.isquit()
192
193	for i_y in range(int(len(self.y)/2)):
194	value1 = self.model.runXY([self.x[i_x], self.y[i_y]])
195	value2 = self.model.runXY([self.x[i_x], self.y[lx-i_y-1]])
196	output[i_y][i_x] = value1 + value2
197	output[lx-i_y-1][lx-i_x-1] = value1 + value2
198	output[lx-i_y-1][i_x] = value1 + value2
199	output[i_y][lx-i_x-1] = value1 + value2
200
201	if lx%2==1:
202	i_x = int(len(self.x)/2)
203	for i_y in range(int(len(self.y)/2)):
204	value1 = self.model.runXY([self.x[i_x], self.y[i_y]])
205	value2 = self.model.runXY([self.x[i_x], self.y[lx-i_y-1]])
206	output[i_y][i_x] = value1 + value2
207	output[lx-i_y-1][lx-i_x-1] = value1 + value2
208	output[lx-i_y-1][i_x] = value1 + value2
209	output[i_y][lx-i_x-1] = value1 + value2
210
211	for i_x in range(int(len(self.x)/2)):
212	if not i_x%2==1:
213	continue
214
215	# Check whether we need to bail out
216	self.update(output=output)
217	self.isquit()
218
219	for i_y in range(int(len(self.y)/2)):
220	value1 = self.model.runXY([self.x[i_x], self.y[i_y]])
221	value2 = self.model.runXY([self.x[i_x], self.y[lx-i_y-1]])
222	output[i_y][i_x] = value1 + value2
223	output[lx-i_y-1][lx-i_x-1] = value1 + value2
224	output[lx-i_y-1][i_x] = value1 + value2
225	output[i_y][lx-i_x-1] = value1 + value2
226
227	elapsed = time.time()-self.starttime
228	self.complete(output=output, elapsed=elapsed)
229
230
231
232	class Calc1D(CalcThread):
233	"""Compute 1D data"""
234
235	def __init__(self, x, model,
236	data=None,
237	qmin=None,
238	qmax=None,
239	smearer=None,
240	completefn = None,
241	updatefn = None,
242	yieldtime = 0.01,
243	worktime = 0.01
244	):
245	CalcThread.__init__(self,completefn,
246	updatefn,
247	yieldtime,
248	worktime)
249	self.x = x
250	self.data= data
251	self.qmin= qmin
252	self.qmax= qmax
253	self.model = model
254	self.smearer= smearer
255	self.starttime = 0
256
257	def compute(self):
258	"""
259	Compute model 1d value given qmin , qmax , x value
260	"""
261	output = numpy.zeros(len(self.x))
262
263	self.starttime = time.time()
264
265	for i_x in range(len(self.x)):
266	self.update(x= self.x, output=output )
267	# Check whether we need to bail out
268	self.isquit()
269	if self.qmin <= self.x[i_x] and self.x[i_x] <= self.qmax:
270	value = self.model.run(self.x[i_x])
271	output[i_x] = value
272	##smearer the ouput of the plot
273	if self.smearer!=None:
274	output = self.smearer(output)
275
276	elapsed = time.time()-self.starttime
277	self.complete(x= self.x, y= output,
278	elapsed=elapsed, model= self.model, data=self.data)
279
280
281
282	class CalcCommandline:
283	def __init__(self, n=20000):
284	#print thread.get_ident()
285	from sans.models.CylinderModel import CylinderModel
286
287	model = CylinderModel()
288
289
290	print model.runXY([0.01, 0.02])
291
292	qmax = 0.01
293	qstep = 0.0001
294	self.done = False
295
296	x = numpy.arange(-qmax, qmax+qstep*0.01, qstep)
297	y = numpy.arange(-qmax, qmax+qstep*0.01, qstep)
298
299
300	calc_thread_2D = Calc2D(x, y, None, model.clone(),-qmax, qmax,qstep,
301	completefn=self.complete,
302	updatefn=self.update ,
303	yieldtime=0.0)
304
305	calc_thread_2D.queue()
306	calc_thread_2D.ready(2.5)
307
308	while not self.done:
309	time.sleep(1)
310
311	def update(self,output):
312	print "update"
313
314	def complete(self, image, data, model, elapsed, qmin, qmax, qstep ):
315	print "complete"
316	self.done = True
317
318	if __name__ == "__main__":
319	CalcCommandline()
320

Note: See TracBrowser for help on using the repository browser.

SasView

source: sasview/sansview/perspectives/fitting/model_thread.py @ 847091f

Download in other formats: