#/*##########################################################################
#
# The PyMca X-Ray Fluorescence Toolkit
#
# Copyright (c) 2004-2014 European Synchrotron Radiation Facility
#
# This file is part of the PyMca X-ray Fluorescence Toolkit developed at
# the ESRF by the Software group.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
#############################################################################*/
__author__ = "V.A. Sole - ESRF Data Analysis"
__contact__ = "sole@esrf.fr"
__license__ = "MIT"
__copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
import sys
import os
import numpy
import copy
import types
from . import Gefit
from . import SpecfitFuns
DEBUG = 0
[docs]class SimpleFit(object):
def __init__(self):
#no data available by default
self._x0 = None
self._y0 = None
#get default configuration
self.getDefaultConfiguration()
#the list and dictionary of defined functions
self._functionList = []
self._functionDict = {}
#the current fit function
self._stripFunction = None
[docs] def getDefaultConfiguration(self):
self._fitConfiguration = {}
self._fitConfiguration['fit'] = {}
self._fitConfiguration['fit']['fit_function'] = "None"
self._fitConfiguration['fit']['function_flag'] = 1
self._fitConfiguration['fit']['background_function'] = "None"
self._fitConfiguration['fit']['background_flag'] = 1
self._fitConfiguration['fit']['strip_function'] = "Strip"
self._fitConfiguration['fit']['stripalgorithm'] = 0
self._fitConfiguration['fit']['strip_flag'] = 1
self._fitConfiguration['fit']['fit_algorithm'] = "Levenberg-Marquardt"
self._fitConfiguration['fit']['weight'] = "NO Weight"
self._fitConfiguration['fit']['maximum_fit_iterations'] = 10
self._fitConfiguration['fit']['background_estimation_policy'] = "Estimate always"
self._fitConfiguration['fit']['function_estimation_policy'] = "Estimate always"
self._fitConfiguration['fit']['minimum_delta_chi'] = 0.0010
self._fitConfiguration['fit']['use_limits'] = 0
self._fitConfiguration['fit']['xmin'] = 0.
self._fitConfiguration['fit']['xmax'] = 1000.
self._fitConfiguration['fit']['functions'] = []
#strip/snip background configuration related
self._fitConfiguration['fit']['stripanchorsflag'] = 0
self._fitConfiguration['fit']['stripanchorslist'] = []
self._fitConfiguration['fit']['stripfilterwidth'] = 1
self._fitConfiguration['fit']['snipwidth'] = 10
self._fitConfiguration['fit']['stripwidth'] = 4
self._fitConfiguration['fit']['stripiterations'] = 5000
self._fitConfiguration['fit']['stripconstant'] = 1.0
self._fitConfiguration['functions'] = {}
[docs] def setConfiguration(self, ddict, try_import=False):
oldConfig = self.getConfiguration()
if ddict is None:
return oldConfig
if 'fit' in ddict:
givenKeys = ddict['fit'].keys()
for key in self._fitConfiguration['fit'].keys():
if key in givenKeys:
self._fitConfiguration['fit'][key] = ddict['fit'][key]
for key in ddict.keys():
if key in ['fit', 'functions']:
continue
self._fitConfiguration[key] = ddict[key]
if 'functions' in ddict:
functionNames = ddict['functions'].keys()
for fName in functionNames:
if fName not in self._fitConfiguration['functions'].keys():
if try_import:
ffile = ddict['functions'][fName].get('file', None)
if ffile is not None:
self.importFunctions(ffile)
else:
print("WARNING:Function %s not among defined functions" % fName)
continue
self._fitConfiguration['functions'][fName]['configuration']=\
ddict['functions'][fName]['configuration']
configureMethod = self._fitConfiguration['functions'][fName]\
['configure']
if configureMethod is not None:
configureMethod(ddict['functions'][fName]['configuration'])
#if data are present, update strip background
if (self._x0 is None) or (self._y0 is None):
return
if (oldConfig['fit']['xmin'] != self._fitConfiguration['fit']['xmin']) or\
(oldConfig['fit']['xmax'] != self._fitConfiguration['fit']['xmax']):
if DEBUG:
print("SETTING DATA AGAIN")
self.setData(self._x0, self._y0,
xmin=self._fitConfiguration['fit']['xmin'],
xmax=self._fitConfiguration['fit']['xmax'])
return
for key in ['strip_flag', 'stripanchorsflag', 'stripalgorithm',
'stripwidth', 'stripiterations', 'stripconstant']:
if oldConfig['fit'][key] != self._fitConfiguration['fit'][key]:
if DEBUG:
print("RECALCULATING STRIP")
self._getStripBackground()
break
if key == 'stripanchorsflag':
if len(oldConfig['fit']['stripanchorslist']) !=\
len(self._fitConfiguration['fit']['stripanchorslist']):
if DEBUG:
print("ANCHORS CHANGE, RECALCULATING STRIP")
self._getStripBackground()
break
[docs] def getConfiguration(self):
ddict = {}
for key in self._fitConfiguration.keys():
if key == 'functions':
continue
ddict[key] = copy.deepcopy(self._fitConfiguration[key])
ddict['functions'] = {}
for key in self._fitConfiguration['functions'].keys():
ddict['functions'][key] = {}
ddict['functions'][key]['configuration'] = copy.deepcopy(\
self._fitConfiguration['functions'][key]['configuration'])
configureMethod = self._fitConfiguration['functions']\
[key]['configure']
if configureMethod is not None:
currentFunctionConfig = configureMethod()
for newKey in currentFunctionConfig.keys():
if newKey not in ['estimation']:
ddict['functions'][key]['configuration'][newKey] = currentFunctionConfig[newKey]
parameters = self._fitConfiguration['functions'][key]['parameters']
ddict['functions'][key]['parameters'] = parameters
widget = self._fitConfiguration['functions'][key]['widget']
ddict['functions'][key]['widget'] = widget
fname = self._fitConfiguration['functions'][key]['file']
ddict['functions'][key]['file'] = fname
return ddict
[docs] def setData(self, x, y, sigma=None, xmin=None, xmax=None, **kw):
# make sure last fit result is not used
self._fitResult = None
idx = numpy.argsort(x)
if sigma is not None:
self._sigma = sigma[idx]
else:
self._sigma = None
self._y0 = y[idx]
self._x0 = x[idx]
if sigma is not None:
self._sigma0 = sigma[idx]
xmin, xmax = self._getLimits(self._x0, xmin, xmax)
idx = (self._x0 >= xmin) & (self._x0 <= xmax)
self._x = self._x0[idx]
self._y = self._y0[idx]
self._fitConfiguration['fit']['xmin'] = xmin * 1.0
self._fitConfiguration['fit']['xmax'] = xmax * 1.0
if sigma is not None:
self._sigma = self._sigma0[idx]
if DEBUG:
print("TODO: Make sure we have something to fit")
#get strip/SNIP background
self._z = self._getStripBackground()
[docs] def importFunctions(self, modname):
#modname can be a module or a file
if type(modname) == types.ModuleType:
newfun = modname
elif os.path.exists(modname):
sys.path.append(os.path.dirname(modname))
f=os.path.basename(os.path.splitext(modname)[0])
newfun=__import__(f)
else:
raise ValueError("Cannot interprete/find %s" % modname)
theory = newfun.THEORY
function=newfun.FUNCTION
parameters = newfun.PARAMETERS
try:
estimate=newfun.ESTIMATE
except:
estimate=None
try:
derivative=newfun.DERIVATIVE
except:
derivative=None
try:
configure=newfun.CONFIGURE
except:
configure=None
try:
widget=newfun.WIDGET
except:
widget=None
basename = os.path.basename(newfun.__file__)
for i in range(len(theory)):
ddict = {}
functionName = theory[i]
ddict['function'] = function[i]
ddict['parameters'] = parameters[i]
ddict['default_parameters'] = None
ddict['estimate'] = None
ddict['derivative'] = None
ddict['configure'] = None
ddict['widget'] = None
ddict['file'] = newfun.__file__
ddict['configuration'] = {}
if estimate is not None:
ddict['estimate'] = estimate[i]
if derivative is not None:
ddict['derivative'] = derivative[i]
if configure is not None:
ddict['configure'] = configure[i]
if ddict['configure'] is not None:
ddict['configuration'] = configure[i]()
if ddict['estimate'] is None:
ddict['configuration']['estimation'] = None
if widget is not None:
ddict['widget'] = widget[i]
self._fitConfiguration['functions'][functionName] = ddict
self._fitConfiguration['fit']['functions'].append(functionName)
[docs] def setFitFunction(self, name):
if name in [None, "None", "NONE"]:
self._fitConfiguration['fit']['fit_function'] = "None"
return
self._fitFunctionConfigured = False
if name not in self._fitConfiguration['fit']['functions']:
txt = "Function %s not among defined functions" % name
raise KeyError(txt)
self._fitConfiguration['fit']['fit_function'] = name
[docs] def getFitFunction(self):
return "%s" % self._fitConfiguration['fit']['fit_function']
[docs] def setBackgroundFunction(self, name):
if name in [None, "None", "NONE"]:
self._fitConfiguration['fit']['background_function'] = "None"
return
self._backgroundFunctionConfigured = False
if name not in self._fitConfiguration['fit']['functions']:
txt = "Function %s not among defined functions" % name
raise KeyError(txt)
self._fitConfiguration['fit']['background_function'] = name
[docs] def getBackgroundFunction(self):
return "%s" % self._fitConfiguration['fit']['background_function']
def _getLimits(self, x, xmin, xmax):
if self._fitConfiguration['fit']['use_limits']:
xmin = self._fitConfiguration['fit']['xmin']
xmax = self._fitConfiguration['fit']['xmax']
return xmin, xmax
if xmin is None:
xmin = x[0]
if xmax is None:
xmax = x[-1]
return xmin, xmax
def _getStripBackground(self, x=None, y=None):
#this makes the assumption x are equally spaced
#and I should build a spline if that is not the case
#but I do not want to put a dependency on SciPy
if y is not None:
ywork = y
else:
ywork = self._y
if x is not None:
xwork = x
else:
xwork = self._x
n=len(xwork)
#loop for anchors
anchorslist = []
if self._fitConfiguration['fit']['stripanchorsflag']:
if self._fitConfiguration['fit']['stripanchorslist'] is not None:
oldShape = xwork.shape
ravelled = xwork
ravelled.shape = -1
for channel in self._fitConfiguration['fit']['stripanchorslist']:
if channel <= ravelled[0]:continue
index = numpy.nonzero(ravelled >= channel)
if len(index):
index = min(index)
if index > 0:
anchorslist.append(index)
ravelled.shape = oldShape
#work with smoothed data
ysmooth = self._getSmooth(xwork, ywork)
#SNIP algorithm
if self._fitConfiguration['fit']['stripalgorithm'] in ["SNIP", 1]:
if DEBUG:
print("CALCULATING SNIP")
if len(anchorslist) == 0:
anchorslist = [0, len(ysmooth)-1]
anchorslist.sort()
result = 0.0 * ysmooth
lastAnchor = 0
width = self._fitConfiguration['fit']['snipwidth']
for anchor in anchorslist:
if (anchor > lastAnchor) and (anchor < len(ysmooth)):
result[lastAnchor:anchor] =\
SpecfitFuns.snip1d(ysmooth[lastAnchor:anchor], width, 0)
lastAnchor = anchor
if lastAnchor < len(ysmooth):
result[lastAnchor:] =\
SpecfitFuns.snip1d(ysmooth[lastAnchor:], width, 0)
return result
#strip background
niter = self._fitConfiguration['fit']['stripiterations']
if niter > 0:
if DEBUG:
print("CALCULATING STRIP")
print("iterations = ", niter)
print("constant = ",
self._fitConfiguration['fit']['stripconstant'])
print("width = ",
self._fitConfiguration['fit']['stripwidth'])
print("anchors = ", anchorslist)
result=SpecfitFuns.subac(ysmooth,
self._fitConfiguration['fit']['stripconstant'],
niter,
self._fitConfiguration['fit']['stripwidth'],
anchorslist)
if niter > 1000:
#make sure to get something smooth
result = SpecfitFuns.subac(result,
self._fitConfiguration['fit']['stripconstant'],
500,1,
anchorslist)
else:
#make sure to get something smooth but with less than
#500 iterations
result = SpecfitFuns.subac(result,
self._fitConfiguration['fit']['stripconstant'],
int(self._fitConfiguration['fit']['stripwidth']*2),
1,
anchorslist)
else:
if DEBUG:
print("NO STRIP, NO SNIP")
result = numpy.zeros(ysmooth.shape, numpy.float) + min(ysmooth)
return result
def _getSmooth(self, x, y):
f=[0.25,0.5,0.25]
try:
if hasattr(y, "shape"):
if len(y.shape) > 1:
result=SpecfitFuns.SavitskyGolay(numpy.ravel(y).astype(numpy.float),
self._fitConfiguration['fit']['stripfilterwidth'])
else:
result=SpecfitFuns.SavitskyGolay(numpy.array(y).astype(numpy.float),
self._fitConfiguration['fit']['stripfilterwidth'])
else:
result=SpecfitFuns.SavitskyGolay(numpy.array(y).astype(numpy.float),
self._fitConfiguration['fit']['stripfilterwidth'])
except:
err = sys.exc_info()[1]
raise ValueError("Unsuccessful Savitsky-Golay smoothing: %s" % err)
result=numpy.array(y).astype(numpy.float)
if len(result) > 1:
result[1:-1]=numpy.convolve(result,f,mode=0)
result[0]=0.5*(result[0]+result[1])
result[-1]=0.5*(result[-1]+result[-2])
return result
[docs] def fit(self):
if self._y0 is None:
self._setStatus("No data to be fitted")
return
self.estimate()
self.startFit()
return self.getResult()
[docs] def estimate(self):
self._fitResult = None
if self._y0 is None:
self._setStatus("No data to be fitted")
return
self._setStatus("Estimate started")
backgroundDict = {'parameters':[]}
fitFunctionDict = {'parameters':[]}
backgroundParameters, backgroundConstraints = [], [[],[],[]]
backgroundFunction = self.getBackgroundFunction()
if self._fitConfiguration['fit']['background_flag']:
if backgroundFunction not in [None, "None", "NONE"]:
backgroundParameters, backgroundConstraints =\
self.estimateBackground()
backgroundDict = self._fitConfiguration['functions']\
[backgroundFunction]
self._setStatus("Background estimation finished")
functionParameters, functionConstraints = [], [[],[],[]]
fitFunction = self._fitConfiguration['fit']['fit_function']
if self._fitConfiguration['fit']['function_flag']:
if fitFunction not in [None, "None", "NONE"]:
functionParameters, functionConstraints=\
self.estimateFunction()
fitFunctionDict = self._fitConfiguration['functions']\
[fitFunction]
if DEBUG:
print("ESTIMATION parameters = ",functionParameters)
print("ESTIMATION constraints = ",functionConstraints)
self._setStatus("Fit function estimation finished")
#estimations are made
#Check if there can be conflicts between parameter names
#because they can have same names in the background and
#in the fit function
conflict = False
for parname in backgroundDict['parameters']:
if parname in fitFunctionDict['parameters']:
conflict = True
break
#build the parameter names
self.final_theory=[]
nBasePar = len(backgroundDict['parameters'])
nActualPar = len(backgroundParameters)
self.__nBackgroundParameters = nActualPar
if nActualPar:
for i in range(nActualPar):
parname = backgroundDict['parameters'][i%nBasePar]
if conflict:
parname = "Bkg_"+parname
if nBasePar < nActualPar:
parname = parname + ("_%d" % (1+int(i/nBasePar)))
self.final_theory.append(parname)
nBasePar = len(fitFunctionDict['parameters'])
nActualPar = len(functionParameters)
if nActualPar:
for i in range(nActualPar):
parname = fitFunctionDict['parameters'][i%nBasePar]
if nBasePar < nActualPar:
parname = parname + ("_%d" % (1+int(i/nBasePar)))
self.final_theory.append(parname)
CONS=['FREE',
'POSITIVE',
'QUOTED',
'FIXED',
'FACTOR',
'DELTA',
'SUM',
'IGNORE']
self.paramlist=[]
param = self.final_theory
j=0
i=0
k=0
xmin=self._x.min()
xmax=self._x.max()
#print "xmin = ",xmin,"xmax = ",xmax
for pname in self.final_theory:
if i < len(backgroundParameters):
self.paramlist.append({'name':pname,
'estimation':backgroundParameters[i],
'group':0,
'code':CONS[int(backgroundConstraints[0][i])],
'cons1':backgroundConstraints[1][i],
'cons2':backgroundConstraints[2][i],
'fitresult':0.0,
'sigma':0.0,
'xmin':xmin,
'xmax':xmax})
i=i+1
else:
if (j % len(fitFunctionDict['parameters'])) == 0:
k=k+1
if (CONS[int(functionConstraints[0][j])] == "FACTOR") or \
(CONS[int(functionConstraints[0][j])] == "DELTA"):
functionConstraints[1][j] = functionConstraints[1][j] +\
len(backgroundParameters)
self.paramlist.append({'name':pname,
'estimation':functionParameters[j],
'group':k,
'code':CONS[int(functionConstraints[0][j])],
'cons1':functionConstraints[1][j],
'cons2':functionConstraints[2][j],
'fitresult':0.0,
'sigma':0.0,
'xmin':xmin,
'xmax':xmax})
j=j+1
self._setStatus("Estimate finished")
return self.paramlist
def _setStatus(self, status):
self.__status = status
[docs] def getStatus(self):
return self.__status
[docs] def estimateBackground(self):
fname = self.getBackgroundFunction()
if fname is None:
return [],[[],[],[]]
ddict = self._fitConfiguration['functions'][fname]
estimateFunction = ddict['estimate']
if estimateFunction is None:
parameters = []
constraints = [[],[],[]]
if ddict['configuration']['estimation'] is not None:
estimation = ddict['configuration']['estimation']
defaultPar = estimation['parameters']
for parameter in defaultPar:
parameters.append(estimation[parameter]['estimation'])
constraints[0].append(estimation[parameter]['code'])
constraints[1].append(estimation[parameter]['cons1'])
constraints[2].append(estimation[parameter]['cons2'])
else:
defaultPar = ddict['parameters']
for parameter in defaultPar:
parameters.append(0.0)
constraints[0].append(0)
constraints[1].append(0)
constraints[2].append(0)
return parameters, constraints
parameters, constraints = estimateFunction(self._x, self._y, self._z)
return parameters, constraints
[docs] def estimateFunction(self):
self._z = self._getStripBackground()
fname = self.getFitFunction()
if fname is None:
return [],[[],[],[]]
ddict = self._fitConfiguration['functions'][fname]
estimateFunction = ddict['estimate']
if estimateFunction is None:
parameters = []
constraints = [[],[],[]]
if ddict['configuration']['estimation'] is not None:
estimation = ddict['configuration']['estimation']
defaultPar = estimation['parameters']
for parameter in defaultPar:
parameters.append(estimation[parameter]['estimation'])
constraints[0].append(estimation[parameter]['code'])
constraints[1].append(estimation[parameter]['cons1'])
constraints[2].append(estimation[parameter]['cons2'])
else:
defaultPar = ddict['parameters']
for parameter in defaultPar:
parameters.append(0.0)
constraints[0].append(0)
constraints[1].append(0)
constraints[2].append(0)
return parameters, constraints
parameters, constraints = estimateFunction(self._x * 1,
self._y * 1,
self._z * 1)
return parameters, constraints
[docs] def startFit(self):
if self._y0 is None:
self._setStatus("No data to be fitted")
return
self._setStatus("Fit started")
param_list = self.final_theory
length = len(param_list)
param_val = []
param_constrains = [[],[],[]]
flagconstrained=0
for param in self.paramlist:
#print param['name'],param['group'],param['estimation']
param_val.append(param['estimation'])
if (param['code'] != 'FREE') & (param['code'] != 0) & \
(param['code'] != 0.0) :
flagconstrained=1
param_constrains [0].append(param['code'])
param_constrains [1].append(param['cons1'])
param_constrains [2].append(param['cons2'])
#weight handling
if self._fitConfiguration['fit']['weight'] in ["NO Weight", 0]:
weightflag = 0
else:
weightflag = 1
if DEBUG:
print("STILL TO HANDLE DERIVATIVES")
model_deriv = self.modelFunctionDerivative
if self._fitConfiguration['fit']['strip_flag']:
y = self._y - self._z
else:
y = self._y
self._fitResult = None
if not flagconstrained:
param_constrains = []
if DEBUG:
result = Gefit.LeastSquaresFit(self.modelFunction,param_val,
xdata=self._x,
ydata=y,
sigmadata=self._sigma,
constrains=param_constrains,
weightflag=weightflag,
model_deriv=model_deriv,
fulloutput=True)
else:
try:
result = Gefit.LeastSquaresFit(self.modelFunction,param_val,
xdata=self._x,
ydata=y,
sigmadata=self._sigma,
constrains=param_constrains,
weightflag=weightflag,
model_deriv=model_deriv,
fulloutput=True)
except:
text = sys.exc_info()[1]
if type(text) is not type(" "):
text = text.args
if len(text):
text = text[0]
else:
text = ''
self._setStatus('Fit error : %s' %text)
raise
self._fitResult = {}
self._fitResult['fit_function'] = self.getFitFunction()
self._fitResult['background_function'] = self.getBackgroundFunction()
self._fitResult['fittedvalues'] = result[0]
self._fitResult['chisq'] = result[1]
self._fitResult['sigma_values'] = result[2]
self._fitResult['niter'] = result[3]
self._fitResult['lastdeltachi'] = result[4]
self._fitResult['n_background_parameters'] = self.__nBackgroundParameters
if DEBUG:
print("Found parameters = ", self._fitResult['fittedvalues'])
i=0
self._fitResult['parameters'] = []
for param in self.paramlist:
if param['code'] != 'IGNORE':
self._fitResult['parameters'].append(param['name'])
param['fitresult'] = result[0][i]
param['sigma']= result[2][i]
i = i + 1
self._setStatus("Fit finished")
return result
[docs] def modelFunction(self, pars, t):
result = 0.0 * t
nb = self.__nBackgroundParameters
if nb:
result += self._fitConfiguration['functions'][self.getBackgroundFunction()]\
['function'](pars[0:nb], t)
if len(self.paramlist) > nb:
result += self._fitConfiguration['functions'][self.getFitFunction()]\
['function'](pars[nb:], t)
return result
[docs] def numericDerivative(self, f, parameters, index, x):
"""
numericDerivative(self, f, parameters, index, x)
calculates the numeric derivate of f(parameters, x) respect
to the parameter indexed by the given index
"""
#numeric derivative
x=numpy.array(x)
delta = (parameters[index] + numpy.equal(parameters[index],0.0)) * 0.00001
#make a copy of the parameters
newpar = parameters * 1
newpar[index] = parameters[index] + delta
f1 = f(newpar, x)
newpar[index] = parameters[index] - delta
f2 = f(newpar, x)
return (f1-f2) / (2.0 * delta)
[docs] def modelFunctionDerivative(self, pars, index, x):
return self.numericDerivative(self.modelFunction, pars, index, x)
[docs] def getResult(self, configuration=False):
#print " get results to be implemented"
ddict = {}
ddict['result'] = self._fitResult
if configuration:
ddict['configuration'] = self.getConfiguration()
return ddict
def _evaluateBackground(self, x=None):
if x is None:
x = self._x
pars = self._fitResult['fittedvalues']
nb = self.__nBackgroundParameters
if nb:
y = self._fitConfiguration['functions'][self.getBackgroundFunction()]\
['function'](pars[:nb], x)
else:
y = numpy.zeros(x.shape, numpy.float)
if self._fitConfiguration['fit']['strip_flag']:
#If the x is not self._x, how to add the strip?
try:
y += self._z
except:
print("Cannot add strip background")
return y
def _evaluateFunction(self, x=None):
if x is None:
x = self._x
pars = self._fitResult['fittedvalues']
nb = self.__nBackgroundParameters
if len(self.paramlist) > nb:
return self._fitConfiguration['functions'][self.getFitFunction()]\
['function'](pars[nb:], x)
else:
return numpy.zeros(x.shape, numpy.float)
[docs] def evaluateDefinedFunction(self, x=None):
if x is None:
x = self._x
y = self._evaluateBackground(x)
y += self._evaluateFunction(x)
return y
[docs]def test():
from PyMca5.PyMca import SpecfitFunctions
a=SpecfitFunctions.SpecfitFunctions()
x = numpy.arange(1000).astype(numpy.float)
p1 = numpy.array([1500,100.,50.0])
p2 = numpy.array([1500,700.,50.0])
y = a.gauss(p1, x)+1
y = y + a.gauss(p2,x)
fit = SimpleFit()
fit.importFunctions(SpecfitFunctions)
fit.setFitFunction('Gaussians')
#fit.setBackgroundFunction('Gaussians')
#fit.setBackgroundFunction('Constant')
fit.setData(x, y)
fit.fit()
print("Expected parameters 1500,100.,50.0, 1500,700.,50.0")
print("Found: ", fit.paramlist)
from PyMca5.PyMca import PyMcaQt as qt
from PyMca5.PyMca import Parameters
a = qt.QApplication(sys.argv)
a.lastWindowClosed.connect(a.quit)
w =Parameters.Parameters()
w.fillfromfit(fit.paramlist)
w.show()
a.exec_()
if __name__=="__main__":
DEBUG = 1
test()