AbstractFitEngine.py @ bd5ac39

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 bd5ac39 was d5f0f5e3, checked in by Gervaise Alina <gervyh@…>, 13 years ago
fix intentation issue
Property mode set to `100644`
File size: 25.3 KB

Line
1
2	import copy
3	#import logging
4	#import sys
5	import numpy
6	import math
7	import park
8	from DataLoader.data_info import Data1D
9	from DataLoader.data_info import Data2D
10	import time
11	_SMALLVALUE = 1.0e-10
12
13	class SansParameter(park.Parameter):
14	"""
15	SANS model parameters for use in the PARK fitting service.
16	The parameter attribute value is redirected to the underlying
17	parameter value in the SANS model.
18	"""
19	def __init__(self, name, model):
20	"""
21	:param name: the name of the model parameter
22	:param model: the sans model to wrap as a park model
23
24	"""
25	park.Parameter.__init__(self, name)
26	self._model, self._name = model, name
27	#set the value for the parameter of the given name
28	self.set(model.getParam(name))
29
30	def _getvalue(self):
31	"""
32	override the _getvalue of park parameter
33
34	:return value the parameter associates with self.name
35
36	"""
37	return self._model.getParam(self.name)
38
39	def _setvalue(self, value):
40	"""
41	override the _setvalue pf park parameter
42
43	:param value: the value to set on a given parameter
44
45	"""
46	self._model.setParam(self.name, value)
47
48	value = property(_getvalue, _setvalue)
49
50	def _getrange(self):
51	"""
52	Override _getrange of park parameter
53	return the range of parameter
54	"""
55	#if not self.name in self._model.getDispParamList():
56	lo, hi = self._model.details[self.name][1:3]
57	if lo is None: lo = -numpy.inf
58	if hi is None: hi = numpy.inf
59	#else:
60	#lo,hi = self._model.details[self.name][1:]
61	#if lo is None: lo = -numpy.inf
62	#if hi is None: hi = numpy.inf
63	if lo >= hi:
64	raise ValueError,"wrong fit range for parameters"
65
66	return lo, hi
67
68	def get_name(self):
69	"""
70	"""
71	return self._getname()
72
73	def _setrange(self, r):
74	"""
75	override _setrange of park parameter
76
77	:param r: the value of the range to set
78
79	"""
80	self._model.details[self.name][1:3] = r
81	range = property(_getrange, _setrange)
82
83	class Model(park.Model):
84	"""
85	PARK wrapper for SANS models.
86	"""
87	def __init__(self, sans_model, **kw):
88	"""
89	:param sans_model: the sans model to wrap using park interface
90
91	"""
92	park.Model.__init__(self, **kw)
93	self.model = sans_model
94	self.name = sans_model.name
95	#list of parameters names
96	self.sansp = sans_model.getParamList()
97	#list of park parameter
98	self.parkp = [SansParameter(p, sans_model) for p in self.sansp]
99	#list of parameterset
100	self.parameterset = park.ParameterSet(sans_model.name, pars=self.parkp)
101	self.pars = []
102
103	def get_params(self, fitparams):
104	"""
105	return a list of value of paramter to fit
106
107	:param fitparams: list of paramaters name to fit
108
109	"""
110	list_params = []
111	self.pars = []
112	self.pars = fitparams
113	for item in fitparams:
114	for element in self.parkp:
115	if element.name == str(item):
116	list_params.append(element.value)
117	return list_params
118
119	def set_params(self, paramlist, params):
120	"""
121	Set value for parameters to fit
122
123	:param params: list of value for parameters to fit
124
125	"""
126	try:
127	for i in range(len(self.parkp)):
128	for j in range(len(paramlist)):
129	if self.parkp[i].name == paramlist[j]:
130	self.parkp[i].value = params[j]
131	self.model.setParam(self.parkp[i].name, params[j])
132	except:
133	raise
134
135	def eval(self, x):
136	"""
137	override eval method of park model.
138
139	:param x: the x value used to compute a function
140
141	"""
142	try:
143	return self.model.evalDistribution(x)
144	except:
145	raise
146
147	def eval_derivs(self, x, pars=[]):
148	"""
149	Evaluate the model and derivatives wrt pars at x.
150
151	pars is a list of the names of the parameters for which derivatives
152	are desired.
153
154	This method needs to be specialized in the model to evaluate the
155	model function. Alternatively, the model can implement is own
156	version of residuals which calculates the residuals directly
157	instead of calling eval.
158	"""
159	return []
160
161
162
163	class FitData1D(Data1D):
164	"""
165	Wrapper class for SANS data
166	FitData1D inherits from DataLoader.data_info.Data1D. Implements
167	a way to get residuals from data.
168	"""
169	def __init__(self, x, y, dx=None, dy=None, smearer=None):
170	"""
171	:param smearer: is an object of class QSmearer or SlitSmearer
172	that will smear the theory data (slit smearing or resolution
173	smearing) when set.
174
175	The proper way to set the smearing object would be to
176	do the following: ::
177
178	from DataLoader.qsmearing import smear_selection
179	smearer = smear_selection(some_data)
180	fitdata1d = FitData1D( x= [1,3,..,],
181	y= [3,4,..,8],
182	dx=None,
183	dy=[1,2...], smearer= smearer)
184
185	:Note: that some_data _HAS_ to be of class DataLoader.data_info.Data1D
186	Setting it back to None will turn smearing off.
187
188	"""
189	Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy)
190
191	self.smearer = smearer
192	self._first_unsmeared_bin = None
193	self._last_unsmeared_bin = None
194	# Check error bar; if no error bar found, set it constant(=1)
195	# TODO: Should provide an option for users to set it like percent,
196	# constant, or dy data
197	if dy == None or dy == [] or dy.all() == 0:
198	self.dy = numpy.ones(len(y))
199	else:
200	self.dy = numpy.asarray(dy).copy()
201
202	## Min Q-value
203	#Skip the Q=0 point, especially when y(q=0)=None at x[0].
204	if min (self.x) == 0.0 and self.x[0] == 0 and\
205	not numpy.isfinite(self.y[0]):
206	self.qmin = min(self.x[self.x!=0])
207	else:
208	self.qmin = min(self.x)
209	## Max Q-value
210	self.qmax = max(self.x)
211
212	# Range used for input to smearing
213	self._qmin_unsmeared = self.qmin
214	self._qmax_unsmeared = self.qmax
215	# Identify the bin range for the unsmeared and smeared spaces
216	self.idx = (self.x >= self.qmin) & (self.x <= self.qmax)
217	self.idx_unsmeared = (self.x >= self._qmin_unsmeared) \
218	& (self.x <= self._qmax_unsmeared)
219
220	def set_fit_range(self, qmin=None, qmax=None):
221	""" to set the fit range"""
222	# Skip Q=0 point, (especially for y(q=0)=None at x[0]).
223	# ToDo: Find better way to do it.
224	if qmin == 0.0 and not numpy.isfinite(self.y[qmin]):
225	self.qmin = min(self.x[self.x != 0])
226	elif qmin != None:
227	self.qmin = qmin
228	if qmax != None:
229	self.qmax = qmax
230	# Determine the range needed in unsmeared-Q to cover
231	# the smeared Q range
232	self._qmin_unsmeared = self.qmin
233	self._qmax_unsmeared = self.qmax
234
235	self._first_unsmeared_bin = 0
236	self._last_unsmeared_bin = len(self.x) - 1
237
238	if self.smearer != None:
239	self._first_unsmeared_bin, self._last_unsmeared_bin = \
240	self.smearer.get_bin_range(self.qmin, self.qmax)
241	self._qmin_unsmeared = self.x[self._first_unsmeared_bin]
242	self._qmax_unsmeared = self.x[self._last_unsmeared_bin]
243
244	# Identify the bin range for the unsmeared and smeared spaces
245	self.idx = (self.x >= self.qmin) & (self.x <= self.qmax)
246	## zero error can not participate for fitting
247	self.idx = self.idx & (self.dy != 0)
248	self.idx_unsmeared = (self.x >= self._qmin_unsmeared) \
249	& (self.x <= self._qmax_unsmeared)
250
251	def get_fit_range(self):
252	"""
253	return the range of data.x to fit
254	"""
255	return self.qmin, self.qmax
256
257	def residuals(self, fn):
258	"""
259	Compute residuals.
260
261	If self.smearer has been set, use if to smear
262	the data before computing chi squared.
263
264	:param fn: function that return model value
265
266	:return: residuals
267
268	"""
269	# Compute theory data f(x)
270	fx = numpy.zeros(len(self.x))
271	fx[self.idx_unsmeared] = fn(self.x[self.idx_unsmeared])
272
273	## Smear theory data
274	if self.smearer is not None:
275	fx = self.smearer(fx, self._first_unsmeared_bin,
276	self._last_unsmeared_bin)
277	## Sanity check
278	if numpy.size(self.dy) != numpy.size(fx):
279	msg = "FitData1D: invalid error array "
280	msg += "%d <> %d" % (numpy.shape(self.dy), numpy.size(fx))
281	raise RuntimeError, msg
282	return (self.y[self.idx] - fx[self.idx]) / self.dy[self.idx]
283
284	def residuals_deriv(self, model, pars=[]):
285	"""
286	:return: residuals derivatives .
287
288	:note: in this case just return empty array
289
290	"""
291	return []
292
293	class FitData2D(Data2D):
294	""" Wrapper class for SANS data """
295	def __init__(self, sans_data2d, data=None, err_data=None):
296	Data2D.__init__(self, data=data, err_data=err_data)
297	"""
298	Data can be initital with a data (sans plottable)
299	or with vectors.
300	"""
301	self.res_err_image = []
302	self.index_model = []
303	self.qmin = None
304	self.qmax = None
305	self.smearer = None
306	self.radius = 0
307	self.res_err_data = []
308	self.set_data(sans_data2d)
309
310	def set_data(self, sans_data2d, qmin=None, qmax=None):
311	"""
312	Determine the correct qx_data and qy_data within range to fit
313	"""
314	self.data = sans_data2d.data
315	self.err_data = sans_data2d.err_data
316	self.qx_data = sans_data2d.qx_data
317	self.qy_data = sans_data2d.qy_data
318	self.mask = sans_data2d.mask
319
320	x_max = max(math.fabs(sans_data2d.xmin), math.fabs(sans_data2d.xmax))
321	y_max = max(math.fabs(sans_data2d.ymin), math.fabs(sans_data2d.ymax))
322
323	## fitting range
324	if qmin == None:
325	self.qmin = 1e-16
326	if qmax == None:
327	self.qmax = math.sqrt(x_max * x_max + y_max * y_max)
328	## new error image for fitting purpose
329	if self.err_data == None or self.err_data == []:
330	self.res_err_data = numpy.ones(len(self.data))
331	else:
332	self.res_err_data = copy.deepcopy(self.err_data)
333	#self.res_err_data[self.res_err_data==0]=1
334
335	self.radius = numpy.sqrt(self.qx_data2 + self.qy_data2)
336
337	# Note: mask = True: for MASK while mask = False for NOT to mask
338	self.index_model = ((self.qmin <= self.radius)&\
339	(self.radius <= self.qmax))
340	self.index_model = (self.index_model) & (self.mask)
341	self.index_model = (self.index_model) & (numpy.isfinite(self.data))
342
343	def set_smearer(self, smearer):
344	"""
345	Set smearer
346	"""
347	if smearer == None:
348	return
349	self.smearer = smearer
350	self.smearer.set_index(self.index_model)
351	self.smearer.get_data()
352
353	def set_fit_range(self, qmin=None, qmax=None):
354	""" to set the fit range"""
355	if qmin == 0.0:
356	self.qmin = 1e-16
357	elif qmin != None:
358	self.qmin = qmin
359	if qmax != None:
360	self.qmax = qmax
361	self.radius = numpy.sqrt(self.qx_data2 + self.qy_data2)
362	self.index_model = ((self.qmin <= self.radius)&\
363	(self.radius <= self.qmax))
364	self.index_model = (self.index_model) &(self.mask)
365	self.index_model = (self.index_model) & (numpy.isfinite(self.data))
366	self.index_model = (self.index_model) & (self.res_err_data != 0)
367
368	def get_fit_range(self):
369	"""
370	return the range of data.x to fit
371	"""
372	return self.qmin, self.qmax
373
374	def residuals(self, fn):
375	"""
376	return the residuals
377	"""
378	if self.smearer != None:
379	fn.set_index(self.index_model)
380	# Get necessary data from self.data and set the data for smearing
381	fn.get_data()
382
383	gn = fn.get_value()
384	else:
385	gn = fn([self.qx_data[self.index_model],
386	self.qy_data[self.index_model]])
387	# use only the data point within ROI range
388	res = (self.data[self.index_model] - gn)/\
389	self.res_err_data[self.index_model]
390	return res
391
392	def residuals_deriv(self, model, pars=[]):
393	"""
394	:return: residuals derivatives .
395
396	:note: in this case just return empty array
397
398	"""
399	return []
400
401	class FitAbort(Exception):
402	"""
403	Exception raise to stop the fit
404	"""
405
406
407	class SansAssembly:
408	"""
409	Sans Assembly class a class wrapper to be call in optimizer.leastsq method
410	"""
411	def __init__(self, paramlist, model=None , data=None, fitresult=None,
412	handler=None, curr_thread=None):
413	"""
414	:param Model: the model wrapper fro sans -model
415	:param Data: the data wrapper for sans data
416
417	"""
418	self.model = model
419	self.data = data
420	self.paramlist = paramlist
421	self.curr_thread = curr_thread
422	self.handler = handler
423	self.fitresult = fitresult
424	self.res = []
425	self.true_res = []
426	self.func_name = "Functor"
427
428	#def chisq(self, params):
429	def chisq(self):
430	"""
431	Calculates chi^2
432
433	:param params: list of parameter values
434
435	:return: chi^2
436
437	"""
438	sum = 0
439	for item in self.true_res:
440	sum += item * item
441	if len(self.true_res) == 0:
442	return None
443	return sum / len(self.true_res)
444
445	def __call__(self, params):
446	"""
447	Compute residuals
448
449	:param params: value of parameters to fit
450
451	"""
452	#import thread
453	self.model.set_params(self.paramlist, params)
454	self.true_res = self.data.residuals(self.model.eval)
455	# check parameters range
456	if self.check_param_range():
457	# if the param value is outside of the bound
458	# just silent return res = inf
459	return self.res
460	self.res = self.true_res
461	if self.fitresult is not None and self.handler is not None:
462	self.fitresult.set_model(model=self.model)
463	#fitness = self.chisq(params=params)
464	fitness = self.chisq()
465	self.fitresult.pvec = params
466	self.fitresult.set_fitness(fitness=fitness)
467	self.handler.set_result(result=self.fitresult)
468	self.handler.update_fit()
469
470	if self.curr_thread != None :
471	try:
472	self.curr_thread.isquit()
473	except:
474	raise FitAbort,"stop leastsqr optimizer"
475	return self.res
476
477	def check_param_range(self):
478	"""
479	Check the lower and upper bound of the parameter value
480	and set res to the inf if the value is outside of the
481	range
482	:limitation: the initial values must be within range.
483	"""
484
485	time.sleep(0.01)
486	is_outofbound = False
487	# loop through the fit parameters
488	for p in self.model.parameterset:
489	param_name = p.get_name()
490	if param_name in self.paramlist:
491
492	# if the range was defined, check the range
493	if numpy.isfinite(p.range[0]):
494	if p.value == 0:
495	# This value works on Scipy
496	# Do not change numbers below
497	value = _SMALLVALUE
498	else:
499	value = p.value
500	# For leastsq, it needs a bit step back from the boundary
501	val = p.range[0] - value * _SMALLVALUE
502	if p.value < val:
503	self.res *= 1e+6
504
505	is_outofbound = True
506	break
507	if numpy.isfinite(p.range[1]):
508	# This value works on Scipy
509	# Do not change numbers below
510	if p.value == 0:
511	value = _SMALLVALUE
512	else:
513	value = p.value
514	# For leastsq, it needs a bit step back from the boundary
515	val = p.range[1] + value * _SMALLVALUE
516	if p.value > val:
517	self.res *= 1e+6
518	is_outofbound = True
519	break
520
521	return is_outofbound
522
523
524	class FitEngine:
525	def __init__(self):
526	"""
527	Base class for scipy and park fit engine
528	"""
529	#List of parameter names to fit
530	self.param_list = []
531	#Dictionnary of fitArrange element (fit problems)
532	self.fit_arrange_dict = {}
533
534	def set_model(self, model, id, pars=[], constraints=[]):
535	"""
536	set a model on a given in the fit engine.
537
538	:param model: sans.models type
539	:param : is the key of the fitArrange dictionary where model is
540	saved as a value
541	:param pars: the list of parameters to fit
542	:param constraints: list of
543	tuple (name of parameter, value of parameters)
544	the value of parameter must be a string to constraint 2 different
545	parameters.
546	Example:
547	we want to fit 2 model M1 and M2 both have parameters A and B.
548	constraints can be:
549	constraints = [(M1.A, M2.B+2), (M1.B= M2.A *5),...,]
550
551
552	:note: pars must contains only name of existing model's parameters
553
554	"""
555	if model == None:
556	raise ValueError, "AbstractFitEngine: Need to set model to fit"
557
558	new_model = model
559	if not issubclass(model.__class__, Model):
560	new_model = Model(model)
561
562	if len(constraints) > 0:
563	for constraint in constraints:
564	name, value = constraint
565	try:
566	new_model.parameterset[str(name)].set(str(value))
567	except:
568	msg = "Fit Engine: Error occurs when setting the constraint"
569	msg += " %s for parameter %s " % (value, name)
570	raise ValueError, msg
571
572	if len(pars) > 0:
573	temp = []
574	for item in pars:
575	if item in new_model.model.getParamList():
576	temp.append(item)
577	self.param_list.append(item)
578	else:
579
580	msg = "wrong parameter %s used" % str(item)
581	msg += "to set model %s. Choose" % str(new_model.model.name)
582	msg += "parameter name within %s" % \
583	str(new_model.model.getParamList())
584	raise ValueError, msg
585
586	#A fitArrange is already created but contains data_list only at id
587	if self.fit_arrange_dict.has_key(id):
588	self.fit_arrange_dict[id].set_model(new_model)
589	self.fit_arrange_dict[id].pars = pars
590	else:
591	#no fitArrange object has been create with this id
592	fitproblem = FitArrange()
593	fitproblem.set_model(new_model)
594	fitproblem.pars = pars
595	self.fit_arrange_dict[id] = fitproblem
596
597	else:
598	raise ValueError, "park_integration:missing parameters"
599
600	def set_data(self, data, id, smearer=None, qmin=None, qmax=None):
601	"""
602	Receives plottable, creates a list of data to fit,set data
603	in a FitArrange object and adds that object in a dictionary
604	with key id.
605
606	:param data: data added
607	:param id: unique key corresponding to a fitArrange object with data
608
609	"""
610	if data.__class__.__name__ == 'Data2D':
611	fitdata = FitData2D(sans_data2d=data, data=data.data,
612	err_data=data.err_data)
613	else:
614	fitdata = FitData1D(x=data.x, y=data.y ,
615	dx=data.dx, dy=data.dy, smearer=smearer)
616
617	fitdata.set_fit_range(qmin=qmin, qmax=qmax)
618	#A fitArrange is already created but contains model only at id
619	if self.fit_arrange_dict.has_key(id):
620	self.fit_arrange_dict[id].add_data(fitdata)
621	else:
622	#no fitArrange object has been create with this id
623	fitproblem = FitArrange()
624	fitproblem.add_data(fitdata)
625	self.fit_arrange_dict[id] = fitproblem
626
627	def get_model(self, id):
628	"""
629
630	:param id: id is key in the dictionary containing the model to return
631
632	:return: a model at this id or None if no FitArrange element was
633	created with this id
634
635	"""
636	if self.fit_arrange_dict.has_key(id):
637	return self.fit_arrange_dict[id].get_model()
638	else:
639	return None
640
641	def remove_fit_problem(self, id):
642	"""remove fitarrange in id"""
643	if self.fit_arrange_dict.has_key(id):
644	del self.fit_arrange_dict[id]
645
646	def select_problem_for_fit(self, id, value):
647	"""
648	select a couple of model and data at the id position in dictionary
649	and set in self.selected value to value
650
651	:param value: the value to allow fitting.
652	can only have the value one or zero
653
654	"""
655	if self.fit_arrange_dict.has_key(id):
656	self.fit_arrange_dict[id].set_to_fit(value)
657
658	def get_problem_to_fit(self, id):
659	"""
660	return the self.selected value of the fit problem of id
661
662	:param id: the id of the problem
663
664	"""
665	if self.fit_arrange_dict.has_key(id):
666	self.fit_arrange_dict[id].get_to_fit()
667
668	class FitArrange:
669	def __init__(self):
670	"""
671	Class FitArrange contains a set of data for a given model
672	to perform the Fit.FitArrange must contain exactly one model
673	and at least one data for the fit to be performed.
674
675	model: the model selected by the user
676	Ldata: a list of data what the user wants to fit
677
678	"""
679	self.model = None
680	self.data_list = []
681	self.pars = []
682	#self.selected is zero when this fit problem is not schedule to fit
683	#self.selected is 1 when schedule to fit
684	self.selected = 0
685
686	def set_model(self, model):
687	"""
688	set_model save a copy of the model
689
690	:param model: the model being set
691
692	"""
693	self.model = model
694
695	def add_data(self, data):
696	"""
697	add_data fill a self.data_list with data to fit
698
699	:param data: Data to add in the list
700
701	"""
702	if not data in self.data_list:
703	self.data_list.append(data)
704
705	def get_model(self):
706	"""
707
708	:return: saved model
709
710	"""
711	return self.model
712
713	def get_data(self):
714	"""
715
716	:return: list of data data_list
717
718	"""
719	#return self.data_list
720	return self.data_list[0]
721
722	def remove_data(self, data):
723	"""
724	Remove one element from the list
725
726	:param data: Data to remove from data_list
727
728	"""
729	if data in self.data_list:
730	self.data_list.remove(data)
731
732	def set_to_fit (self, value=0):
733	"""
734	set self.selected to 0 or 1 for other values raise an exception
735
736	:param value: integer between 0 or 1
737
738	"""
739	self.selected = value
740
741	def get_to_fit(self):
742	"""
743	return self.selected value
744	"""
745	return self.selected

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

SasView

source: sasview/park_integration/AbstractFitEngine.py @ bd5ac39

Download in other formats: