model_thread.py @ ba8d326

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalcmagnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since ba8d326 was ba8d326, checked in by Paul Kienzle <pkienzle@…>, 7 years ago
code cleanup
Property mode set to `100644`
File size: 10.0 KB

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

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

SasView

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

Download in other formats: