model_thread.py @ cbcdd2c

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalc

Last change on this file since cbcdd2c was cbcdd2c, checked in by Piotr Rozyczko <rozyczko@…>, 7 years ago
QModel items conversion into SasModel? parameters + data display SASVIEW-535
Property mode set to `100644`
File size: 8.7 KB

Line
1	"""
2	Calculation thread for modeling
3	"""
4
5	import time
6	import numpy
7	import math
8	from sas.sascalc.data_util.calcthread import CalcThread
9
10	class Calc2D(CalcThread):
11	"""
12	Compute 2D model
13	This calculation assumes a 2-fold symmetry of the model
14	where points are computed for one half of the detector
15	and I(qx, qy) = I(-qx, -qy) is assumed.
16	"""
17	def __init__(self, data, model, smearer, qmin, qmax, page_id,
18	state=None,
19	weight=None,
20	fid=None,
21	toggle_mode_on=False,
22	completefn=None,
23	updatefn=None,
24	update_chisqr=True,
25	source='model',
26	yieldtime=0.04,
27	worktime=0.04,
28	exception_handler=None,
29	):
30	CalcThread.__init__(self, completefn, updatefn, yieldtime, worktime,
31	exception_handler=exception_handler)
32	self.qmin = qmin
33	self.qmax = qmax
34	self.weight = weight
35	self.fid = fid
36	#self.qstep = qstep
37	self.toggle_mode_on = toggle_mode_on
38	self.data = data
39	self.page_id = page_id
40	self.state = None
41	# the model on to calculate
42	self.model = model
43	self.smearer = smearer
44	self.starttime = 0
45	self.update_chisqr = update_chisqr
46	self.source = source
47
48	def compute(self):
49	"""
50	Compute the data given a model function
51	"""
52	self.starttime = time.time()
53	# Determine appropriate q range
54	if self.qmin == None:
55	self.qmin = 0
56	if self.qmax == None:
57	if self.data != None:
58	newx = math.pow(max(math.fabs(self.data.xmax),
59	math.fabs(self.data.xmin)), 2)
60	newy = math.pow(max(math.fabs(self.data.ymax),
61	math.fabs(self.data.ymin)), 2)
62	self.qmax = math.sqrt(newx + newy)
63
64	if self.data is None:
65	msg = "Compute Calc2D receive data = %s.\n" % str(self.data)
66	raise ValueError, msg
67
68	# Define matrix where data will be plotted
69	radius = numpy.sqrt((self.data.qx_data * self.data.qx_data) + \
70	(self.data.qy_data * self.data.qy_data))
71
72	# For theory, qmax is based on 1d qmax
73	# so that must be mulitified by sqrt(2) to get actual max for 2d
74	index_model = (self.qmin <= radius) & (radius <= self.qmax)
75	index_model = index_model & self.data.mask
76	index_model = index_model & numpy.isfinite(self.data.data)
77
78	if self.smearer is not None:
79	# Set smearer w/ data, model and index.
80	fn = self.smearer
81	fn.set_model(self.model)
82	fn.set_index(index_model)
83	# Get necessary data from self.data and set the data for smearing
84	fn.get_data()
85	# Calculate smeared Intensity
86	#(by Gaussian averaging): DataLoader/smearing2d/Smearer2D()
87	value = fn.get_value()
88	else:
89	# calculation w/o smearing
90	value = self.model.evalDistribution(\
91	[self.data.qx_data[index_model],
92	self.data.qy_data[index_model]])
93	output = numpy.zeros(len(self.data.qx_data))
94	# output default is None
95	# This method is to distinguish between masked
96	#point(nan) and data point = 0.
97	output = output / output
98	# set value for self.mask==True, else still None to Plottools
99	output[index_model] = value
100	elapsed = time.time() - self.starttime
101	#self.complete(image=output,
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)
116	return (output,
117	self.data,
118	self.page_id,
119	self.model,
120	self.state,
121	self.toggle_mode_on,
122	elapsed,
123	index_model,
124	self.fid,
125	self.qmin,
126	self.qmax,
127	self.weight,
128	self.update_chisqr,
129	self.source)
130
131
132	class Calc1D(CalcThread):
133	"""
134	Compute 1D data
135	"""
136	def __init__(self, model,
137	page_id,
138	data,
139	fid=None,
140	qmin=None,
141	qmax=None,
142	weight=None,
143	smearer=None,
144	toggle_mode_on=False,
145	state=None,
146	completefn=None,
147	update_chisqr=True,
148	source='model',
149	updatefn=None,
150	yieldtime=0.01,
151	worktime=0.01,
152	exception_handler=None,
153	):
154	"""
155	"""
156	CalcThread.__init__(self, completefn, updatefn, yieldtime, worktime,
157	exception_handler=exception_handler)
158	self.fid = fid
159	self.data = data
160	self.qmin = qmin
161	self.qmax = qmax
162	self.model = model
163	self.weight = weight
164	self.toggle_mode_on = toggle_mode_on
165	self.state = state
166	self.page_id = page_id
167	self.smearer = smearer
168	self.starttime = 0
169	self.update_chisqr = update_chisqr
170	self.source = source
171	self.out = None
172	self.index = None
173
174	def compute(self):
175	"""
176	Compute model 1d value given qmin , qmax , x value
177	"""
178	self.starttime = time.time()
179	output = numpy.zeros((len(self.data.x)))
180	index = (self.qmin <= self.data.x) & (self.data.x <= self.qmax)
181
182	##smearer the ouput of the plot
183	if self.smearer is not None:
184	first_bin, last_bin = self.smearer.get_bin_range(self.qmin,
185	self.qmax)
186	mask = self.data.x[first_bin:last_bin+1]
187	output[first_bin:last_bin+1] = self.model.evalDistribution(mask)
188	output = self.smearer(output, first_bin, last_bin)
189	else:
190	output[index] = self.model.evalDistribution(self.data.x[index])
191
192	elapsed = time.time() - self.starttime
193
194	#self.complete(x=self.data.x[index], y=output[index],
195	# page_id=self.page_id,
196	# state=self.state,
197	# weight=self.weight,
198	# fid=self.fid,
199	# toggle_mode_on=self.toggle_mode_on,
200	# elapsed=elapsed, index=index, model=self.model,
201	# data=self.data,
202	# update_chisqr=self.update_chisqr,
203	# source=self.source)
204	return (self.data.x[index], output[index],
205	self.page_id,
206	self.state,
207	self.weight,
208	self.fid,
209	self.toggle_mode_on,
210	elapsed, index, self.model,
211	self.data,
212	self.update_chisqr,
213	self.source)
214
215	def results(self):
216	"""
217	Send resuts of the computation
218	"""
219	return [self.out, self.index]
220
221	"""
222	Example: ::
223
224	class CalcCommandline:
225	def __init__(self, n=20000):
226	#print thread.get_ident()
227	from sas.models.CylinderModel import CylinderModel
228
229	model = CylinderModel()
230
231
232	print model.runXY([0.01, 0.02])
233
234	qmax = 0.01
235	qstep = 0.0001
236	self.done = False
237
238	x = numpy.arange(-qmax, qmax+qstep*0.01, qstep)
239	y = numpy.arange(-qmax, qmax+qstep*0.01, qstep)
240
241
242	calc_thread_2D = Calc2D(x, y, None, model.clone(),None,
243	-qmax, qmax,qstep,
244	completefn=self.complete,
245	updatefn=self.update ,
246	yieldtime=0.0)
247
248	calc_thread_2D.queue()
249	calc_thread_2D.ready(2.5)
250
251	while not self.done:
252	time.sleep(1)
253
254	def update(self,output):
255	print "update"
256
257	def complete(self, image, data, model, elapsed, qmin, qmax,index, qstep ):
258	print "complete"
259	self.done = True
260
261	if __name__ == "__main__":
262	CalcCommandline()
263	"""

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

SasView

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

Download in other formats: