model_thread.py @ 804fefa

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.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since 804fefa was 804fefa, checked in by Mathieu Doucet <doucetm@…>, 8 years ago
Add rescaled data (re #687)
Property mode set to `100644`
File size: 9.2 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
117
118	class Calc1D(CalcThread):
119	"""
120	Compute 1D data
121	"""
122	def __init__(self, model,
123	page_id,
124	data,
125	fid=None,
126	qmin=None,
127	qmax=None,
128	weight=None,
129	smearer=None,
130	toggle_mode_on=False,
131	state=None,
132	completefn=None,
133	update_chisqr=True,
134	source='model',
135	updatefn=None,
136	yieldtime=0.01,
137	worktime=0.01,
138	exception_handler=None,
139	):
140	"""
141	"""
142	CalcThread.__init__(self, completefn, updatefn, yieldtime, worktime,
143	exception_handler=exception_handler)
144	self.fid = fid
145	self.data = data
146	self.qmin = qmin
147	self.qmax = qmax
148	self.model = model
149	self.weight = weight
150	self.toggle_mode_on = toggle_mode_on
151	self.state = state
152	self.page_id = page_id
153	self.smearer = smearer
154	self.starttime = 0
155	self.update_chisqr = update_chisqr
156	self.source = source
157	self.out = None
158	self.index = None
159
160	def compute(self):
161	"""
162	Compute model 1d value given qmin , qmax , x value
163	"""
164	self.starttime = time.time()
165	output = numpy.zeros((len(self.data.x)))
166	index = (self.qmin <= self.data.x) & (self.data.x <= self.qmax)
167
168	# If we use a smearer, also return the unsmeared model
169	unsmeared_output = None
170	unsmeared_data = None
171	unsmeared_error = None
172	##smearer the ouput of the plot
173	if self.smearer is not None:
174	first_bin, last_bin = self.smearer.get_bin_range(self.qmin,
175	self.qmax)
176	mask = self.data.x[first_bin:last_bin+1]
177	unsmeared_output = numpy.zeros((len(self.data.x)))
178	unsmeared_output[first_bin:last_bin+1] = self.model.evalDistribution(mask)
179	output = self.smearer(unsmeared_output, first_bin, last_bin)
180
181	# Rescale data to unsmeared model
182	unsmeared_data = numpy.zeros((len(self.data.x)))
183	unsmeared_error = numpy.zeros((len(self.data.x)))
184	unsmeared_data[first_bin:last_bin+1] = self.data.y[first_bin:last_bin+1]\
185	* unsmeared_output[first_bin:last_bin+1]\
186	/ output[first_bin:last_bin+1]
187	unsmeared_error[first_bin:last_bin+1] = self.data.dy[first_bin:last_bin+1]\
188	* unsmeared_output[first_bin:last_bin+1]\
189	/ output[first_bin:last_bin+1]
190	unsmeared_output=unsmeared_output[index]
191	unsmeared_data=unsmeared_data[index]
192	unsmeared_error=unsmeared_error
193	else:
194	output[index] = self.model.evalDistribution(self.data.x[index])
195
196	elapsed = time.time() - self.starttime
197
198	self.complete(x=self.data.x[index], y=output[index],
199	page_id=self.page_id,
200	state=self.state,
201	weight=self.weight,
202	fid=self.fid,
203	toggle_mode_on=self.toggle_mode_on,
204	elapsed=elapsed, index=index, model=self.model,
205	data=self.data,
206	update_chisqr=self.update_chisqr,
207	source=self.source,
208	unsmeared_model=unsmeared_output,
209	unsmeared_data=unsmeared_data,
210	unsmeared_error=unsmeared_error)
211
212	def results(self):
213	"""
214	Send resuts of the computation
215	"""
216	return [self.out, self.index]
217
218	"""
219	Example: ::
220
221	class CalcCommandline:
222	def __init__(self, n=20000):
223	#print thread.get_ident()
224	from sas.models.CylinderModel import CylinderModel
225
226	model = CylinderModel()
227
228
229	print model.runXY([0.01, 0.02])
230
231	qmax = 0.01
232	qstep = 0.0001
233	self.done = False
234
235	x = numpy.arange(-qmax, qmax+qstep*0.01, qstep)
236	y = numpy.arange(-qmax, qmax+qstep*0.01, qstep)
237
238
239	calc_thread_2D = Calc2D(x, y, None, model.clone(),None,
240	-qmax, qmax,qstep,
241	completefn=self.complete,
242	updatefn=self.update ,
243	yieldtime=0.0)
244
245	calc_thread_2D.queue()
246	calc_thread_2D.ready(2.5)
247
248	while not self.done:
249	time.sleep(1)
250
251	def update(self,output):
252	print "update"
253
254	def complete(self, image, data, model, elapsed, qmin, qmax,index, qstep ):
255	print "complete"
256	self.done = True
257
258	if __name__ == "__main__":
259	CalcCommandline()
260	"""

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

SasView

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

Download in other formats: