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)