def setUp(self):
self.minuit = minuit.Minuit(f, x=10, y=10)
def fit(self, *, solver="minuit", method="migrad", **kwargs):
assert self._x is not None and self._y is not None, "No data to fit."
self._assert_data_sanity()
errors = self.combined_errors(allow_zero=False)
if solver == "curve_fit":
from scipy.optimize import curve_fit
popt, pcov = curve_fit(self._func,
xdata=self._x,
ydata=self._y,
p0=self.param_values(),
sigma=errors,
absolute_sigma=True,
**kwargs)
for name, value, error in zip(self.param_names(), popt,
np.sqrt(np.diag(pcov))):
self._check_solver_value(value)
self._check_solver_value(error)
self._param_values[name] = value
self._param_errors[name] = error
elif solver == "minuit":
import minuit
minuit_names, costs = _minuit_costs(self._func, self._x, self._y,
errors)
initial = {}
for name, minuit_name in zip(self.param_names(), minuit_names):
initial[minuit_name] = self._param_values[name]
initial["error_" + minuit_name] = self._param_errors[name]
minuit = minuit.Minuit(costs, **initial)
minuit.up = 1
minuit.strategy = 1 # 0 = fast, 1 = default, 2 = thorough
minuit.printMode = 0
if method == "migrad":
minuit.migrad(**kwargs)
minuit.hesse()
elif method == "simplex":
minuit.simplex(**kwargs)
elif method == "hesse":
minuit.hesse(**kwargs)
elif method == "minos":
minuit.minos(**kwargs)
else:
raise ValueError("Invalid method.")
for name, minuit_name in zip(self.param_names(), minuit_names):
value = minuit.values[minuit_name]
error = minuit.errors[minuit_name]
self._check_solver_value(value)
self._check_solver_value(error)
self._param_values[name] = value
self._param_errors[name] = error
elif solver == "minimize":
from scipy.optimize import minimize, OptimizeWarning
costs = _minimize_costs(self._func, self._x, self._y, errors)
result = minimize(costs,
x0=self.param_values(),
method=method,
jac=False,
**kwargs)
if not result.success:
warn(result.message, OptimizeWarning)
cov = np.linalg.inv(np.dot(result.jac.T, result.jac))
for name, value, error in zip(self.param_names(),
result.itervalues(),
np.sqrt(np.diag(cov))):
self._param_values[name] = value
self._param_errors[name] = error
elif solver == "lmfit":
from lmfit import minimize, fit_report, Parameters
costs = _lmfit_costs(self._func, self._x, self._y, errors)
parameters = Parameters()
for name, value in self._param_values.items():
parameters.add(name, value=value, vary=True)
result = minimize(costs, parameters, method=method)
if not result.success:
warn(result.message)
for name in self.param_names():
self._check_solver_value(parameters[name].value)
self._check_solver_value(parameters[name].stderr)
self._param_values[name] = parameters[name].value
self._param_errors[name] = parameters[name].stderr
else:
raise ValueError("Invalid solver.")
self._fitted = True
import sys
import numpy as np
import pyfits as pf
from WLtools.profiles.nfw import gamma_nfw
import minuit
data = pf.open(sys.argv[1])[1].data
class nfw(object):
def __init__(self, data):
self.data = data
def chi2(self, r, c):
k = gamma_nfw(r, c, self.data['R_gal_1'], self.data['factor_gal_1'], self.data['galaxies_x_1'],
self.data['galaxies_y_1'], self.data['galaxies_r_1'])
chi2 = np.sum(((k[0] - self.data['e1_c']) ** 2) * self.data['weight_LF_1']) + np.sum(
((k[1] - self.data['e2_c']) ** 2) * self.data['weight_LF_1'])
return chi2
model = nfw(data[data['R_gal_1'] < 4])
m = minuit.Minuit(model.chi2, limit_r=(.1, 10.), limit_c=(.1, 15.))
print 'Starting minuit'
m.migrad()
print 'End: r = %3.2f and c = %3.2f' % (m.values['r'], m.values['c'])
def MinuitFitEDBPL(self,x,y,s,pinit=[],limits=(),full_output=False):
"""Function to fit double broken Powerlaw with super exponential pile-up / cut-off
to data using minuit.migrad
pinit[0] = norm
pinit[1] = pl index
pinit[2] = pl index 2
pinit[3] = pl index 3
pinit[4] = 1./ break energy
pinit[5] = 1./ break energy 2
pinit[6] = 1./ cut-off / pile-up 2
returns 3 lists:
1. Fit Stats: ChiSq, Dof, P-value
2. Final fit parameters
3. 1 Sigma errors of Final Fit parameters
"""
npar = 7
fitfunc = errfunc_edbpl
if not len(x) == len(y) or not len(x) == len(s) or not len(y) == len(s):
raise TypeError("Lists must have same length!")
if not len(x) > npar:
print "Not sufficient number of data points => Returning -1"
return -1
x = np.array(x)
y = np.array(y)
s = np.array(s)
def FillChiSq(N0,G1,G2,G3,Bre,Bre2,Cut):
params = N0,G1,G2,G3,Bre,Bre2,Cut
result = 0.
for i,xval in enumerate(x):
result += fitfunc(params,xval,y[i],s[i])**2.
return result
m = minuit.Minuit(FillChiSq)
# Set initial fit control variables
self.SetFitParams(m)
# Set initial Fit parameters, initial step width and limits of parameters
if not len(pinit):
m.values['N0'] = prior_norm(x,y)
m.values['G1'], m.values['G2'],m.values['G3'],m.values['Bre'],m.values['Bre2'] \
= prior_dbpl(x,y)
m.values['Cut'] = prior_epl_cut(x,y)
else:
m.values['N0'],m.values['G1'], m.values['G2'],\
m.values['G3'],m.values['Bre'],m.values['Bre2'],m.values['Cut'] = pinit
if len(limits):
for i in range(len(limits)):
if i == 0:
m.limits['N0'] = limits[i]
if i == 1:
m.limits['G1'] = limits[i]
if i == 2:
m.limits['G2'] = limits[i]
if i == 3:
m.limits['G3'] = limits[i]
if i == 4:
m.limits['Bre'] = limits[i]
if i == 5:
m.limits['Bre2'] = limits[i]
if i == 6:
m.limits['Cut'] = limits[i]
else:
m.limits['G1'] = (self.FitParams['SpecIndLoLim'],self.FitParams['SpecIndUpLim'])
m.limits['G2'] = (self.FitParams['SpecIndLoLim'],self.FitParams['SpecIndUpLim'])
m.limits['G3'] = (self.FitParams['SpecIndLoLim'],self.FitParams['SpecIndUpLim'])
m.limits['Bre'] = (1./(2.*x[-1]),2./(x[0]))
m.limits['Bre2'] = (1./(2.*x[-1]),2./(x[0]))
#m.limits['Cut'] = (0.,2./(x[0]))
m.limits['Cut'] = (1./(2.*x[-1]),2./(x[0]))
for val in m.errors:
m.errors[val] = m.values[val] * self.FitParams['int_steps']
pfinal = np.zeros((npar,))
fit_err = np.zeros((npar,))
try:
m.migrad()
m.hesse()
if self.minos and pvalue(float(len(x) - npar), m.fval) >= 0.05:
m.minos('G1',1.)
m.minos('G2',1.)
m.minos('G3',1.)
m.minos('Cut',1.)
except minuit.MinuitError:
warnings.simplefilter("always")
warnings.warn('Minuit could not fit function!',RuntimeWarning)
if full_output:
return (np.inf,float(npar),np.inf),pfinal,fit_err,m.covariance
else:
return (np.inf,float(npar),np.inf),pfinal,fit_err
fit_stat = m.fval, float(len(x) - npar), pvalue(float(len(x) - npar), m.fval)
for i,val in enumerate(m.values):
if i == 0:
pfinal[i] = m.values['N0']
fit_err[i] = m.errors['N0']
if i == 1:
pfinal[i] = m.values['G1']
fit_err[i] = m.errors['G1']
if i == 2:
pfinal[i] = m.values['G2']
fit_err[i] = m.errors['G2']
if i == 3:
pfinal[i] = m.values['G3']
fit_err[i] = m.errors['G3']
if i == 4:
pfinal[i] = m.values['Bre']
fit_err[i] = m.errors['Bre']
if i == 5:
pfinal[i] = m.values['Bre2']
fit_err[i] = m.errors['Bre2']
if i == 6:
pfinal[i] = m.values['Cut']
fit_err[i] = m.errors['Cut']
if full_output:
return fit_stat,pfinal,fit_err,m.covariance
else:
return fit_stat,pfinal,fit_err
def totchi(ce, ge, ratse, delta, Eg, de, s, phi, decayel, decaymu,
decaytau, E_d):
return chitot(ce, ge, ratse, delta, Eg, de, s, phi, decayel,
decaymu, decaytau, E_d) + chiposi(
ce, ge, ratse, delta, phi, decayel, decaymu,
decaytau)
chilist = []
minchi = {}
#for sm in range(len(smooth)):
for p in range(len(solmod)):
for bkc in range(len(bkcutscan)):
m = minuit.Minuit(totchi)
m.maxcalls = None
m.values['s'] = smooth[sm]
m.values['phi'] = solmod[p]
#m.fixed['Eg'] = True
#m.fixed['E_d'] = True
#m.fixed['Epn'] = True
m.fixed['s'] = True
m.fixed['phi'] = True
m.values['ce'] = 1.0
#m.limits['ce'] = (1,1300)
m.limits['ce'] = (0.001, 100)
#m.fixed['diffelec'] = True
m.values['ge'] = 3.1
m.limits['ge'] = (2.5, 4)
def MinuitFitSN(self,x,y,s,pinit=[],limits=(),fixed=[], full_output=False):
"""Function to fit super nova type II lightcurve
according to Cowen et al. 2009, Eq. (1) + Eq. (2)
pinit[0] = a1
pinit[1] = a2
pinit[2] = a3
pinit[3] = t0
returns 3 lists:
1. Fit Stats: ChiSq, Dof, P-value
2. Final fit parameters
3. 1 Sigma errors of Final Fit parameters
"""
npar = 4
fitfunc = errfunc_sn
if not len(x) == len(y) or not len(x) == len(s) or not len(y) == len(s):
raise TypeError("Lists must have same length!")
if not len(x) > npar:
print "Not sufficient number of data points => Returning -1"
return -1
x = np.array(x)
y = np.array(y)
s = np.array(s)
def FillChiSq(p0,p1,p2,t0):
params = p0,p1,p2,t0
result = 0.
for i,xval in enumerate(x):
result += fitfunc(params,xval,y[i],s[i])**2.
return result
m = minuit.Minuit(FillChiSq)
# Set initial fit control variables
self.SetFitParams(m)
# Set initial Fit parameters, initial step width and limits of parameters
if not len(pinit):
m.values['p0'] = 1.
m.values['p1'] = 1.
m.values['p2'] = 1.
m.values['t0'] = 1.
else:
m.values['p0'], m.values['p1'], m.values['p2'],m.values['t0'] = pinit
if not len(fixed): # fix certain parameters?
m.fixed['p0'] = False
m.fixed['p1'] = False
m.fixed['p2'] = False
m.fixed['t0'] = False
else:
m.fixed['p0'], m.fixed['p1'], m.fixed['p2'],m.fixed['t0'] = fixed
if len(limits):
for i in range(len(limits)):
if i == 0:
m.limits['p0'] = limits[i]
if i == 1:
m.limits['p1'] = limits[i]
if i == 2:
m.limits['p2'] = limits[i]
if i == 3:
m.limits['t0'] = limits[i]
else:
m.limits['p0'] = (-1.e-10,1e10)
m.limits['p1'] = (-1.e-10,1e10)
m.limits['p2'] = (-1.e-10,1e10)
m.limits['t0'] = (1.e-10,1e10)
for val in m.errors:
m.errors[val] = m.values[val] * self.FitParams['int_steps']
pfinal = np.zeros((npar,))
fit_err = np.zeros((npar,))
try:
m.migrad()
m.hesse()
if self.minos and pvalue(float(len(x) - npar), m.fval) >= 0.05:
m.minos('p0',1.)
m.minos('p1',1.)
m.minos('p2',1.)
m.minos('t0',1.)
except minuit.MinuitError:
warnings.simplefilter("always")
warnings.warn('Minuit could not fit function!',RuntimeWarning)
if full_output:
return (np.inf,float(npar),np.inf),pfinal,fit_err,m.covariance
else:
return (np.inf,float(npar),np.inf),pfinal,fit_err
fit_stat = m.fval, float(len(x) - npar), pvalue(float(len(x) - npar), m.fval)
for i,val in enumerate(m.values):
if i == 0:
pfinal[i] = m.values['p0']
fit_err[i] = m.errors['p0']
if i == 1:
pfinal[i] = m.values['p1']
fit_err[i] = m.errors['p1']
if i == 2:
pfinal[i] = m.values['p2']
fit_err[i] = m.errors['p2']
if i == 3:
pfinal[i] = m.values['t0']
fit_err[i] = m.errors['t0']
if full_output:
return fit_stat,pfinal,fit_err,m.covariance
else:
return fit_stat,pfinal,fit_err
def MinuitFitPL(self,x,y,s,pinit=[],limits=(),full_output=False):
"""Function to fit Powerlaw to data using minuit.migrad
pinit[0] = norm
pinit[1] = pl index
returns 3 lists:
1. Fit Stats: ChiSq, Dof, P-value
2. Final fit parameters
3. 1 Sigma errors of Final Fit parameters
"""
npar = 2
fitfunc = errfunc_pl
if not len(x) == len(y) or not len(x) == len(s) or not len(y) == len(s):
raise TypeError("Lists must have same length!")
if not len(x) > npar:
print "Not sufficient number of data points => Returning -1"
return -1
x = np.array(x)
y = np.array(y)
s = np.array(s)
def FillChiSq(N0,G1):
params = N0,G1
result = 0.
for i,xval in enumerate(x):
result += fitfunc(params,xval,y[i],s[i])**2.
return result
m = minuit.Minuit(FillChiSq)
# Set initial fit control variables
self.SetFitParams(m)
# Set initial Fit parameters, initial step width and limits of parameters
if not len(pinit):
m.values['N0'] = prior_norm(x,y)
m.values['G1'] = prior_pl_ind(x,y)
else:
m.values['N0'] = pinit[0]
m.values['G1'] = pinit[1]
if len(limits):
for i in range(len(limits)):
if i == 0:
m.limits['N0'] = limits[i]
if i == 1:
m.limits['G1'] = limits[i]
else:
m.limits['G1'] = (self.FitParams['SpecIndLoLim'],self.FitParams['SpecIndUpLim'])
for val in m.errors:
m.errors[val] = m.values[val] * self.FitParams['int_steps']
pfinal = np.zeros((npar,))
fit_err = np.zeros((npar,))
try:
m.migrad()
m.hesse()
if self.minos and pvalue(float(len(x) - npar), m.fval) >= 0.05:
m.minos('G1',1.)
except minuit.MinuitError:
warnings.simplefilter("always")
warnings.warn('Minuit could not fit function!',RuntimeWarning)
if full_output:
return (np.inf,float(npar),np.inf),pfinal,fit_err,m.covariance
else:
return (np.inf,float(npar),np.inf),pfinal,fit_err
fit_stat = m.fval, float(len(x) - npar), pvalue(float(len(x) - npar), m.fval)
for i,val in enumerate(m.values):
pfinal[i] = m.values[val]
fit_err[i] = m.errors[val]
if full_output:
return fit_stat,pfinal,fit_err,m.covariance
else:
return fit_stat,pfinal,fit_err
xx4 = ScoresP.SizeRatio
#x5 = ScoresP.DiS_Hyd_ration - Held fixed at default
#x6 = ScoresP.SpecialRatio - Held fixed at default
#x7 = ScoresP.CornerRatio - Not in use
xx8 = ScoresP.SideBondRatio
xx9 = ScoresP.LoopPenalty
xx10 = ScoresP.CornerCutPenalty
xx11 = ScoresP.TurnVolPenaly
xx12 = ScoresP.LoopWeight
print 'start looking for optimal parameters'
# limit_x$ set the value limits for the parameter x$
# x$ = xx$ sets the starting point for x$
m = minuit.Minuit(GetScoreQuality,limit_x2=(20,90),
limit_x3=(50,150),limit_x4=(50,350),limit_x8=(10,100),limit_x9=(10,650),
limit_x10=(20,250),limit_x11=(10,1500),limit_x12=(0.3,0.9),
x2=xx2,x3=xx3,x4=xx4,x8=xx8,x9=xx9,x10=xx10,x11=xx11,x12=xx12,
err_x2=10,err_x3=10,err_x4=10,
err_x8=10,err_x9=10,err_x10=10,err_x11=10,err_x12=10)
# Strategy 0,1,2 is the level of accuracy
m.strategy = 1 # 0 = fast, 1 = default, 2 = thorough
# tol is the tolerance we ask for in the values we look for
#print '\nm.limits',m.limits
#print '\nm.parameters',m.parameters
#print 'm.values',m.values
#print 'm.strategy',m.strategy
#print 'm.edm',m.edm
print '\nx1 = %.2f ScoresP.HydroRatio - Held fixed at default' % xx1
print 'x2 = %.2f ScoresP.PolarRatio' % xx2
print 'x3 = %.2f ScoresP.ChargeRatio' % xx3
print 'x4 = %.2f ScoresP.SizeRatio' % xx4
def MinuitFitTau_Fermi_Eb(self,x,y,s,pinit=[],limits=(),full_output=False):
"""Function fitted to optical depth
Function given by Fermi tools:
tau(E) = (E - Eb) * p0 + p1 * ln(E/Eb) + p2* ln(E/Eb)**2
Energies in MeV
pinit[0] = p0
pinit[1] = p1
pinit[2] = p2
returns 3 lists:
1. Fit Stats: ChiSq, Dof, P-value
2. Final fit parameters
3. 1 Sigma errors of Final Fit parameters
"""
npar = 3
fitfunc = errfunc_tau_fermi_Eb
if not len(x) == len(y) or not len(x) == len(s) or not len(y) == len(s):
raise TypeError("Lists must have same length!")
if not len(x) > npar:
print "Not sufficient number of data points => Returning -1"
return -1
x = np.array(x)
y = np.array(y)
s = np.array(s)
def FillChiSq(p0,p1,p2):
params = p0,p1,p2
result = 0.
for i,xval in enumerate(x):
result += fitfunc(params,xval,y[i],s[i])**2.
return result
m = minuit.Minuit(FillChiSq)
# Set initial fit control variables
self.SetFitParams(m)
# Set initial Fit parameters, initial step width and limits of parameters
if not len(pinit):
m.values['p0'] = 0.
m.values['p1'] = 1.
m.values['p2'] = 0.5
else:
m.values['p0'], m.values['p1'], m.values['p2'] = pinit
if len(limits):
for i in range(len(limits)):
if i == 0:
m.limits['p0'] = limits[i]
if i == 1:
m.limits['p1'] = limits[i]
if i == 2:
m.limits['p2'] = limits[i]
else:
m.limits['p0'] = (-3.e-1,10.) # set them all positive, so that no upturn in spectra possible
m.limits['p1'] = (-3.e-1,10.)
m.limits['p2'] = (-3.e-1,10.)
for val in m.errors:
m.errors[val] = m.values[val] * self.FitParams['int_steps']
#m.fixed['SupExp'] = True
pfinal = np.zeros((npar,))
fit_err = np.zeros((npar,))
try:
m.migrad()
m.hesse()
if self.minos and pvalue(float(len(x) - npar), m.fval) >= 0.05:
m.minos('p0',1.)
m.minos('p1',1.)
m.minos('p2',1.)
except minuit.MinuitError:
warnings.simplefilter("always")
warnings.warn('Minuit could not fit function!',RuntimeWarning)
if full_output:
return (np.inf,float(npar),np.inf),pfinal,fit_err,m.covariance
else:
return (np.inf,float(npar),np.inf),pfinal,fit_err
fit_stat = m.fval, float(len(x) - npar), pvalue(float(len(x) - npar), m.fval)
for i,val in enumerate(m.values):
if i == 0:
pfinal[i] = m.values['p0']
fit_err[i] = m.errors['p0']
if i == 1:
pfinal[i] = m.values['p1']
fit_err[i] = m.errors['p1']
if i == 2:
pfinal[i] = m.values['p2']
fit_err[i] = m.errors['p2']
if full_output:
return fit_stat,pfinal,fit_err,m.covariance
else:
return fit_stat,pfinal,fit_err
def fit(self,
xdata,
ydata,
sigma,
*,
solver="minuit",
method="migrad",
**kwargs):
assert xdata.shape == ydata.shape, "X and Y must have the same dimensions."
assert sigma is None or sigma.shape == ydata.shape, "Errors and Y data must have the same dimensions."
assert len(xdata) >= len(
self._params), "Must have more data than free parameters."
self._ndf = max(0, len(xdata) - len(self._params))
if solver == "curve_fit":
from scipy.optimize import curve_fit
popt, pcov = curve_fit(self._func,
xdata=xdata,
ydata=ydata,
p0=self.param_values(),
sigma=sigma,
absolute_sigma=True,
**kwargs)
for name, value, error in zip(self.param_names(), popt,
np.sqrt(np.diag(pcov))):
self._check_solver_error(error)
self._params[name] = value
self._errors[self.ERROR_PREFIX + name] = error
elif solver == "minuit":
import minuit
minuit_names, costs = _minuit_costs(self._func, xdata, ydata,
sigma)
initial = {}
for name, minuit_name in zip(self.param_names(), minuit_names):
initial[minuit_name] = self._params[name]
initial["error_" +
minuit_name] = self._errors[self.ERROR_PREFIX + name]
minuit = minuit.Minuit(costs, **initial)
minuit.up = 1
minuit.strategy = 1 # 0 = fast, 1 = default, 2 = thorough
minuit.printMode = 0
if method == "migrad":
minuit.migrad(**kwargs)
minuit.hesse()
elif method == "simplex":
minuit.simplex(**kwargs)
elif method == "hesse":
minuit.hesse(**kwargs)
elif method == "minos":
minuit.minos(**kwargs)
else:
raise ValueError("Invalid method.")
for name, minuit_name in zip(self.param_names(), minuit_names):
value = minuit.values[minuit_name]
error = minuit.errors[minuit_name]
self._check_solver_error(error)
self._params[name] = value
self._errors[self.ERROR_PREFIX + name] = error
elif solver == "minimize":
from scipy.optimize import minimize, OptimizeWarning
costs = _minimize_costs(self._func, xdata, ydata, sigma)
result = minimize(costs,
x0=self.param_values(),
method=method,
jac=False,
**kwargs)
if not result.success:
warn(result.message, OptimizeWarning)
cov = np.linalg.inv(np.dot(result.jac.T, result.jac))
for name, value, error in zip(self.param_names(),
result.itervalues(),
np.sqrt(np.diag(cov))):
self._params[name] = value
self._errors[self.ERROR_PREFIX + name] = error
elif solver == "lmfit":
from lmfit import minimize, fit_report, Parameters
costs = _lmfit_costs(self._func, xdata, ydata, sigma)
parameters = Parameters()
for name, value in self._params.items():
parameters.add(name, value=value, vary=True)
result = minimize(costs, parameters, method=method)
if not result.success:
warn(result.message)
for name in self.param_names():
self._check_solver_error(parameters[name].stderr)
self._params[name] = parameters[name].value
self._errors[self.ERROR_PREFIX +
name] = parameters[name].stderr
else:
raise ValueError("Invalid solver.")
self._data_min = xdata.min()
self._data_max = xdata.max()
self._chi2 = self.calculate_chi2(xdata, ydata, sigma)
# objective function (for an arbitrary number of alignables)
def chi2_arbitrary(*args):
if fixed is None: s = lam * sum(args)**2
else: s = lam * args[fixed]**2
for m in measurements:
s += (m.value - args[m.i] + args[m.j])**2 / m.uncertainty**2
return s
# objective function for Na alignables (in a form that Minuit can accept)
chi2_arguments = ", ".join(["A%i" % i for i in range(Na)])
chi2 = eval("lambda %s: chi2_arbitrary(%s)" % (chi2_arguments, chi2_arguments))
# minimize the objective function using Minuit
import minuit
minimizer = minuit.Minuit(chi2)
minimizer.migrad()
print[minimizer.values["A%i" % i] for i in range(Na)]
# minimize the objective function using linear algebra
from numpy import matrix
from numpy.linalg.linalg import inv, dot
# Equation 15
def vk(k):
s = 0.
for m in measurements:
d = 1. * m.value / m.uncertainty**2
if m.i == k: s += d
if m.j == k: s -= d
import numpy as nm
import string as st
from TheaderCommonFunctions import *
from ReadDate import *
from ThreadClasses import *
from AminoData import *
import pylab as pl
import copy as cp
import minuit
class vars:
def __init__(self):
self.x = 10.0
self.y = 15.0
def f(x,y):
return ((x-2) / 3)**2 + y**2 + y**4
x=10
y=15
m = minuit.Minuit(f,x=10,y=15)
s0.set_ylim(0)
s0.set_xlabel(r"$\Delta t (ps)$",fontsize=40)
s0.set_ylabel(r"# events",fontsize=40)
f1 = plt.figure(figsize=(8,6),dpi=100,facecolor='w',edgecolor='k')
s1 = f1.add_subplot(1,1,1)
f1.subplots_adjust(wspace=0.4,hspace=0.4,bottom=0.2)
lch.hist_err(events[2],bins=50)
s1.set_xlim(deltat_min,deltat_max)
s1.set_ylim(0)
s1.set_xlabel(r"$\Delta t (ps)$",fontsize=40)
s1.set_ylabel(r"# events",fontsize=40)
=======
#print p1
data = [events,deltat_mc]
m = minuit.Minuit(pdfs.extended_maximum_likelihood_function_minuit,p=p0)
print m.values
m.migrad()
>>>>>>> 188c3ba5e96c5bf165488d665ae2b51d278b7574
# Need this command to display the figure.
plt.show()
################################################################################
# Top-level script evironment
################################################################################
if __name__ == "__main__":
main()
def fitLines(coordPairs,lineBasicData, CutLinesValues, bPlot = False) :
fitData = []
j = 1
for i in range(0,len(coordPairs),1) :
print i
print coordPairs[i]
print lineBasicData[i]
for Values, basicData in itertools.izip(CutLinesValues[1:],lineBasicData[1:]):
#chnage slicer values to skip lines which cannot be minimised i.e edge effects or detected false lines
x = Values[0]
f = Values[1]
Err = Values[2]
#chi2 = lambda bg, a, mu, sigma, R: (((f-convolutionfuncG(a, mu, sigma, x, R)+bg)/Err)**2).sum()
#chi2 = lambda bg,a,mu,sigma: ((f -(a/sigma*pylab.sqrt(2*math.pi))*pylab.exp(-(x-mu)**2/sigma**2)+bg)**2/Err**2).sum() #just gauss
#chi2 = lambda bg, a, mu, gamma,R: ((f-convolutionfuncL(a, mu, gamma, x, R)+bg)**2/Err**2).sum() #circleLorentz
chi2 = lambda bg, a, mu, gamma, sigma, R:(((f-convolutionfuncvoi(a, x, mu, sigma, gamma, R)+bg)/Err)**2).sum() #circlevoigt
#chi2 = lambda bg, a, mu, gamma, sigma:(((f-voiSb((x-mu), sigma, gamma,a)+bg)/Err)**2).sum() #voigt
#m=minuit.Minuit(chi2, bg=-505864.835856, a = -408608, mu= 666.961236213, gamma=11.1507399367, sigma=0.750795227728, R=4.87)
#m=minuit.Minuit(chi2, bg=-510099.995856, a = -890000, mu= 668.961236213, gamma=11.1507399367, sigma=0.750795227728)#voigt beta extended
#m=minuit.Minuit(chi2, bg=-505864.835856, a = -408608, mu= 666.961236213, gamma=11.1507399367, sigma=0.750795227728)#voigt shallow
#m=minuit.Minuit(chi2, bg = -500000, a = -basicData[1], mu = basicData[0], gamma = basicData[2], sigma = basicData[2], R=4.87)#tester
#m=minuit.Minuit(chi2, bg = -603807.71721, a = -801908.440558, mu = 389.77133122, gamma = 10.133591096, sigma = 10.161872412, R=4.255771982)
m=minuit.Minuit(chi2, bg = -494532.214627, a = -275192.356194, mu = 389.755898794, gamma = 9.06574437224, sigma = 2, R=11.0398160531)
m.tol = 10000000000
m.printMode = 1
m.migrad()
m.hesse()
m.values
bg = m.values['bg']
a = m.values['a']
mu = m.values['mu']
gamma = m.values['gamma']
sigma = m.values['sigma']
R = m.values['R']
#fit =(a/sigma*pylab.sqrt(2*math.pi))*pylab.exp(-((x-mu)**2)/sigma**2)-bg
#fit =convolutionfuncL(a, mu, gamma, x, R)-bg
#fit = convolutionfuncG(a, mu, sigma, x, R)-bg
fit = convolutionfuncvoi(a, x, mu, sigma, gamma,R)-bg
#fit = voiSb((x-mu), sigma, gamma,a)-bg
#fitData.append([a,mu,bg,sigma,m.errors])
fitData.append([a,mu,bg,gamma,sigma,R,m.errors])
print'fitLines> Covariance Matrix:\n', m.covariance
if bPlot:
pylab.figure()
pylab.errorbar(x,f,Err,label='Data')
pylab.xlabel('Pixels')
pylab.ylabel('no. Photo electrons')
pylab.plot(x,fit,label='Fitted Voigt X Circle')
pylab.legend(loc='best')
pylab.figure(108)
pylab.subplot(5,2,j)
pylab.tight_layout()
ax = pylab.gca()
for tick in ax.xaxis.get_major_ticks():
tick.label1.set_fontsize(9)
for tick in ax.yaxis.get_major_ticks():
tick.label1.set_fontsize(9)
pylab.errorbar(x,f,Err)
pylab.plot(x,fit,label='line:%s'%(j))
pylab.legend(loc='best',prop={'size':8})
j+=1
fitData = pylab.reshape(fitData,(len(fitData),7))
#out_txt(fitData,'')
print 'fitLines> fitData:\n',fitData
return[fitData]
def minuitFit(evalfunc, params, names, values, xvals, yvals, yserr):
"""Do fitting with minuit (if installed)."""
def chi2(params):
"""generate a lambda function to impedance-match between PyMinuit's
use of multiple parameters versus our use of a single numpy vector."""
c = ((evalfunc(params, xvals) - yvals)**2 / yserr**2).sum()
if chi2.runningFit:
chi2.iters += 1
p = [chi2.iters, c] + params.tolist()
str = ("%5i " + "%8g " * (len(params)+1)) % tuple(p)
print(str)
return c
namestr = ', '.join(names)
fnstr = 'lambda %s: chi2(N.array([%s]))' % (namestr, namestr)
# this is safe because the only user-controlled variable is len(names)
fn = eval(fnstr, {'chi2' : chi2, 'N' : N})
print(_('Fitting via Minuit:'))
m = minuit.Minuit(fn, fix_x=True, **values)
# run the fit
chi2.runningFit = True
chi2.iters = 0
m.migrad()
# do some error analysis
have_symerr, have_err = False, False
try:
chi2.runningFit = False
m.hesse()
have_symerr = True
m.minos()
have_err = True
except minuit.MinuitError as e:
print(e)
if str(e).startswith('Discovered a new minimum'):
# the initial fit really failed
raise
# print the results
retchi2 = m.fval
dof = len(yvals) - len(params)
redchi2 = retchi2 / dof
if have_err:
print(_('Fit results:\n') + "\n".join([
u" %s = %g \u00b1 %g (+%g / %g)"
% (n, m.values[n], m.errors[n], m.merrors[(n, 1.0)],
m.merrors[(n, -1.0)]) for n in names]))
elif have_symerr:
print(_('Fit results:\n') + "\n".join([
u" %s = %g \u00b1 %g" % (n, m.values[n], m.errors[n])
for n in names]))
print(_('MINOS error estimate not available.'))
else:
print(_('Fit results:\n') + "\n".join([
' %s = %g' % (n, m.values[n]) for n in names]))
print(_('No error analysis available: fit quality uncertain'))
print("chi^2 = %g, dof = %i, reduced-chi^2 = %g" % (retchi2, dof, redchi2))
vals = m.values
return vals, retchi2, dof
def make_sum_func(n):
call = 'lambda p_' + ', p_'.join([str(i) for i in range(n)])
call += ' : '
for i in range(n):
call += '+ one_item_func( %d, p_%d )' % (i, i)
return eval(call)
f = make_sum_func(3)
grains = {}
for i in range(10):
grains[i] = 43
import minuit
m = minuit.Minuit(f)
m.migrad()
print(m.values)
f = make_sum_func(4)
grains = {}
for i in range(4):
grains[i] = -3.
print('HELLO')
m = minuit.Minuit(f)
m.migrad()
print(m.values)
