def get_fit_result(
data,
init_params,
model_function,
):
'''
find best fit parameters.
:param data: DataFrame
raw data. index values are sampling events.
:param init_params: dict
:param model_function
function to fit data with.
:return: result: ModelResult
'''
x = data.index.values
y = data.values
model = Model(model_function)
for param, init_value in init_params.items():
model.set_param_hint(param, value=init_value)
params = model.make_params()
result = model.fit(y, params, t=x)
return result
def double_gaussian(self, mod):
"""
Function to fit a double gaussian model to the data
:param mod: model to fit
:return:
- model : results of the fit
- Report of the fit function
"""
min = np.asarray(self.x).min()
max = np.asarray(self.x).max()
moy1 = (min + max) / 2 + 5
moy2 = (min + max) / 2 - 5
gmodel = Model(mod) # create model
# set constraint on parameters value
gmodel.set_param_hint('sigma1_dg', min=0)
gmodel.set_param_hint('sigma2_dg', min=0)
gmodel.set_param_hint('mu1_dg', min=min, max=max)
gmodel.set_param_hint('mu2_dg', min=min, max=max)
self.solution["double_gaussian"] = gmodel.fit(self.y, x=self.x, sigma1_dg=1, sigma2_dg=1, mu1_dg=moy1,
mu2_dg=moy2, add_dg=1, method='powell')
# get results
self.master.info(self.solution["double_gaussian"].fit_report())
print(self.solution["double_gaussian"].fit_report())
self.solution["double_gaussian_fit"] = [self.solution["double_gaussian"].best_values['sigma1_dg'],
self.solution["double_gaussian"].best_values['mu1_dg'],
self.solution["double_gaussian"].best_values['sigma2_dg'],
self.solution["double_gaussian"].best_values['mu2_dg'],
self.solution["double_gaussian"].best_values['add_dg']]
return self.solution["double_gaussian_fit"], self.solution["double_gaussian"].fit_report()
def lorentz(self, mod):
"""
Function to fit a simple lorentz model to the data
:param mod: model to fit
:return:
- model : results of the fit
- Report of the fit function
"""
min = np.asarray(self.x).min()
max = np.asarray(self.x).max()
moy = (min + max) / 2
gmodel = Model(mod) # create model
# set constraint on parameters value
gmodel.set_param_hint('gamma_l', min=0)
gmodel.set_param_hint('mu_l', min=min, max=max)
self.solution["lorentz"] = gmodel.fit(self.y, x=self.x, mu_l=moy, gamma_l=1, add_l=1, method='powell')
# get results
print(self.solution["lorentz"].fit_report())
self.master.info(self.solution["lorentz"].fit_report())
self.solution["lorentz_fit"] = [self.solution["lorentz"].best_values['mu_l'],
self.solution["lorentz"].best_values['gamma_l'],
self.solution["lorentz"].best_values['add_l']]
return self.solution["lorentz_fit"], self.solution["lorentz"].fit_report()
def gauss_step_const(signal, guess):
"""
Fits high contrast data very well
"""
if guess == False:
return [0, 0]
else:
amp, centre, stdev, offset = guess
data = np.array([range(len(signal)), signal]).T
X = data[:,0]
Y = data[:,1]
# gauss_mod = Model(gaussian)
gauss_mod = Model(gaussian)
const_mod = ConstantModel()
step_mod = StepModel(prefix='step')
pars = gauss_mod.make_params(height=amp, center=centre, width=stdev / 3., offset=offset)
# pars = gauss_mod.make_params(amplitude=amp, center=centre, sigma=stdev / 3.)
gauss_mod.set_param_hint('sigma', value = stdev / 3., min=stdev / 2., max=stdev)
pars += step_mod.guess(Y, x=X, center=centre)
pars += const_mod.guess(Y, x=X)
mod = const_mod + gauss_mod + step_mod
result = mod.fit(Y, pars, x=X)
# write error report
#print result.fit_report()
print "contrast fit", result.redchi
return X, result.best_fit, result.redchi
def fit_act(led_volt, led):
model = Model(act, independent_vars=['x'])
model.set_param_hint('xo', value=-1, vary=True)
model.set_param_hint('a', value=1, vary=True)
result = model.fit(led_volt[led][:, 1],
x=led_volt[led][:, 0],
nan_policy='propagate')
return result
def fit_gaussian_peak(w,
f,
amp_hint=-0.5,
cen_hint=None,
wid_hint=0.01,
shift_hint=0.8,
minmax='min'):
"""Fit a single Gaussian to a spectrum line.
Gaussian G(x)=shift+amp*e^(-(x-cen)^2/(2*wid^2))
Uses lmfit package.
Parameters
----------
w, f : 1d arrays
Spectrum range where the minimum is located.
amp_hint : float
Amplitude value to be used as 1st guess when performing the fit.
cen_hint : float
Wavelength of the minimum location, to be used as 1st guess when fitting. If None, the mean value of `w` is used.
wid_hint : float
shift_hint : float
minmax = str
Specifies if the peak to be fitted is a minimum or a maximum, to know if the gaussian amplitude parameter `amp` must be negative or positive, respectively. Default: 'min'.
Returns
-------
lmfit results object
"""
def gaussian(x, amp=1, cen=0, wid=1, shift=0):
return shift + amp * np.exp(-(x - cen)**2 / (2 * wid**2))
# Fit model and parameters
mod = Model(gaussian)
# Amplitude `amp`
if minmax == 'min': mod.set_param_hint('amp', value=amp_hint, max=0.)
elif minmax == 'max': mod.set_param_hint('amp', value=amp_hint, min=0.)
# Center `cen`
if cen_hint is None: cen_hint = np.mean(w)
mod.set_param_hint('cen', value=cen_hint)
# Width `wid`
mod.set_param_hint('wid', value=wid_hint, min=0.)
# Shift in the y-axis `shift`
mod.set_param_hint('shift', value=shift_hint)
# mod.set_param_hint('fwhm', expr='2.35482004503*wid')
# mod.set_param_hint('height', expr='shift+amp')
gfitparams = mod.make_params()
# Fit
lmfitresult = Model(gaussian).fit(f, x=w, params=gfitparams)
return lmfitresult
def fit_model(ms_dx, guess_s, hours_per_frame=5/60):
fitfunc = lambda T, s, p: (s**2 * p**2) * (T/p - 1 + exp(-T/p))
n = len(ms_dx)//2
model = Model(fitfunc)
model.set_param_hint('s', value=guess_s, min=0, max=250)
# Constrain persistence time to ≥ 1 minute
model.set_param_hint('p', value=0.5, min=1/60.)
T = (arange(len(ms_dx)) + 1) * hours_per_frame
result = model.fit(ms_dx[:n], T=T[:n])
return result, (T, result.best_fit)
def gaussfit2d_multi(data, x, y, p0, **kwargs):
plot = kwargs.get('plot', True)
import numpy as np
from lmfit import Parameters, Parameter, minimize, Model
import funk
import matplotlib.pyplot as plt
def gauss2d_flat(x, y, amp, xcenter, ycenter, xwidth,
ywidth): # This ends up as f(y,x)
my, mx = np.meshgrid(x, y)
xwidth, ywidth = xwidth / 2., ywidth / 2.
return np.ravel(amp * np.exp(-2 * (np.square(mx - ycenter) /
(np.square(ywidth)))) *
np.exp(-2 * (np.square(my - xcenter)) /
(np.square(xwidth))))
def zero(x, y, a):
return np.ravel(a * np.zeros((np.shape(x)[0], np.shape(y)[0])))
n = len(p0[0])
fullmod = Model(zero, independent_vars=['x', 'y'], param_names='a')
fullmod.set_param_hint('a', value=0, max=.001, min=-.001)
for i in range(n):
# Define x,y grid and p_0 names
p_0s = ['amp', 'xcenter', 'ycenter', 'xwidth', 'ywidth']
func_model = Model(gauss2d_flat,
independent_vars=['x', 'y'],
param_names=p_0s,
prefix='g' + str(i + 1) + '_')
fullmod += func_model
fullmod.set_param_hint('g' + str(i + 1) + '_amp',
value=p0[0][i],
min=0)
fullmod.set_param_hint('g' + str(i + 1) + '_xcenter', value=p0[1][i])
fullmod.set_param_hint('g' + str(i + 1) + '_ycenter', value=p0[2][i])
fullmod.set_param_hint('g' + str(i + 1) + '_xwidth',
value=p0[3][i],
min=0)
fullmod.set_param_hint('g' + str(i + 1) + '_ywidth',
value=p0[4][i],
min=0)
result = fullmod.fit(np.ravel(data), x=x, y=y)
if plot == True:
plt.figure('best_fit')
plt.clf()
plt.imshow(np.flipud(np.reshape(result.eval(), np.shape(data))),
interpolation='nearest',
extent=[x[0], x[-1], y[0], y[-1]])
plt.colorbar(orientation='vertical')
return result.best_values, np.flipud(
np.reshape(result.eval(), np.shape(data)))
def fit_gauss_ramsey(x_data, y_data, weight_power=None, maxiter=None, maxfun=5000, verbose=1, initial_params=None):
""" Fit a gauss_ramsey. The function gauss_ramsey gives a model for the measurement result of a pulse Ramsey
sequence while varying the free evolution time, the phase of the second pulse is made dependent on the free
evolution time.
This results in a gaussian decay multiplied by a sinus. Function as used by T.F. Watson et all.,
see function 'gauss_ramsey' and example in qtt/docs/notebooks/example_fit_ramsey.ipynb
Args:
x_data (array): the data for the independent variable
y_data (array): the data for the measured variable
weight_power (float or None): If a float then weight all the residual errors with a scale factor
maxiter (int): maximum number of iterations to perform
maxfun (int): maximum number of function evaluations to make
verbose (int): set to >0 to print convergence messages
initial_params (None or array): optional, initial guess for the fit parameters: [A,C,ramseyfreq,angle,B]
Returns:
par_fit (array): array with the fit parameters: [A,t2s,ramseyfreq,angle,B]
result_dict (dict): dictionary containing a description, the par_fit and initial_params
"""
def gauss_ramsey_model(x, amplitude, decay_time, frequency, phase, offset):
""" """
y = gauss_ramsey(x, [amplitude, decay_time, frequency, phase, offset])
return y
if weight_power is None:
weights = None
else:
diff_x = np.diff(x_data)
weights = np.hstack((diff_x[0], diff_x)) ** weight_power
if initial_params is None:
initial_parameters = estimate_parameters_damped_sine_wave(x_data, y_data, exponent=2)
else:
initial_parameters = initial_params
lmfit_model = Model(gauss_ramsey_model)
lmfit_model.set_param_hint('amplitude', min=0)
lmfit_model.set_param_hint('decay_time', min=0)
lmfit_result = lmfit_model.fit(y_data, x=x_data, **dict(zip(lmfit_model.param_names, initial_parameters)),
verbose=verbose >= 2, weights=weights)
import qtt.algorithms.fitting
result_dict = qtt.algorithms.fitting.extract_lmfit_parameters(lmfit_model, lmfit_result)
result_dict['description'] = 'Function to analyse the results of a Ramsey experiment, ' + \
'fitted function: gauss_ramsey = A * exp(-(x_data/t2s)**2) * sin(2*pi*ramseyfreq * x_data - angle) + B'
# backwards compatibility
result_dict['parameters fit'] = result_dict['fitted_parameters']
result_dict['parameters initial guess'] = initial_parameters
return result_dict['fitted_parameters'], result_dict
class CurveFitObject(object):
"""
Wrapper for curve fitting objects
Parameters:
paramList: List of parameters, with initial guess, max and min values
Each parameter is a dict with the following form
{'name': str PARAMETER NAME,
'guess': float or lambda function
'max': float or lambda function
'min': float or lambda function
'vary' True or False}
growthEquation: A function to fit with the following form:
def growthEquation(t, param1, param2, ..): return f(param1,param2,..)
method: lmfit method (slsqp, leastsq)
"""
def __init__(self, paramList, growthEquation, method='slsqp'):
self.paramList = paramList
self.growthEquation = growthEquation
self.gmod = Model(growthEquation)
self.method = method
def calcFit(self, t, data, **kwargs):
if 'method' not in kwargs:
method = self.method
else:
method = kwargs['method']
for param in self.paramList:
# Check if the parameter is a lambda function
temp = dict()
for hint in ['guess', 'min', 'max']:
# print('hint: ',hint,'param[hint]: ',param[hint])
if type(param[hint]) == type(lambda x: 0):
temp[hint] = param[hint](data)
else:
temp[hint] = param[hint]
self.gmod.set_param_hint(param['name'],
value=temp['guess'],
min=temp['min'],
max=temp['max'],
vary=param['vary'])
try:
params = self.gmod.make_params()
except Exception as e:
print(data)
print(e)
result = self.gmod.fit(data, params, t=t, method=method, **kwargs)
result.fit_report()
return result
def PlotSPE(h,b,c,ext):
#b1=numpy.array(b1)
#c1=numpy.array(c1)
#cond = (b1>=600) & (b1<=800)
#b = b1[ cond ]
#c = c1[ cond ]
ofilename=OUTDIR+"/"+bsfile[0]+".png"
sh_marker=["+",".","^","*","p","s","x","D","h","o","+",".","^","*","p","s","x","D","h","o","+",".","^","*","p","s"]
sh_color=['b','g','r','c','m','y','k','orange','darkblue','darkgreen','darkred','darkcyan','darkmagenta','deeppink','firebrick','gold','darkviolet','lavenderblush','dodgerblue','indigo','limegreen']
#gmodel = Model(gaussian) + Model(line)
#gmodel = Model(gaussian) + Model(expo)
gmodel = Model(fit_function)
gmodel.set_param_hint('A', value=10000)
gmodel.set_param_hint('beta', value=0.001)
gmodel.set_param_hint('B', value=500)
gmodel.set_param_hint('mu', value=660)
gmodel.set_param_hint('sigma', value=30)
pars = gmodel.make_params()
result = gmodel.fit(c, pars,x=b)
print(result.fit_report())
#print result.params
print "%6.2f %6.4f"%(result.params["mu"].value,result.params["sigma"].value)
fig = plt.gcf()
plt.title(h[0],fontsize=14,fontweight='bold')
if "spe" in ext:
plt.xlabel('Energy ',fontsize=14,fontweight='bold')
else:
plt.xlabel('Bins ',fontsize=14,fontweight='bold')
plt.ylabel('Counts ',fontsize=14,fontweight='bold')
plt.tick_params(labelsize=18)
#plt.text(energyBins[binid][0]+10, 0.8*maxv2,strv,fontsize=14,fontweight='bold')
plt.plot(b,c,marker=sh_marker[0],linestyle='None',color=sh_color[0],label=bsfile)
plt.plot(b, result.best_fit, 'r-', label="fit %6.2f %6.4f"%(result.params["mu"].value,result.params["sigma"].value))
legend = plt.legend(loc='upper right', shadow=True)
frame = legend.get_frame()
frame.set_facecolor('0.90')
for label in legend.get_texts():
label.set_fontsize('large')
for label in legend.get_lines():
label.set_linewidth(1.5) # the legend line width
plt.grid(True)
#plt.yscale('log')
plt.autoscale(enable=True, axis='y')
fig.set_size_inches(16,12)
plt.savefig(ofilename,dpi=100)
plt.show()
def all_fits(count,pers,plot=False,subax=None,do_two_expo=False):
tmp={}
# single
try:
popt, pcov = curve_fit(single_exp,pers[2::],count[2::])
model=Model(single_exp)
model.set_param_hint('a1', value=popt[0],vary=False)
model.set_param_hint('b1', value=popt[1],vary=False)
result = model.fit(count[2::], x=pers[2::])
tmp['single_exp']={'bic':result.bic,'params':result.best_values,'best_fit':result.best_fit}
except Exception,e:
tmp['single_exp']={'bic':None,'params':{'a1':np.nan,'b1':np.nan},'best_fit':None}
def test_main():
from get_ssa import get_ssa
zenith = 53.1836240528
AMass = 1.66450160404
rel_h = 0.665
pressure = 950
AM = 5
ssa = get_ssa(rel_h, AM)
x = np.linspace(200, 800, 100) # config
variables = ['alpha', 'beta', 'g_dsa', 'g_dsr'] # config
expected_values = [2.5, 0.06, 0.6, 0.5]
print('Expected: %s' % expected_values)
guess = [1.0, 0.01, 0.5, 0.8] # config
bounds = [(-0.2, 4), (0., 3), (0., 2.), (0., 2.)] # config
# Theano
irr_symbol = IrradianceModel_sym(x, zenith, AMass, pressure, ssa, variables)
getIrrRatio = irr_symbol.getcompiledModel('ratio')
y_theano = getIrrRatio(*expected_values)
res = Residuum(irr_symbol, 'ratio')
residuum = FitWrapper(res.getResiduum())
residuals = FitWrapper(res.getResiduals())
derivative = FitWrapper(res.getDerivative())
Fit = FitModel()
result = Fit._minimize(residuum, guess, y_theano, bounds, jacobian=derivative)
print("Got %s" % result.x)
resultls = Fit._least_squares(residuals, guess, y_theano, bounds)
print("Got %s" % resultls.x)
# Python
IrradianceObject = IrradianceModel_python(AMass, rel_h, ssa, zenith, pressure)
y_python = IrradianceObject.irradiance_ratio(x, 2.5, 0.06,0.0, 0.6, 0.5)
gmod = Model(IrradianceObject.irradiance_ratio, independent_vars=['x'], param_names=variables)
gmod.set_param_hint('alpha', value=guess[0], min=bounds[0][0], max=bounds[0][1])
gmod.set_param_hint('beta', value=guess[1], min=bounds[1][0], max=bounds[1][1])
gmod.set_param_hint('g_dsa', value=guess[2], min=bounds[2][0], max=bounds[2][1])
gmod.set_param_hint('g_dsr', value=guess[3], min=bounds[3][0], max=bounds[3][1])
result_lmfit = gmod.fit(y_python, x=x)
print(result_lmfit.fit_report())
plt.plot(x, y_theano)
x_new = np.linspace(300, 900,150)
irr_symbol.set_wavelengthAOI(x_new)
getIrrRatio = irr_symbol.getcompiledModel('ratio')
y_new = getIrrRatio(*expected_values)
plt.plot(x_new, y_new, '+', label='different wavelengths')
plt.legend()
plt.show()
def center_on_cos(raw_quadratures, phi0=None, omega=None, snap_omega=False):
mean = scipy.average(raw_quadratures, axis=1)
no_angles, no_pulses = raw_quadratures.shape
model = Model(cos_model)
offset, amplitude, phi0, omega = guess_initial_parameters(
mean, phi0, omega)
model.set_param_hint("offset", value=offset)
model.set_param_hint("amplitude", min=0., value=amplitude)
model.set_param_hint("phi0", value=phi0)
model.set_param_hint("omega", min=0., value=omega)
model.make_params(verbose=False)
steps = scipy.arange(no_angles)
res = model.fit(mean, x=steps, verbose=False)
omega_param = res.params["omega"]
if snap_omega:
appx_omega = float(omega_param)
no_pi_intervals = int(round(pi / appx_omega))
omega = pi / no_pi_intervals
omega_param.set(omega, vary=False)
res.fit(mean, x=steps, verbose=False)
d_value, p_value_ks = kstest(res.residual, 'norm')
mean_fit = res.eval(x=steps)
offset = mean - mean_fit
aligned_quadratures = raw_quadratures - offset[:, None]
centered_quadratures = aligned_quadratures - float(res.params["offset"])
return (centered_quadratures, float(omega_param),
float(res.params["phi0"]), p_value_ks)
def center_on_cos(raw_quadratures, phi0=None, omega=None, snap_omega=False):
mean = scipy.average(raw_quadratures, axis=1)
no_angles, no_pulses = raw_quadratures.shape
model = Model(cos_model)
offset, amplitude, phi0, omega = guess_initial_parameters(mean, phi0, omega)
model.set_param_hint("offset", value=offset)
model.set_param_hint("amplitude", min=0., value=amplitude)
model.set_param_hint("phi0", value=phi0)
model.set_param_hint("omega", min=0., value=omega)
model.make_params(verbose=False)
steps = scipy.arange(no_angles)
res = model.fit(mean, x=steps, verbose=False)
omega_param = res.params["omega"]
if snap_omega:
appx_omega = float(omega_param)
no_pi_intervals = int(round(pi/appx_omega))
omega = pi/no_pi_intervals
omega_param.set(omega, vary=False)
res.fit(mean, x=steps, verbose=False)
d_value, p_value_ks = kstest(res.residual, 'norm')
mean_fit = res.eval(x=steps)
offset = mean-mean_fit
aligned_quadratures = raw_quadratures - offset[:,None]
centered_quadratures = aligned_quadratures - float(res.params["offset"])
return (centered_quadratures,
float(omega_param), float(res.params["phi0"]), p_value_ks)
def create_model(func, backend="lmfit"):
"""
Returns a model-class of the selected package for fitting.
Parameters
----------
func :
sth
backend : str
- lmfit: uses `lmfit´ package for fitting
- iminuit: uses `iminuit´ package for fitting
Return
------
model : lmfit.Model or iminuit.Minuit object
"""
if backend.upper() == "LMFIT":
model = Model(func)
model.set_param_hint("A", min=0.0)
model.set_param_hint("omega", value=2 * pi / 16, vary=False)
model.set_param_hint("phi", min=0.0, max=2 * pi)
model.set_param_hint("y0", min=0.0)
return model
elif backend.upper() == "IMINUIT":
raise NotImplementedError
else:
raise KeyError("The backend '{}' is not recognized.".format(backend))
def fit_model_error(t, y, wt=1):
gmodel = Model(correlation)
gmodel.set_param_hint('g0', value=0.1)
gmodel.set_param_hint('tauD', value=1e-4, min=1e-6, max=100)
gmodel.set_param_hint('sp', value=0.01, min=0.001, max=0.1)
gmodel.set_param_hint('bl', value=1e-6)
pars = gmodel.make_params()
return gmodel.fit(y, pars, t=t, weights=wt)
def test_weird_param_hints(self):
# tests Github Issue 312, a very weird way to access param_hints
def func(x, amp):
return amp*x
m = Model(func)
models = {}
for i in range(2):
m.set_param_hint('amp', value=1)
m.set_param_hint('amp', value=25)
models[i] = Model(func, prefix='mod%i_' % i)
models[i].param_hints['amp'] = m.param_hints['amp']
self.assertEqual(models[0].param_hints['amp'],
models[1].param_hints['amp'])
def test_hints_in_composite_models(self):
# test propagation of hints from base models to composite model
def func(x, amplitude):
pass
m1 = Model(func, prefix='p1_')
m2 = Model(func, prefix='p2_')
m1.set_param_hint('amplitude', value=1)
m2.set_param_hint('amplitude', value=2)
mx = (m1 + m2)
params = mx.make_params()
param_values = {name: p.value for name, p in params.items()}
self.assertEqual(param_values['p1_amplitude'], 1)
self.assertEqual(param_values['p2_amplitude'], 2)
def _iterate(simulation, expected, guess, bounds, variables, independent, callable_, global_, local_):
biased_parameters = np.zeros((len(local_['input']), len(expected)))
success_ar = np.zeros(len(local_['input']))
expected_dict = {key: value for key, value in zip(variables, expected)}
gmod = Model(callable_, independent_vars=independent.keys(), param_names=variables, method='lbfgsb')
for param, ini, limits in zip(variables, guess, bounds):
gmod.set_param_hint(param, value=ini, min=limits[0], max=limits[1])
independent[global_['param']] = global_['input']
for i, input_ in enumerate(local_['input']):
independent[local_['param']] = input_
result = gmod.fit(simulation, verbose=False, **independent)
print(result.fit_report())
success_ar[i] = result.success
biased_parameters[i] = np.array([result.params[key].value - expected_dict[key] for key in variables])
return biased_parameters, success_ar
def test_constraints_function_call():
"""Test a constraint with simple function call in Model class."""
x = [1723, 1773, 1823, 1523, 1773, 1033.03078, 1042.98077, 1047.90937,
1053.95899, 1057.94906, 1063.13788, 1075.74218, 1086.03102]
y = [0.79934, -0.31876, -0.46852, 0.05, -0.21, 11.1708, 10.31844, 9.73069,
9.21319, 9.12457, 9.05243, 8.66407, 8.29664]
def VFT(T, ninf=-3, A=5e3, T0=800):
return ninf + A/(T-T0)
vftModel = Model(VFT)
vftModel.set_param_hint('D', vary=False, expr=r'A*log(10)/T0')
result = vftModel.fit(y, T=x)
assert 2600.0 < result.params['A'].value < 2650.0
assert 7.0 < result.params['D'].value < 7.5
def getModel(self, guess_T12, guess_fragility, guess_log_eta_inf):
'''
Creates a model for regression.
Parameters
----------
guess_T12 : float
Guess for the temperature were the viscosity is 10^12 Pa.s.
guess_fragility : float
Guess for the fragility index.
guess_log_eta_inf : array_like, optional
Guess for the base-10 logarithm of the infinite viscosity.
Notes
-----
The parameters 'T0' and 'A' are also added in the model paremeters.
Returns
-------
model : instance of lmfit's Model class.
'''
model = Model(eq.Dienes, name=self.__str__())
T12 = guess_T12
m = guess_fragility
n = guess_log_eta_inf
guess_T0 = T12 * (1 - (12 - n) / m)
guess_A = -log(10) * (12 - n - m) / (guess_T0 / (T12 - guess_T0)**2)
guess_B = T12 * log(10) / guess_T0 * (T12 *
(12 - n - m) + guess_T0 * m)
model.set_param_hint('log_eta_inf',
vary=True,
max=11.99,
value=guess_log_eta_inf)
model.set_param_hint(
'T0',
vary=True,
min=0,
value=guess_T0,
)
model.set_param_hint(
'A',
vary=True,
value=guess_A,
)
model.set_param_hint(
'B',
vary=True,
value=guess_B,
)
return model
def fit_fold(pspec, init):
'''
Fit the Fold power spectrum model to pspec and compute AIC score.
Uses the package LMFIT for optimisation.
Args
--------------
pspec: pd.Series
Power spectrum data as a Series indexed by frequency.
init: list of floats
Initial parameter guesses of the form [sigma_init, lambda_init].
Returns
----------------
list:
Form [aic, result] where aic is the AIC score for the model fit,
and result is a handle that contains further information on the fit.
'''
# Put frequency values and power values as a list to use LMFIT
freq_vals = pspec.index.tolist()
power_vals = pspec.tolist()
sigma_init, lambda_init = init
# Assign model object
model = Model(psd_fold)
# Set up constraint S(wMax) < psi_fold*S(0)
psi_fold = 0.5
wMax = max(freq_vals)
# Parameter constraints for sigma
model.set_param_hint('sigma', value=sigma_init, min=0, max=10 * sigma_init)
# Parameter constraints for lambda
model.set_param_hint('lam',
min=-np.sqrt(psi_fold / (1 - psi_fold)) * wMax,
max=0,
value=lambda_init)
# Assign initial parameter values and constraints
params = model.make_params()
# Fit model to the empircal spectrum
result = model.fit(power_vals, params, w=freq_vals)
# Compute AIC score
aic = result.aic
# Export AIC score and model fit
return [aic, result]
def fit_model(t, y, jj, zjj, meanz, stdd):
gmodel = Model(gaus1)
gmodel.set_param_hint('a', value=zjj, min=0.8*zjj, max=1.2*zjj)
gmodel.set_param_hint('b', value=jj, min=jj-2, max=jj+2)
gmodel.set_param_hint('w', value=1.2, min=0.1, max=20)
gmodel.set_param_hint('y0', value=meanz, min=meanz -
stdd/2, max=meanz + stdd/2)
pars = gmodel.make_params()
return gmodel.fit(y, pars, t=t)
def PixSED_Xstk(nus, maps, FuncModel, pix, pix_red, istk, covMat, nus_edge,
maxfev = 10000, verbose = False, initP0 = None, chi2 = None,
nsamples = 5000, new = False):
if new:
gmodel = Model(FuncModel)
#Set initial params...
#print(gmodel.fit(maps[:, pix, istk], pars, x = nus, nan_policy = "omit"))
if initP0 != None:
for j, ipar in enumerate(gmodel.param_names):
gmodel.set_param_hint(ipar, value = initP0[j])
pars = gmodel.make_params()
fit_par = gmodel.fit(maps[:, pix, istk], pars, x = nus, nan_policy = "omit")
popt = list(fit_par.best_values.values())
else:
popt, pcov = curve_fit(FuncModel, nus, maps[:, pix, istk],
sigma = covMat[:, :, istk, pix_red], absolute_sigma=True,
maxfev = maxfev, p0 = initP0)
#popt = initP0
if verbose:
print("Calling LogLikelihood", popt, pcov)
print("xvals, yvals", nus, maps[:, pix, istk])
myfit = mcmc.LogLikelihood(xvals = nus, yvals = maps[:, pix, istk],
errors = covMat[:, :, istk, pix_red], chi2 = chi2,
model = FuncModel, p0 = popt)
#print("myfit info: " )
fit_prep = myfit.run(nsamples)
#print("Doing chain")
flat_samples = fit_prep.get_chain(discard = nsamples//2, thin=32, flat=True)
#print("Samples ", flat_samples, np.shape(flat_samples))
nspls = flat_samples.shape[0]
#Generating realizations for parameters of the model (fake X(nu))
x = np.linspace(nus_edge[0], nus_edge[-1], nsamples//2)
vals = np.zeros((len(x), nspls))
for i in range(len(x)):
for j in range(nspls):
vals[i, j] = FuncModel(x[i], *flat_samples[j, :])
mvals = np.mean(vals, axis=1)
svals = np.std(vals, axis=1)
return mvals, svals, x, flat_samples
def fit_null(pspec, init):
'''
Fit the Null power spectrum model to pspec and compute AIC score.
Uses the package LMFIT for optimisation.
Args
--------------
pspec: pd.Series
Power spectrum data as a Series indexed by frequency
init: list of floats
Initial parameter guesses of the form [sigma_init]
Returns
----------------
list:
Form [aic, result] where aic is the AIC score for the model fit,
and result is a handle that contains further information on the fit.
'''
# Put frequency values and power values as a list to use LMFIT
freq_vals = pspec.index.tolist()
power_vals = pspec.tolist()
sigma_init = init[0]
# Assign model object
model = Model(psd_null)
# Initial parameter value for Null fit
model.set_param_hint('sigma',
value=sigma_init,
vary=True,
min=0,
max=10 * sigma_init)
# Assign initial parameter values and constraints
params = model.make_params()
# Fit model to the empircal spectrum
result = model.fit(power_vals, params, w=freq_vals)
# Compute AIC score
aic = result.aic
# Export AIC score and model fit
return [aic, result]
def getModel(self, guess_T12, guess_fragility, guess_log_eta_inf):
'''
Creates a model for regression.
Parameters
----------
guess_T12 : float
Guess for the temperature were the viscosity is 10^12 Pa.s.
guess_fragility : float
Guess for the fragility index.
guess_log_eta_inf : array_like, optional
Guess for the base-10 logarithm of the infinite viscosity.
Notes
-----
The parameters 'T0' and 'A' are also added in the model paremeters.
Returns
-------
model : instance of lmfit's Model class.
'''
model = Model(eq.AM_alt, name=self.__str__())
model.set_param_hint('T12', vary=True, min=0, value=guess_T12)
model.set_param_hint('m', vary=True, min=0, value=guess_fragility)
model.set_param_hint('log_eta_inf',
vary=True,
max=11.99,
value=guess_log_eta_inf)
model.set_param_hint(
'alpha',
vary=False,
expr=r'm / (12 - log_eta_inf)',
)
model.set_param_hint(
'beta',
vary=False,
expr=
r'T12 * (log(10) * (12 - log_eta_inf))**((12 - log_eta_inf)/m)',
)
return model
def fit_gaussian(seq, *params, report=False):
x = np.arange(len(seq))
y = seq
amp, cen, wid = params
gmodel = Model(gaussian)
# limit the amplitude to be in 0-256
gmodel.set_param_hint('amp', min=0)
gmodel.set_param_hint('amp', max=256)
result = gmodel.fit(y, x=x, amp=amp, cen=cen, wid=wid)
if result.redchi >= 1e3:
# if report:
plt.figure()
plt.plot(x, y, 'bo')
# plt.plot(x, result.init_fit, 'k--')
plt.plot(x, np.ceil(result.best_fit), 'r-')
plt.title('chi2: {0:.2e} - red_chi2: {0:.2e}'.format(
result.chisqr, result.redchi))
plt.show()
return result
def getModel(self, guess_T12, guess_fragility, guess_log_eta_inf):
'''
Creates a model for regression.
Parameters
----------
guess_T12 : float
Guess for the temperature were the viscosity is 10^12 Pa.s.
guess_fragility : float
Guess for the fragility index.
guess_log_eta_inf : array_like, optional
Guess for the base-10 logarithm of the infinite viscosity.
Notes
-----
The parameters 'K' and 'C' from Eq. (6) from Ref. [1] are also added in
the model paremeters.
Returns
-------
model : instance of lmfit's Model class.
'''
model = Model(eq.MYEGA_alt, name=self.__str__())
model.set_param_hint('T12', vary=True, min=0, value=guess_T12)
model.set_param_hint('m', vary=True, min=0, value=guess_fragility)
model.set_param_hint('log_eta_inf',
vary=True,
max=11.99,
value=guess_log_eta_inf)
model.set_param_hint(
'K',
vary=False,
expr=r'(12-log_eta_inf)*T12*exp(1-m/(12-log_eta_inf))')
model.set_param_hint('C',
vary=False,
expr=r'T12*(m/(12-log_eta_inf)-1)')
return model
def FitSpectrumInit(self, label):
"""
Fit the spectrum with the fit params of another spectrum (given by label) as initial values. Useful when you fit big number of similar spectra.
"""
borders = np.genfromtxt(label + '/spectrumborders_' + label + '.txt',
unpack=True)
np.savetxt(self.label + '/spectrumborders_' + self.label + '.txt',
borders)
self.y = self.y[(self.x > borders[0]) & (self.x < borders[-1])]
self.x = self.x[(self.x > borders[0]) & (self.x < borders[-1])]
FitData = np.load(label + '/fitparams_' + label + '.npz')
baseline = FitData['c'] / self.maxyvalue
ctr = FitData['x0']
sigma = FitData['sigma']
gamma = FitData['gamma']
ramanmodel = ConstantModel()
ramanmodel.set_param_hint('c', value=baseline[0], min=0)
for i in range(len(sigma)):
prefix = 'p' + str(i + 1)
tempvoigt = Model(func=voigt, prefix=prefix)
tempvoigt.set_param_hint(prefix + 'x0', value=ctr[i], min=0)
tempvoigt.set_param_hint(prefix + 'sigma', value=sigma[i], min=0)
tempvoigt.set_param_hint(prefix + 'gamma', value=gamma[i], min=0)
tempvoigt.set_param_hint(prefix + 'height',
expr='wofz(((0) + 1j*' + prefix +
'gamma) / ' + prefix +
'sigma / sqrt(2)).real')
tempvoigt.set_param_hint(prefix + 'fwhm',
expr='0.5346 * 2 *' + prefix +
'gamma + sqrt(0.2166 * (2*' + prefix +
'gamma)**2 + (2 * ' + prefix +
'sigma * sqrt(2 * log(2) ) )**2 )')
ramanmodel += tempvoigt
pars = ramanmodel.make_params()
fitresult = ramanmodel.fit(self.y, pars, x=self.x, scale_covar=True)
plt.clf()
comps = fitresult.eval_components()
xplot = np.linspace(self.x[0], self.x[-1], 1000)
plt.plot(self.x, self.y * self.maxyvalue, 'r-')
plt.plot(self.x, fitresult.best_fit * self.maxyvalue)
for i in range(0, len(sigma)):
plt.plot(
self.x, comps['p' + str(i + 1)] * self.maxyvalue +
comps['constant'] * self.maxyvalue, 'k-')
plt.savefig(self.label + '/rawplot_' + self.label + '.pdf')
save_modelresult(fitresult,
self.label + '/modelresult_' + self.label + '.sav')
plt.clf()
def FitSpectrum(self):
"""
Fit Spectrum with initial values provided by SelectBaseline() and SelectPeaks()
"""
polyparams = self.Fitbaseline(self)
base = polyparams[0].n
ramanmodel = ConstantModel()
ramanmodel.set_param_hint('c', value=base, min=0)
globwidth = 1
xpeak, ypeak = np.genfromtxt(self.peakfile, unpack=True)
if type(xpeak) == np.float64:
xpeak = [xpeak]
ypeak = [ypeak]
for i in range(0, len(xpeak)):
prefix = 'p' + str(i + 1)
tempvoigt = Model(func=voigt, prefix=prefix)
tempvoigt.set_param_hint(prefix + 'x0', value=xpeak[i], min=0)
tempvoigt.set_param_hint(prefix + 'sigma', value=globwidth, min=0)
tempvoigt.set_param_hint(prefix + 'gamma', value=globwidth, min=0)
tempvoigt.set_param_hint(prefix + 'height',
value=ypeak[i],
expr='wofz(((0) + 1j*' + prefix +
'gamma) / ' + prefix +
'sigma / sqrt(2)).real')
tempvoigt.set_param_hint(prefix + 'fwhm',
expr='0.5346 * 2 *' + prefix +
'gamma + sqrt(0.2166 * (2*' + prefix +
'gamma)**2 + (2 * ' + prefix +
'sigma * sqrt(2 * log(2) ) )**2 )')
ramanmodel += tempvoigt
pars = ramanmodel.make_params()
fitresult = ramanmodel.fit(self.y, pars, x=self.x, scale_covar=True)
print(fitresult.fit_report(min_correl=0.5))
comps = fitresult.eval_components()
xplot = np.linspace(self.x[0], self.x[-1], 1000)
plt.plot(self.x, self.y * self.maxyvalue, 'rx')
plt.plot(self.x, fitresult.best_fit * self.maxyvalue)
for i in range(0, len(xpeak)):
plt.plot(
self.x, comps['p' + str(i + 1)] * self.maxyvalue +
comps['constant'] * self.maxyvalue, 'k-')
plt.show()
plt.savefig(self.label + '/rawplot_' + self.label + '.pdf')
save_modelresult(fitresult,
self.label + '/modelresult_' + self.label + '.sav')
def fit_beam_center(Ixy_data):
"""
Calculates the center of a 2D dataset with I(x, y) as
input. Fitting a 1D gaussian function to each dimension summing
over all remaining ones.
Parameters
----------
Ixy_data: np.ndarray
neutron intensity data as given by a 2D detector (CASCADE, 'neutron camera')
Return
------
('center axis0', 'center axis1', 'center axis2', ...)
Notes
-----
works also for n-dimensional data set I(x1, x2, ..., xn)
"""
def sum_axis(index, length):
templist = list(range(length))
templist.remove(index)
return templist
center_vals = []
gaussian_model = Model(gaussian_function)
gaussian_model.set_param_hint('amp', min=0)
gaussian_model.set_param_hint('x0', min=0, max=128)
gaussian_model.set_param_hint('sig', min=0)
gaussian_model.set_param_hint('bckg', min=0)
I_shape = Ixy_data.shape
for i, l in enumerate(I_shape):
fit_data = Ixy_data.sum(axis = tuple(sum_axis(i, len(I_shape))))
x0_estimate = np.argmax(fit_data)
temp_amp = np.max(fit_data)
sig_estimate = len(np.where(fit_data > temp_amp/2)[0]) / 2.35
amp_estimate = temp_amp * sqrt(2*pi) * sig_estimate
fit_res = gaussian_model.fit(
x=range(l),
data=fit_data,
amp=amp_estimate,
x0=x0_estimate,
sig=sig_estimate,
bckg=0
)
center_vals.append(fit_res.params['x0'].value)
return tuple(center_vals)
def fit_gaussian_lorentzian(ET,
I,
cen=0,
offset=10,
fwhm=.27,
gamma=.3,
Gampl=10,
Lampl=10,
fixcen=False,
fixline=False,
plot=False):
mod = Model(gaussian_lorentzian)
mod.set_param_hint('fwhm', value=fwhm, vary=False)
mod.set_param_hint('cen', value=cen, vary=not fixcen)
mod.set_param_hint('offset', value=offset, vary=not fixline)
out = mod.fit(I,
x=ET,
offset=offset,
gamma=gamma,
Gampl=Gampl,
Lampl=Lampl)
if plot:
fig = plt.figure()
out.plot_fit()
return out
def Rturn_Vmax(r_array, v_array, negative=False):
r_array, v_array = abs(r_array), abs(v_array)
r_array = np.append(r_array, 0.1)
v_array = np.append(v_array, 5)
v0 = np.nanmedian(v_array)
try:
#x0=[250,5,0,1]
#vmax ,r_turn,beta,gamma = optimization.curve_fit(vrot, r_array, v_array, p0=x0, bounds = ([0,0,0,0],[500,60,1,50]))[0]
mod = Model(vrot)
mod.set_param_hint('v_max', value=v0, vmin=0, vmax=360)
mod.set_param_hint('beta', value=0, vary=False, min=0, max=1.0)
mod.set_param_hint('R_turn', value=5, min=0, max=35)
mod.set_param_hint('gamma', value=1, min=-2, max=12)
pars = mod.make_params()
result = mod.fit(v_array, r_sky=r_array) #, fit_method = "Powell")
best = result.best_values
vmax, r_turn, gamma, beta = best["v_max"], best["R_turn"], best[
"gamma"], best["beta"]
except (RuntimeError, TypeError, ValueError):
vmax, r_turn, gamma, beta = 500, 0, 1, 1
return vmax, r_turn, beta, gamma
def lmfit(mjd,flux,fluxerr):
t0_guess = mjd[np.argmax(flux)]
tau_fall_guess = 40.
tau_rise_guess = -5.
A = 150.
B = 20.
# nflux = np.zeros(2+len(np.array(flux)))
# nfluxerr = np.ones(2+len(np.array(flux)))/10.
# nmjd = np.zeros(2+len(np.array(flux)))
#
# nflux[1:-1] = flux
# nfluxerr[1:-1] = fluxerr
# nmjd[1:-1] = mjd
# nmjd[1] = mjd[0]-100.
# nmjd[-1] = mjd[-1]+150
#
# flux = nflux
# fluxerr = nfluxerr
# mjd = nmjd
bmod = Model(bazinfunc)
bmod.set_param_hint('t0', value=t0_guess, min=t0_guess-20, max=t0_guess+20)
bmod.set_param_hint('tau_fall', value=tau_fall_guess)
bmod.set_param_hint('tau_rise', value=tau_rise_guess)
bmod.set_param_hint('A',value=A)
bmod.set_param_hint('B',value=B)
pars = bmod.make_params()
#print(bmod.param_names)
#print(bmod.independent_vars)
# print(np.array(flux))
# print(np.array(1./np.array(fluxerr)))
# print(np.array(mjd))
result = bmod.fit(np.array(flux),method='leastsq',weights=1./np.array(fluxerr), t=np.array(mjd))
#print(result.fit_report())
# plt.clf()
# plt.errorbar(np.array(mjd), np.array(flux), yerr=fluxerr,fmt='o')
# plt.plot(np.array(mjd), result.init_fit, 'k--')
# plt.plot(np.array(mjd), result.best_fit, 'r-')
# #plt.xlim(mjd[1],mjd[-2])
# plt.savefig('bazinfit.png')
chisq = result.redchi
ps = result.best_values
popt = [ps['t0'],ps['tau_fall'],ps['tau_rise'],ps['A'],ps['B']]
#print('popt',popt)
#sys.exit()
# if chisq < 2.:
# input('good chisq!')
# popt, pcov, infodict, errmsg, ier = curve_fit(bazinfunc, mjd, flux,
# sigma=fluxerr, p0=p0, maxfev=2000000, full_output=True)
#
# chisq = (infodict['fvec'] ** 2).sum() / (len(infodict['fvec']) - len(popt))
return chisq,popt
def GaussStepConst(signal, guess):
"""
Fits high contrast data very well
"""
if guess == False:
return [0, 0, 0]
else:
amp, centre, stdev, offset = guess
data = np.array([range(len(signal)), signal]).T
X = data[:,0]
Y = data[:,1]
# gauss_mod = Model(gaussian)
gauss_mod = Model(gaussian)
const_mod = ConstantModel()
step_mod = StepModel(prefix='step')
gauss_mod.set_param_hint('width', value = stdev / 2., min=stdev / 3., max=stdev)
gauss_mod.set_param_hint('fwhm', expr='2.3548*width')
pars = gauss_mod.make_params(height=amp, center=centre, width=stdev / 2., offset=offset)
pars += step_mod.guess(Y, x=X, center=centre)
pars += const_mod.guess(Y, x=X)
pars['width'].vary = False
mod = const_mod + gauss_mod + step_mod
result = mod.fit(Y, pars, x=X)
# write error report
#print result.fit_report()
fwhm = result.best_values['width'] * 2.3548
return X, result.best_fit, result.redchi, fwhm
def tau_fitter(data,nbins):
profile_peak = np.max(data)
binpeak = np.argmax(data)
modelname = GxETrain
model = Model(modelname)
model.set_param_hint('nbins', value=nbins, vary=False)
model.set_param_hint('sigma', value=15, vary=True, min =0, max = nbins)
model.set_param_hint('mu', value=binpeak, vary=True, min=0, max = nbins)
model.set_param_hint('A',value=profile_peak, vary=True)
model.set_param_hint('tau',value=200, vary=True, min=0)
model.set_param_hint('dc',value = 0, vary = True)
pars = model.make_params()
#"""Fit data"""
result = model.fit(data,pars,x=np.linspace(1,nbins,nbins))
# print(result.fit_report(show_correl = False))
noiselessmodel = result.best_fit
besttau = result.best_values['tau']
taustd = result.params['tau'].stderr ##estimated 1 sigma error
return noiselessmodel, besttau, taustd
def example():
# possible values
from get_ssa import get_ssa
from Model import IrradianceModel
zenith = 53.1836240528
AMass = 1.66450160404
rel_h = 0.665
pressure = 950
AM = 5
ssa = get_ssa(rel_h, AM)
iteration = 20
alphas = np.zeros(len(range(1, iteration)) + 1)
x = np.linspace(200, 800, 100)
irr = IrradianceModel_python(AMass, rel_h, ssa, zenith, pressure)
irr_symbol = IrradianceModel(x, zenith, AMass, pressure, ssa)
func = irr_symbol._irradiance_ratio()
y = irr.irradiance_ratio(x, 2.5, 0.06, 0.0, 1.0, 1.0)
for i in range(0, iteration):
ssa = get_ssa(rel_h, AM)
print(ssa)
irr = IrradianceModel_python(AMass, rel_h, ssa, zenith, pressure)
yerror = np.random.normal(0, 0.009, len(x))
y = irr.irradiance_ratio(x, 1.5, 0.06, 0.0, 0.6, 0.9) + yerror
weights = 1 / yerror
gmod = Model(irr.irradiance_ratio, independent_vars=["x"], param_names=["alpha", "beta", "g_dsa", "g_dsr"])
gmod.set_param_hint("alpha", value=1.0, min=-0.2, max=2.5)
gmod.set_param_hint("beta", value=0.01, min=0.0, max=2.0)
gmod.set_param_hint("g_dsa", value=0.6, min=0.0, max=1.0)
gmod.set_param_hint("g_dsr", value=0.9, min=0.0, max=1.0)
print(gmod.param_hints)
print(gmod.param_names)
print(gmod.independent_vars)
result = gmod.fit(y, x=x)
print(result.fit_report())
alphas[i] = result.params["alpha"].value
# plt.plot(x, y, label='%s' % AM)
# plt.plot(x, result.best_fit, 'r-', label='fit')
y = irr.irradiance_ratio(x, 1.5, 0.06, 0.0, 0.6, 0.9)
y2 = irr.irradiance_ratio(x, 1.5, 0.08, 0.0, 0.6, 0.9)
plt.legend()
plt.show()
"""
A two-parameter model that does not fit a dataset with two observations
"""
import numpy as np
from lmfit import Model
import matplotlib.pyplot as plt
x = np.linspace(0.1, 0.5, 2)
y = 2.1*x + 3
def line(x, m, b):
return m*x + b
gmod = Model(line)
# this makes the model impossible
gmod.set_param_hint('m', min=-10.0, max=0.)
result = gmod.fit(y, x=x, m=1, b=0)
print(result.fit_report())
plt.plot(x, y, 'bo')
plt.plot(x, result.init_fit, 'k--')
plt.plot(x, result.best_fit, 'r-')
plt.xlim([0, 0.6])
plt.show()
def minimizefunction(vars,low,high,data):
mymod=Model(myfitfunction)
newdata=[]
x=np.array(range(low,high),int)
for i in xrange(low,high):
newdata.append(data[i])
#params=getparams(vars)
mymod.set_param_hint('a',value=vars[0])
mymod.set_param_hint('b',value=vars[1],min=0,max=0.5)
mymod.set_param_hint('c',value=vars[2])
mymod.set_param_hint('d',value=vars[3],min=-1,max=1.1)
mymod.set_param_hint('e',value=vars[4])
mymod.set_param_hint('f',value=vars[5],min=-1,max=1.1)
mymod.set_param_hint('g',value=vars[6])
#print params
out=mymod.fit(newdata,x=x)
#result=getresult(out.params)
print(out.fit_report())
#x1=np.linspace(1,length,10000)
plt.plot(x,newdata,'blue',linestyle='dashed',marker='.')
plt.plot(x,out.init_fit,'y',linewidth=2)
plt.plot(x,out.best_fit,'r',linewidth=2)
plt.xlabel("circle(Time)")
plt.ylabel("fluorescence")
plt.legend()
plt.show()
file_result=open('./result/result_select_itera.txt','r+')
file_result.read()
file_result.write(out.fit_report())
file_result.write('\n\n')
file_result.close()
def generalfit(vars,Xmin,Xmax,method,data):
mymod=Model(myfitfunction)
x=np.array(range(Xmin+1,Xmax+1),int)
#params=getparams(vars)
mymod.set_param_hint('a',value=vars[0])
mymod.set_param_hint('b',value=vars[1],min=0,max=0.5)
mymod.set_param_hint('c',value=vars[2])
mymod.set_param_hint('d',value=vars[3],min=-1,max=1.1)
mymod.set_param_hint('e',value=vars[4])
mymod.set_param_hint('f',value=vars[5],min=-1,max=1.1)
mymod.set_param_hint('g',value=vars[6])
#print params
'''newdata=[]
for i in xrange(Xmin,Xmax):
newdata.append(data[i])'''
out=mymod.fit(data,x=x,method=method,jac=True)
#result=getresult(out.params)
print(out.fit_report())
#x1=np.linspace(1,length,10000)
plt.plot(x,data,'blue',linestyle='dashed',marker='.')
plt.plot(x,out.init_fit,'y',linewidth=2)
plt.plot(x,out.best_fit,'r',linewidth=2)
plt.xlabel("circle(Time)")
plt.ylabel("fluorescence")
plt.legend()
plt.show()
file_result=open('./result/result_general_itera.txt','r+')
file_result.read()
file_result.write(out.fit_report())
file_result.write('\n\n')
file_result.close()
#print(len(retVal))
return retVal
def SSE(data, fit_dv):
r = data - fit_dv
return (r*r).sum()
# loop through each file in the input
for f in pArgs.input:
df = pd.read_table(f,sep=',',skiprows=2)
vv = df.voltage.as_matrix()
ii = df.current.as_matrix()
ii = ii*-1
cellModel = Model(cellEqn,nan_policy='omit')
cellModel.set_param_hint('n',value=1)
cellModel.set_param_hint('Rs',value=6)
cellModel.set_param_hint('Rsh',value=1e5)
cellModel.set_param_hint('Iph',value=20e-3)
cellModel.set_param_hint('I0',value=1e-9)
#cellModel.set_param_hint('n',min=0)
#cellModel.set_param_hint('Rs',min=0)
#cellModel.set_param_hint('Rsh',min=0)
#cellModel.set_param_hint('Iph',min=0)
#cellModel.set_param_hint('I0',min=0)
cellModelV = Model(cellEqnV,nan_policy='omit')
cellModelV.set_param_hint('n',value=1)
cellModelV.set_param_hint('Rs',value=6)
cellModelV.set_param_hint('Rsh',value=1e5)
def fitfunction(vars,length,data,weight=None,method='leastsq'):
mymod=Model(myfitfunction)
x=np.array(range(1,length+1),int)
#params=getparams(vars)
mymod.set_param_hint('a',value=vars[0])
mymod.set_param_hint('b',value=vars[1],min=0,max=0.5)
mymod.set_param_hint('c',value=vars[2])
mymod.set_param_hint('d',value=vars[3],min=-1,max=1.1)
mymod.set_param_hint('e',value=vars[4])
mymod.set_param_hint('f',value=vars[5],min=-1,max=1.1)
mymod.set_param_hint('g',value=vars[6])
#print params
out=mymod.fit(data,x=x,weight=weight)
#result=getresult(out.params)
print(out.fit_report())
#x1=np.linspace(1,length,10000)
initialRMSE=printresult(data,out.init_fit)
bestRMSE=printresult(data,out.best_fit)
plt.plot(x,data,'blue',linestyle='dashed',marker='.')
plt.plot(x,out.init_fit,'y',linewidth=2)
print("RMSE of pso is{}".format(initialRMSE))
if initialRMSE<bestRMSE:
plt.plot(x,out.init_fit,'r',linewidth=2)
print("RMSE of iteration is {}".format(initialRMSE))
else:
plt.plot(x,out.best_fit,'r',linewidth=2)
print("RMSE of iteration is {}".format(bestRMSE))
plt.xlabel("circle(Time)")
plt.ylabel("fluorescence")
plt.legend()
plt.show()
file_result=open('./result/result_all_itera.txt','r+')
file_result.read()
file_result.write(out.fit_report())
file_result.write('\n\n')
file_result.close()
def tau_fitter(data,nbins, verbose=True):
profile_peak = np.max(data)
binpeak = np.argmax(data)
modelname = GxETrain
model = Model(modelname)
model.set_param_hint('nbins', value=nbins, vary=False)
model.set_param_hint('sigma', value=15, vary=True, min =0, max = nbins)
model.set_param_hint('mu', value=binpeak, vary=True, min=0, max = nbins)
model.set_param_hint('A',value=profile_peak, vary=True, min=0)
model.set_param_hint('tau',value=200, vary=True, min=0)
model.set_param_hint('dc',value = 0, vary = True)
pars = model.make_params()
xax=np.linspace(1,nbins,nbins)
#"""Fit data"""
result = model.fit(data,pars,x=xax)
if verbose == True:
print(result.fit_report(show_correl = True))
else:
print "To see fit report, use verbose=True"
noiselessmodel = result.best_fit
besttau = result.best_values['tau']
taustd = result.params['tau'].stderr ##estimated 1 sigma error
if taustd == None:
taustd = 0
bestsig = result.best_values['sigma']
bestmu = result.best_values['mu']
bestA = result.best_values['A']
bestdc = result.best_values['dc']
bestsig_std = result.params['sigma'].stderr
bestmu_std = result.params['mu'].stderr
bestA_std = result.params['A'].stderr
bestdc_std = result.params['dc'].stderr
bestparams = np.array([bestsig,bestmu,bestA,bestdc])
bestparams_std = np.array([bestsig_std,bestmu_std,bestA_std,bestdc_std])
"""correlations with sigma"""
corsig = result.params['sigma'].correl
#corA = result.params['A'].correl
#corlist = [corsig,corA]
rchi = result.redchi
#return best values and std errors on the other parameters as well
return result, noiselessmodel, besttau, taustd, bestparams, bestparams_std, rchi, corsig
##
###Create limits on s, via w50
###The distribution of pulsar duty cylces is heavily skewed with a median at 2.5% and an overall minimum at 0.3% and overall maximum at 63% (Ref:Jayanth)
###This max is clearly huge - and therefore the process is pretty much unconstrained. Should consider inserting the actual distribution
w50min = float((0.3/100)*P)
w50max = float((3.0/100)*P)
smin = w50min/(2*np.sqrt(2*np.log(2)))
smax = w50max/(2*np.sqrt(2*np.log(2)))
modelname = GxETrain
model = Model(modelname)
model.set_param_hint('sigma', value=s, vary=True, min=smin, max=smax)
model.set_param_hint('mu', value=m, vary=True)
model.set_param_hint('A',value=1.5, vary=True, min=0)
model.set_param_hint('tau',value=200, vary=True, min=0)
pars = model.make_params()
#print model.param_hints
#modelname2 = GxESingleFold
#model2 = Model(modelname2)
#
#model2.set_param_hint('sigma', value=s, vary=True, min=smin, max=smax)
#model2.set_param_hint('mu', value=m, vary=True)
#model2.set_param_hint('A',value=1.5, vary=True, min=0)
#model2.set_param_hint('tau',value=200, vary=True, min=0)
#pars2 = model2.make_params()
##print model2.param_hints
def tau_1D_fitter(data,nbins):
profile_peak = np.max(data)
binpeak = np.argmax(data)
modelname = GxETrain1D
model = Model(modelname)
model.set_param_hint('nbins', value=nbins, vary=False)
model.set_param_hint('sigma', value=15, vary=True, min =0, max = nbins)
model.set_param_hint('mu', value=binpeak, vary=True, min=0, max = nbins)
model.set_param_hint('A',value=profile_peak, vary=True,min=0)
model.set_param_hint('tau1',value=200, vary=True, min=0)
# model.set_param_hint('tau1',value=166.792877, vary=False)
model.set_param_hint('dc',value = 0, vary = True)
pars = model.make_params()
result = model.fit(data,pars,x=np.linspace(1,nbins,nbins))
# print(result.fit_report(show_correl = False))
noiselessmodel = result.best_fit
besttau = result.best_values['tau1']
taustd = result.params['tau1'].stderr ##estimated 1 sigma error
if taustd == None:
taustd = 0
bestsig = result.best_values['sigma']
bestmu = result.best_values['mu']
bestA = result.best_values['A']
bestdc = result.best_values['dc']
bestsig_std = result.params['sigma'].stderr
bestmu_std = result.params['mu'].stderr
bestA_std = result.params['A'].stderr
bestdc_std = result.params['dc'].stderr
bestparams = np.array([bestsig,bestmu,bestA,bestdc])
bestparams_std = np.array([bestsig_std,bestmu_std,bestA_std,bestdc_std])
"""correlations with sigma"""
corsig = result.params['sigma'].correl
#corA = result.params['A'].correl
#corlist = [corsig,corA]
rchi = result.redchi
return result, noiselessmodel, besttau, taustd, bestparams, bestparams_std, rchi, corsig
def gauss_fit(x, y, a0=None, x0=None, sig0=None, emission=True):
""" Return ``curve_fit``, i.e., ``popt, pcov``.
def gauss_fit(x, y, a0=None, x0=None, sig0=None, emission=True, ssize=0.05):
# def gauss(x, a, x0, sigma):
# y0=1.
# return a*_np.exp(-(x-x0)**2/(2*sigma**2))+y0
if ssize < 0 or ssize > .5:
_warn.warn('Invalid ssize value...', stacklevel=2)
ssize = 0
ssize = int(ssize * len(y))
if ssize == 0:
ssize = 1
q = 95
func = _np.max
if not emission:
func = _np.min
q = 5
if a0 is None:
a0 = _np.abs(_np.percentile(y, q)) - _np.median(y)
if x0 is None:
x0 = x[_np.where(y == func(y))]
if sig0 is None:
sig0 = (_np.max(x)-_np.min(x))/10.
# if y0 is None:
# y0 = np.median(y)
# gmodel = _Model(gauss)
# gmodel.set_param_hint('a', min=0.2, max=20)
# if not emission:
# gmodel.set_param_hint('a', min=-0.2, max=-4)
# gmodel.set_param_hint('sigma', min=50, max=1000)
# result = gmodel.fit(y, x=x, a=a0, x0=x0, sigma=sig0)
# print(result.params['a'], result.params['sigma'], result.params['x0'])
# return result.params['a']*_np.sqrt(_np.pi*2)*result.params['sigma']
medx0, medx1 = _np.average(x[:ssize]), _np.average(x[-ssize:])
if ssize > 9:
medy0, medy1 = _np.median(y[:ssize]), _np.median(y[-ssize:])
else:
medy0, medy1 = _np.average(y[:ssize]), _np.average(y[-ssize:])
new_y = medy0 + (medy1 - medy0) * (x - medx0) / (medx1 - medx0)
g_init = _models.Gaussian1D(amplitude=a0, mean=x0, stddev=sig0)
fit_g = _fitting.LevMarLSQFitter()
g = fit_g(g_init, x, y-new_y)
"""
q = 95
func = np.max
if not emission:
func = np.min
q = 5
if a0 is None:
a0 = np.abs(np.percentile(y, q)) - np.median(y)
if x0 is None:
x0 = x[np.where(y == func(y))]
if sig0 is None:
sig0 = (np.max(x)-np.min(x))/10.
# if y0 is None:
# y0 = np.median(y)
gmodel = Model(gauss)
gmodel.set_param_hint('a', min=0.2, max=4)
if not emission:
gmodel.set_param_hint('a', min=-0.2, max=-4)
gmodel.set_param_hint('sigma', min=50, max=1000)
result = gmodel.fit(y, x=x, a=a0, x0=x0, sigma=sig0)
fig, (ax0, ax1) = plt.subplots(2, 1)
ax0.plot(x, y, 'bo')
ax0.plot(x, result.init_fit, 'k--')
ax0.plot(x, result.best_fit, 'r-')
ax0.set_title(fitsfile)
print(lbc, np.min(x))
idx = np.where((wl > lbc*0.98) & (wl < lbc*1.03))
ax1.plot(wl[idx], flux[idx], 'o')
plt.show(block=False)
cmd = phc.user_input('# Problem (y/other)? ')
if cmd.lower().startswith('y'):
raise ValueError
# phc.savefig(fig, figname=fitsfile)
return result.params['x0']
# Find Rupture Force
ruptureI = np.argmin(retractD)
ruptureF = k_L*(retractD[ruptureI] - y_shift)/contactS
ruptureL = (retractZ[ruptureI] - (retractD[ruptureI] - y_shift) - x_shift)
for x in range(len(retractZ)):
if (retractZ[x] - x_shift) < 0:
originPt = x
break
# Fit WLC model to rupture
separation = (retractZ - (retractD - y_shift) - x_shift)
skipPLT5 = True
gmod = Model(WLCmodel)
gmod.set_param_hint('L_C', value = -60.0)
gmod.set_param_hint('L_P', value = -0.38, min=-0.42, max=-0.34)
gmod.set_param_hint('a', value = 0.0, min=-10.0, max=10.0)
gmod.set_param_hint('b', value = 0.0, min=-10.0, max=10.0)
params = gmod.make_params()
try:
result = gmod.fit(smooth25[originPt:ruptureI], x=separation[originPt:ruptureI]) # method='cobyla'
except Exception:
skipPLT5 = False
sys.exc_clear()
if skipPLT5:
x_off = result.params['a'].value
y_off = result.params['b'].value
WLC_P = result.params['L_P'].value
WLC_L0 = result.params['L_C'].value
else:
def _fit_aengstrom(self, Aods, lambdas):
gmod = Model(self._aengstrom_formula, independent_vars=['x'], param_names=['beta'])
gmod.set_param_hint('beta', value=0.1)
result = gmod.fit(Aods, x=lambdas, verbose=False)
return result
start_bimod_params = {'bimod_centerx': {'value':92,'min':40, 'max':200},
'bimod_centery':{'value':71,'min':40, 'max':200},
'bimod_peakg':{'value':.02,'min' : .009,'max':.05},
'bimod_peaktf':{'value':.15,'min' : 0,'max':.5},
'bimod_Rx':{'value':13 ,'min' : 9,'max':14},
'bimod_Ry':{'value':13,'min' : 9,'max':14},
'bimod_sigx':{'value':17,'min' :14,'max':24},
'bimod_sigy':{'value':17,'min' : 14,'max':24},
'bimod_off':{'value':0 ,'min' : -1,'max': 1},
'bimod_theta':{'value':48.5, 'min' : 48, 'max': 50}
}
#set parameter hings in model
for key, value in start_bimod_params.items():
bimod_2d_mod.set_param_hint(key, **value)
##################
#Fitting
##################
def fit_image(args, data_in, filename, filepath):
"""
function to fit image. For a sequential fit, proceed as follows
1. Do full bimodal fit to determine approximate TF radius
2. Mask TF and fit to flat Gaussian
3. Fix flat Gaussian and re-fit TF
:param args: arguments passed from command line
:param data_in: image data
:param filename: filename of thing being fit
:param filepath: path to results folder
