gen_fit

Tool for general non-linear fitting based on the Marquardt algorithm. To setup a fit you need to:

1. define parameters and assign them reasonable initial values
2. define a fitting function in terms of the parameters
3. define the fit and carry it out

Depending on the outcome, one might need to change the initial values of the parameters or decide to change which parameters are fixed and which are to be fitted.

1. Setting up the parameters:

   >>> import LT_Fit.parameters as P  # get the parameter module
   >>> import LT_fit.gen_fit as G     # load the genfit module
   >>> a = P.Parameter(1., 'amp')     # parameter a, called 'amp', initialized to 1. 
   >>> b = P.Parameter(3., 'omega')   # parameter b, called 'omega', intialized to 3.
   >>> c = P.Parameter(1.5, 'phase')  # parameter c, called 'phase', initialize to 1.5
   

2. Define the fitting function:

   >>> def f(x):
   ....    return a()*sin(b() * x + c() )
   

3. Now do the fit:

   >>> F = G.genfit( f, [a, b, c], x = xval, y = y_exp) #  the list [a,b,c] defines which parameters are fitted
   >>> F = G.genfit( f, [a], x = xval, y = y_exp, yerr = sigy) #  only a is fitted, but take the exp. error into account
   >>> F = G.genfit( f, [a, c], x = xval, y = y_exp, yerr = sigy) #  a and c are fitted b is kept constant
   

To change the initial values and repeat the fit:

>>> a.set(1.5)
>>> b.set(3.2)
>>> c.set(2.0)
>>> F = G.genfit( f, [a, b, c], x = xval, y = y_exp)

Finally plot the data and the fit:

>>> import LT.box as B
>>> B.plot_exp(xval, y_exp, sigy)   # plot the data with errorbars
>>> F.plot()                        # plot the fitted function as a line    
>>> B.plot_line(F.xpl, F.ypl)       # old version of plotting the fitted function as a line
>>> F(x)                            # evaluate the fitted function at x
>>> show()                          # show the new plot

---

class LT_Fit.gen_fit.genfit(function, parameters, x=None, y=None, y_err=None, nplot=100, full_output=1, ftol=0.001, print_results=True, plot_fit=True, **kwargs)

general non-linear fit based on the Marquardt algorithm

Important keywords:

Keyword	Meaning
y	(numpy.array()) array of experimental values (mandatory)
x	(numpy.array()) array of independent variables
y_err	(numpy.array()) array of errors
nplot	number of points to be used for plotting the fit
ftol	minimal change in chi square to determine if the fit has converged
kwargs	additional keywords are passes to scipy.optimize.least_squares, examples below
bounds	an array for upper and lower bounds for the parameter
loss	alternative loss function to handle outliers e.g. ‘huber’
f_scale	outliers with a residual more the f_scale should be not affect the result
plot_fit	(default True) plot the fitted function automatically

Additional keyword arguments are passed on to scipy.optimize.leastsq()

get_parameters()

use the saved parameters

plot(xv=None, **kwargs)

Plot the fitting function

Parameters:

xvTYPE, optional

x-values for which the fitting function should be plotted. The default is None i.e. using the standard xpl and ypl values.

**kwargsTYPE

keyword aguments passed to matplotlib plot function

Returns:

None.

save_parameters()

make a deep copy of the current parameters to be saved

set_xval(x)

set the array of values x

set_yval(y, y_err=None)

set the array of values to be fitted

show_parameters()

show the fitted parameters