def mult_params_peaks_Lorentzian(x, y):
#http://cars9.uchicago.edu/software/python/lmfit/builtin_models.html
loren_mod1 = LorentzianModel(prefix='l1_')
pars = loren_mod1.guess(y, x)
loren_mod2 = LorentzianModel(prefix='l2_')
pars.update(loren_mod2.make_params())
loren_mod3 = LorentzianModel(prefix='l3_')
pars.update(loren_mod3.make_params())
mod = loren_mod1 + loren_mod2 + loren_mod3
init = mod.eval(pars, x=x)
out = mod.fit(y, pars, x=x)
print(out.fit_report(min_correl=0.5))
plot_components = False
plt.plot(x, y, 'b')
plt.plot(x, init, 'k--')
plt.plot(x, out.best_fit, 'r-')
if plot_components:
comps = out.eval_components(x=x)
plt.plot(x, comps['l1_'], 'b--')
plt.plot(x, comps['l2_'], 'b--')
plt.plot(x, comps['l3_'], 'b--')
def test_imagefile_ops(self):
self.a2.gridimage()
self.a3.gridimage()
self.a2.crop(5,-15,5,-5,_=True)
self.a3.crop(5,-15,5,-5,_=True)
self.b=self.a2//self.a3
self.assertEqual(self.b.shape,(90,80),"Failure to crop image correctly.")
self.assertGreater(self.b.max(),0.047,"XMCD Ratio calculation failed")
self.assertLess(self.b.min(),-0.05,"XMCD Ratio calculation failed")
self.b.normalise()
self.assertEqual(self.b.max(),1.0,"Normalise Image failed")
self.assertEqual(self.b.min(),-1.0,"Normalise Image failed")
self.profile=self.b.profile_line((0,0),(100,100))
self.profile.plot()
self.b.mask=self.a2.image>25E3
self.hist=self.b.hist(bins=200)
self.hist.column_headers=["XMCD Signal","Frequency"]
self.hist.labels=None
g1=LorentzianModel(prefix="g1_")
g2=LorentzianModel(prefix="g2_")
params=g1.make_params()
params.update(g2.make_params())
double_peak=g1+g2
g1=np.argmax(self.hist.y[:100]) # Location of first peak
g2=np.argmax(self.hist.y[100:])+100
for k, p in zip(params,[0.25,self.hist.x[g1],self.hist.y[g1]/np.sqrt(2),0.5,self.hist.y[g1],
0.25,self.hist.x[g2],self.hist.y[g2]/np.sqrt(2),0.5,self.hist.y[g2]]):
params[k].value=p
print(g1,g2,params)
self.res=self.hist.lmfit(double_peak,p0=params,output="report")
self.hist.add_column(self.res.init_fit,header="Initial Fit")
self.hist.add_column(self.res.best_fit,header="Best Fit")
self.hist.setas="xyyy"
self.hist.plot(fmt=["b+","b--","r-"])
plt.close("all")
def test_imagefile_ops(self):
self.a2.gridimage()
self.a3.gridimage()
self.a2.crop(5,-15,5,-5,_=True)
self.a3.crop(5,-15,5,-5,_=True)
self.b=self.a2//self.a3
self.assertEqual(self.b.shape,(90,80),"Failure to crop image correctly.")
self.assertGreater(self.b.max(),0.047,"XMCD Ratio calculation failed")
self.assertLess(self.b.min(),-0.05,"XMCD Ratio calculation failed")
self.b.normalise()
self.assertEqual(self.b.max(),1.0,"Normalise Image failed")
self.assertEqual(self.b.min(),-1.0,"Normalise Image failed")
self.profile=self.b.profile_line((0,0),(100,100))
self.profile.plot()
self.b.mask=self.a2.image>25E3
self.hist=self.b.hist(bins=200)
self.hist.column_headers=["XMCD Signal","Frequency"]
self.hist.labels=None
g1=LorentzianModel(prefix="g1_")
g2=LorentzianModel(prefix="g2_")
params=g1.make_params()
params.update(g2.make_params())
double_peak=g1+g2
g1=np.argmax(self.hist.y[:100]) # Location of first peak
g2=np.argmax(self.hist.y[100:])+100
for k, p in zip(params,[0.25,self.hist.x[g1],self.hist.y[g1]/np.sqrt(2),0.5,self.hist.y[g1],
0.25,self.hist.x[g2],self.hist.y[g2]/np.sqrt(2),0.5,self.hist.y[g2]]):
params[k].value=p
print(g1,g2,params)
self.res=self.hist.lmfit(double_peak,p0=params,output="report")
self.hist.add_column(self.res.init_fit,header="Initial Fit")
self.hist.add_column(self.res.best_fit,header="Best Fit")
self.hist.setas="xyyy"
self.hist.plot(fmt=["b+","b--","r-"])
plt.close("all")
def fitLorentzian(x,y):
signalGuess = max(y)-min(y)
# centerGuess = x[np.argmax(y)]
centerGuess = (max(x)+min(x))/2.
span = max(x)-min(x)
sigmaGuess = span/10.
x_bg = np.concatenate((x[:10],x[10:]))
y_bg = np.concatenate((y[:10],y[10:]))
background = LinearModel()
pars = background.guess(y_bg, x=x_bg)
peak = LorentzianModel()
pars.update( peak.make_params())
pars['center'].set(centerGuess)#,min=min(x),max=max(x))
pars['sigma'].set(sigmaGuess,max=span/2.)
pars['amplitude'].set(signalGuess*sigmaGuess*np.pi,min=0.00000001)
pars.add('signal', expr='amplitude/(sigma*pi)')
pars.add('background', expr='intercept+slope*center')
pars.add('contrast', expr='amplitude/(sigma*pi*background)')
pars.add('centerDoubled', expr='2*center')
pars.add('shift', expr='2*center-9192631770')
pars.add('fwhmDoubled', expr='4*sigma')
model = peak + background
init = model.eval(pars, x=x)
out = model.fit(y, pars, x=x)
#print out.fit_report()
return init,out
def add_peak(prefix, center, amplitude=0.005, sigma=0.05):
peak = LorentzianModel(prefix=prefix)
pars = peak.make_params()
pars[prefix + 'center'].set(center)
pars[prefix + 'amplitude'].set(amplitude)
pars[prefix + 'sigma'].set(sigma, min=0)
return peak, pars
def add_lz_peak(prefix: str,
center: float,
amplitude: float = 0.005,
sigma: float = 0.05) -> Tuple[LorentzianModel, Parameters]:
peak = LorentzianModel(prefix=prefix)
pars = peak.make_params()
pars[prefix + "center"].set(center)
pars[prefix + "amplitude"].set(amplitude, min=0)
pars[prefix + "sigma"].set(sigma, min=0)
return peak, pars
def fitsample(data, theta_initial, theta_final):
x = data[:,0]
y = data[:,1]
m = (x > theta_initial) & (x < theta_final)
x_fit = x[m]
y_fit = y[m]
pseudovoigt1 = VoigtModel(prefix = 'pv1_')
pars= pseudovoigt1.make_params()
pars['pv1_center'].set(13.5, min = 13.4, max = 13.6)
pars['pv1_sigma'].set(0.05, min= 0.01, max = 0.1)
pars['pv1_amplitude'].set(70, min = 1, max = 100)
#pars['pv1_fraction'].set(0.5)
lorentz2 = LorentzianModel(prefix = 'lor2_')
pars.update(lorentz2.make_params())
pars['lor2_center'].set(13.60, min = 13.4, max = 13.9)
pars['lor2_sigma'].set(0.1, min= 0.01)
pars['lor2_amplitude'].set(10, min = 1, max = 50 )
#pars['lor2_fraction'].set(0.5)
line1 = LinearModel(prefix ='l1_')
pars.update(line1.make_params())
pars['l1_slope'].set(0)
pars['l1_intercept'].set(240, min = 200, max = 280)
mod = pseudovoigt1 + lorentz2 + line1
v = pars.valuesdict()
result = mod.fit(y_fit, pars, x=x_fit)
#print(result.fit_report())
pv1_pos = result.params['pv1_center'].value
pv1_height = result.params['pv1_height'].value
lor2_pos = result.params['lor2_center'].value
lor2_height = result.params['lor2_height'].value
#peak_area = pars['gau1_fwhm'].value*peak_amp
#plt.xlim([theta_initial, theta_final])
#plt.ylim([100, 500])
#plt.semilogy(x_fit, y_fit, 'bo')
#plt.semilogy (x_fit, result.init_fit, 'k--')
#plt.semilogy(x_fit, result.best_fit, 'r-')
#plt.show()
return pv1_pos, pv1_height, lor2_pos, lor2_height
def fitDoubleLorentzian(x,y) :
signalGuess = 0.5*(max(y)-min(y))
centerGuess = (max(x)+min(x))/2.
span = max(x)-min(x)
sigmaGuess = span/10.
x_bg = np.concatenate((x[:10],x[10:]))
y_bg = np.concatenate((y[:10],y[10:]))
background = LinearModel()
pars = background.guess(y_bg, x=x_bg)
peak1 = LorentzianModel(prefix="p1_")
pars.update(peak1.make_params())
pars['p1_center'].set(centerGuess,min=min(x),max=max(x))
pars['p1_sigma'].set(sigmaGuess,max=span/2.)
pars['p1_amplitude'].set(signalGuess*sigmaGuess*np.pi,min=0.00000001)
pars.add('p1_signal', expr='p1_amplitude/(p1_sigma*pi)')
pars.add('background', expr='intercept+slope*p1_center')
pars.add('p1_contrast', expr='p1_amplitude/(p1_sigma*pi*background)')
pars.add('p1_centerDoubled', expr='2*p1_center')
pars.add('p1_shift', expr='2*p1_center-9192631770')
pars.add('p1_fwhmDoubled', expr='4*p1_sigma')
peak2 = LorentzianModel(prefix="p2_")
pars.update(peak2.make_params())
pars['p2_center'].set(centerGuess,min=min(x),max=max(x))
pars.add('broadScale',value=2.0, min=1.9, max=100.0)
pars['p2_sigma'].set(sigmaGuess*2,max=span/2.,expr='p1_sigma*broadScale')
pars['p2_amplitude'].set(signalGuess*sigmaGuess*np.pi,min=0.00000001)
pars.add('p2_signal', expr='p2_amplitude/(p2_sigma*pi)')
pars.add('p2_contrast', expr='p2_amplitude/(p2_sigma*pi*background)')
pars.add('p2_centerDoubled', expr='2*p2_center')
pars.add('p2_shift', expr='2*p2_center-9192631770')
pars.add('p2_fwhmDoubled', expr='4*p2_sigma')
model = peak1 + peak2 + background
init = model.eval(pars, x=x)
out = model.fit(y, pars, x=x)
print out.fit_report()
return init,out
def fitTwoLorentzians(x,y):
background = PolynomialModel(2)
pars = background.make_params()
peak1 = LorentzianModel(prefix='p1_')
pars.update( peak1.make_params())
peak2 = LorentzianModel(prefix='p2_')
pars.update( peak2.make_params())
# Guess some parameters from data to help the fitting
span = max(x)-min(x)
c1Guess = (y[-1]-y[0])/(x[-1]-x[0])
c0Guess = y[0]-c1Guess*x[0]
bgGuess = background.func(x=x,c0=c0Guess,c1=c1Guess,c2=0)
signalGuess=min(y-bgGuess)
sigmaGuess = span/50.
amplitudeGuess = signalGuess*(sigmaGuess*np.pi)
# Fit variables initialization
pars.add('splitting',value=min(x)+span*0.56,min=0.0000001,max=max(x)-min(x))
pars['c2'].set(0.)
pars['c1'].set(c1Guess)
pars['c0'].set(c0Guess)
pars['p1_center'].set(min(x)+span*0.45,min=min(x),max=max(x))
pars['p2_center'].set(min(x)+span*0.55,expr='p1_center+splitting')
# pars['p2_center'].set(min(x)+span*0.55,min=min(x),max=max(x))
pars['p1_amplitude'].set(amplitudeGuess,max=amplitudeGuess/100.)
pars['p2_amplitude'].set(amplitudeGuess,max=amplitudeGuess/100.)
pars['p1_sigma'].set(sigmaGuess, min=sigmaGuess/1000.,max=sigmaGuess*1000.)
pars['p2_sigma'].set(sigmaGuess, min=sigmaGuess/1000.,max=sigmaGuess*1000.)
#Add some useful parameters to evaluate
pars.add('p1_signal', expr='p1_amplitude/(p1_sigma*pi)')
pars.add('p2_signal', expr='p2_amplitude/(p2_sigma**pi)')
pars.add('p1_contrast', expr='-p1_amplitude/(p1_sigma*pi*(c0+c1*p1_center+c2*p1_center**2))')
pars.add('p2_contrast', expr='-p2_amplitude/(p2_sigma*pi*(c0+c1*p2_center+c2*p2_center**2))')
model = peak1 + peak2 + background
init = model.eval(pars, x=x)
out = model.fit(y, pars, x=x)
print out.fit_report()
return init,out
def test_PeakLogicFiles_add_lz_peak(mocker):
TEST_PREFIX = "test"
TEST_CENTER = -0.4
EXPECTED_PEAK = LorentzianModel(prefix="test")
EXPECTED_PARAMS = EXPECTED_PEAK.make_params(
center=-0.4, amplitude=0.005, sigma=0.05
)
mocker.patch("SWV_AnyPeakFinder.SWV_AnyPeakFinder.PeakFinderApp")
app = swv.PeakFinderApp()
logic = swv.PeakLogicFiles(app)
_, actual_params = logic.add_lz_peak(TEST_PREFIX, TEST_CENTER)
# assert EXPECTED_PEAK == actual_peak # FIXME
assert EXPECTED_PARAMS == actual_params
def make_lorentzian_model(self):
""" This method creates a model of lorentzian with an offset. The
parameters are: 'amplitude', 'center', 'sigma, 'fwhm' and offset
'c'. For function see:
http://cars9.uchicago.edu/software/python/lmfit/builtin_models.html#models.LorentzianModel
@return lmfit.model.CompositeModel model: Returns an object of the
class CompositeModel
@return object params: lmfit.parameter.Parameters object, returns an
object of the class Parameters with all
parameters for the lorentzian model.
"""
model = LorentzianModel() + ConstantModel()
params = model.make_params()
return model, params
def onclick(event):
global X
plt.clf()
x = event.xdata
y = event.ydata
print('waint...')
L1 = LorentzianModel(prefix='L1_')
pars = L1.guess(psd, x=freq)
pars.update(L1.make_params())
pars['L1_center'].set(x, min=x - 10, max=x + 10)
#pars['L1_sigma'].set(y, min=0)
pars['L1_amplitude'].set(y, min=0)
out = L1.fit(psd, pars, x=freq)
X = out.best_fit
plt.title(str(ordem) + " Lorenzian fit")
plt.ylabel('PSD[ppm$^2$/$\mu$Hz]')
plt.xlabel('Frequency [$\mu$Hz]')
plt.minorticks_on()
plt.tick_params(direction='in',
which='major',
top=True,
right=True,
left=True,
length=8,
width=1,
labelsize=15)
plt.tick_params(direction='in',
which='minor',
top=True,
right=True,
length=5,
width=1,
labelsize=15)
plt.tight_layout()
plt.loglog(freq, psd, 'k', lw=0.5, alpha=0.5)
plt.plot(freq, out.best_fit, 'k-', lw=0.5, alpha=0.5)
plt.xlim(min(freq), max(freq))
plt.ylim(min(psd), max(psd))
plt.draw()
print('Done')
def fit_lz_peaks(potentials, currents):
min_y = float(min(currents))
model = QuadraticModel(prefix="Background")
params = model.make_params() # a=0, b=0, c=0
params.add("a", 0, min=0)
params.add("b", 0)
params.add("c", 0, min=min_y)
peak = LorentzianModel(prefix="peak")
pars = peak.make_params()
pars.add("center", -0.3)
pars.add("amplitude", 0.005, min=0)
pars.add("sigma", 0.05, min=0)
model = model + peak
params.update(pars)
# _ = model.eval(params, x=potentials) # not needed
result = model.fit(currents, params, x=potentials)
comps = result.eval_components()
return result.best_fit, float(max(comps["peak"]))
def test_convolution():
r"""Convolution of function with delta dirac should return the function"""
# Reference Lorentzian parameter values
amplitude = 42.0
sigma = 0.042
center = 0.0003
c1 = LorentzianModel(prefix='c1_')
p = c1.make_params(amplitude=amplitude, center=center, sigma=sigma)
c2 = DeltaDiracModel(prefix='c2_')
p.update(c2.make_params(amplitude=1.0, center=0.0))
e = 0.0004 * np.arange(-250, 1500) # energies in meV
# convolve Lorentzian with delta Dirac
y1 = Convolve(c1, c2).eval(params=p, x=e) # should be the lorentzian
# reverse order, convolve delta Dirac with Lorentzian
y2 = Convolve(c2, c1).eval(params=p, x=e) # should be the lorentzian
# We will fit a Lorentzian model against datasets y1 and y2
m = LorentzianModel()
all_params = 'amplitude sigma center'.split()
for y in (y1, y2):
params = m.guess(y, x=e)
# Set initial model Lorentzian parameters far from optimal solution
params['amplitude'].set(value=amplitude * 10)
params['sigma'].set(value=sigma * 4)
params['center'].set(value=center * 7)
# fit Lorentzian model against dataset y
r = m.fit(y, params, x=e)
# Compare the reference Lorentzian parameters against
# parameters of the fitted model
assert_allclose([amplitude, sigma, center],
[r.params[p].value for p in all_params],
rtol=0.01,
atol=0.00001)
def fit_lorentzian(y: np.ndarray, x: np.ndarray) -> np.ndarray:
"""Fits profile to lorentzian. Used with np.apply_along_axis.
Parameters
----------
y
y values of profile to be fitted.
Units: none.
x
x values of profiles to be fitted
Units: Hz.
Returns
-------
result_params
A numpy array of the returning parameters
['Center', 'HWHM', 'max height', 'chi sq'].
Units: [same as x, same as x, None, None].
"""
model = LorentzianModel()
center_guess = x[y.argmax()]
HWHM_guess = x[y.argmax()] / 1000
params = model.make_params(amplitude=y.max() * np.pi * HWHM_guess,
center=center_guess,
sigma=HWHM_guess)
result = model.fit(y, params, x=x)
result_params = np.array([
result.params["center"].value,
result.params["sigma"].value,
result.params["height"].value,
result.chisqr,
])
return result_params
def calculateQ_2peaks(filename, time, taper, lambda0, slope,
modulation_coefficient, rg):
q = readlvm(filename)
q = q.ravel()
q = q / taper - 1
valley = q.min()
valley_index = np.argmin(q)
max_height = -1 * q[valley_index]
q_valley = q[valley_index - rg:valley_index + rg]
l_valley = time[valley_index - rg:valley_index + rg]
q_valley = q_valley * -1
peaks, peak_info = find_peaks(q_valley,
height=max_height * 0.6,
prominence=0.05,
distance=50)
#results_half = peak_widths(q_valley, peaks, rel_height=0.5)
if len(peaks) != 2:
print("Wrong peaks with num:", len(peaks))
return None, None, None, None, None, None
x = np.asarray(list(range(0, 2 * rg)))
y = q_valley
# One peak guess to get width
g_mod = LorentzianModel()
g_pars = g_mod.guess(y, x=x)
g_out = g_mod.fit(y, g_pars, x=x)
g_res = g_out.fit_report()
g_info = g_res.split("\n")
g_variables = parse_info(g_info, 1)
guessedWidth = float(g_variables['fwhm']) / 2
exp_mod = ExponentialModel(prefix='exp_')
pars = exp_mod.guess(y, x=x)
lorenz1 = LorentzianModel(prefix='l1_')
pars.update(lorenz1.make_params())
pars['l1_center'].set(peaks[0])
pars['l1_sigma'].set(guessedWidth)
pars['l1_amplitude'].set(np.pi * guessedWidth * q_valley[peaks[0]])
lorenz2 = LorentzianModel(prefix='l2_')
pars.update(lorenz2.make_params())
pars['l2_center'].set(peaks[1])
pars['l2_sigma'].set(guessedWidth)
pars['l2_amplitude'].set(np.pi * guessedWidth * q_valley[peaks[1]])
mod = lorenz1 + lorenz2 + exp_mod
init = mod.eval(pars, x=x)
out = mod.fit(y, pars, x=x)
res = out.fit_report()
info = res.split("\n")
variables = parse_info(info, 2)
l1_h_res, l1_w_res, l1_c_res = variables['l1_height'], variables[
'l1_fwhm'], variables['l1_center']
print(l1_h_res, l1_w_res, l1_c_res)
l1 = lambda0 + l_valley[int(
float(l1_c_res))] * slope * modulation_coefficient
d_lambda1 = (l_valley[1] - l_valley[0]
) * float(l1_w_res) * slope * modulation_coefficient
Q1 = l1 / d_lambda1
l2_h_res, l2_w_res, l2_c_res = variables['l2_height'], variables[
'l2_fwhm'], variables['l2_center']
print(l2_h_res, l2_w_res, l2_c_res)
l2 = lambda0 + l_valley[int(
float(l2_c_res))] * slope * modulation_coefficient
d_lambda2 = (l_valley[1] - l_valley[0]
) * float(l2_w_res) * slope * modulation_coefficient
Q2 = l2 / d_lambda2
return Q1, float(l1_h_res) * 100, l1, Q2, float(l2_h_res) * 100, l2
profile.subplot(221)
strctural.imshow(figure=profile.fig, title="Structural Image")
profile.subplot(223)
xmcd.imshow(figure=profile.fig, title="XMCD Image")
# Make a histogram of the intesity values
hist = xmcd.hist(bins=200)
hist.column_headers = ["XMCD Signal", "Frequency"]
hist.labels = None
hist.fig = profile.fig
# Construct a two Lorentzian peak model
peak1 = LorentzianModel(prefix="peak1_")
peak2 = LorentzianModel(prefix="peak2_")
params = peak1.make_params()
params.update(peak2.make_params())
double_peak = peak1 + peak2
def guess(self, data, **kwargs):
"""Function to guess the parameters of two Lorentzian peaks."""
x = kwargs.get("x")
l = len(data)
i1 = np.argmax(data[:l // 2]) # Location of first peak
i2 = np.argmax(data[l // 2:]) + l // 2
params = self.make_params()
for k, p in zip(
params,
[
for filename in files:
x, y = np.loadtxt(direc + filename, unpack=True)
x = 1239.8 / x
if counter == 5:
filtro_total = filtro_3 * filtro_2 * filtro_1 #*filtro_feno
y = (y - a) * filtro_total
#Imprimo para llevar un control por la terminal
print(filename)
#Semillas que se dan iterativamente
pars = L0_mod.make_params(center=center[0],
amplitude=amplitude[0],
sigma=sigma[0])
pars += L1_mod.make_params(center=center[1],
amplitude=amplitude[1],
sigma=sigma[1])
pars += L2_mod.make_params(center=center[2],
amplitude=amplitude[2],
sigma=sigma[2])
#pars+=L3_mod.make_params(center=center[3], amplitude= amplitude[3], sigma=sigma[3])
#pars+=L4_mod.make_params(center=center[4], amplitude= amplitude[4], sigma=sigma[4])
#pars+=L5_mod.make_params(center=center[5], amplitude= amplitude[5], sigma=sigma[5])
pars += c_mod.make_params(intercept=c, slope=slope)
#pars+=c_mod.make_params(c=c)
#Defino funcion
def fitModel(x, y, t1, t2, t3, t4, t5, t6, n, c1, c2, c3, c4, c5, c6, chck1,
chck2, chck3):
fitType1 = t1
fitType2 = t2
fitType3 = t3
fitType4 = t4
fitType5 = t5
fitType6 = t6
numPk = n
cen = (c1, c2, c3, c4, c5, c6)
fitstats = chck1
eqWidth = chck2
eqBeta = chck3
Lin1 = LinearModel(prefix='BackG_')
pars = Lin1.make_params()
pars['BackG_slope'].set(0) #, min=-0.001, max=0.001)
pars['BackG_intercept'].set(2e7, min=0)
if fitType1 == 'Lorentzian':
pk1 = LorentzianModel(prefix='Peak1_')
elif fitType1 == 'Gaussian':
pk1 = GaussianModel(prefix='Peak1_')
elif fitType1 == 'PseudoVoigt':
pk1 = PseudoVoigtModel(prefix='Peak1_')
elif fitType1 == 'GND':
pk1 = gndModel(prefix='Peak1_')
if fitType2 == 'Lorentzian':
pk2 = LorentzianModel(prefix='Peak2_')
elif fitType2 == 'Gaussian':
pk2 = GaussianModel(prefix='Peak2_')
elif fitType2 == 'PseudoVoigt':
pk2 = PseudoVoigtModel(prefix='Peak2_')
elif fitType2 == 'GND':
pk2 = gndModel(prefix='Peak2_')
if fitType3 == 'Lorentzian':
pk3 = LorentzianModel(prefix='Peak3_')
elif fitType3 == 'Gaussian':
pk3 = GaussianModel(prefix='Peak3_')
elif fitType3 == 'PseudoVoigt':
pk3 = PseudoVoigtModel(prefix='Peak3_')
elif fitType3 == 'GND':
pk3 = gndModel(prefix='Peak3_')
if fitType4 == 'Lorentzian':
pk4 = LorentzianModel(prefix='Peak4_')
elif fitType4 == 'Gaussian':
pk4 = GaussianModel(prefix='Peak4_')
elif fitType4 == 'PseudoVoigt':
pk4 = PseudoVoigtModel(prefix='Peak4_')
elif fitType4 == 'GND':
pk4 = gndModel(prefix='Peak4_')
if fitType5 == 'Lorentzian':
pk5 = LorentzianModel(prefix='Peak5_')
elif fitType5 == 'Gaussian':
pk5 = GaussianModel(prefix='Peak5_')
elif fitType5 == 'PseudoVoigt':
pk5 = PseudoVoigtModel(prefix='Peak5_')
elif fitType5 == 'GND':
pk5 = gndModel(prefix='Peak5_')
if fitType6 == 'Lorentzian':
pk6 = LorentzianModel(prefix='Peak6_')
elif fitType6 == 'Gaussian':
pk6 = GaussianModel(prefix='Peak6_')
elif fitType6 == 'PseudoVoigt':
pk6 = PseudoVoigtModel(prefix='Peak6_')
elif fitType6 == 'GND':
pk6 = gndModel(prefix='Peak6_')
pars.update(pk1.make_params())
pars['Peak1_center'].set(cen[0], min=cen[0] - 10, max=cen[0] + 10)
pars['Peak1_sigma'].set(20, min=0.01, max=50)
pars['Peak1_amplitude'].set(1e7, min=0)
if fitType1 == 'GND':
pars['Peak1_beta'].set(1.5, min=1, max=2)
if numPk == 2 or numPk == 3 or numPk == 4 or numPk == 5 or numPk == 6:
pars.update(pk2.make_params())
pars['Peak2_center'].set(cen[1], min=cen[1] - 10, max=cen[1] + 10)
pars['Peak2_amplitude'].set(1e7, min=0)
if eqWidth == 1:
pars['Peak2_sigma'].set(expr='Peak1_sigma')
elif eqWidth == 0:
pars['Peak2_sigma'].set(30, min=0.01, max=50)
if fitType2 == 'GND':
if eqBeta == 1:
pars['Peak2_beta'].set(expr='Peak1_beta')
elif eqBeta == 0:
pars['Peak2_beta'].set(1.5, min=1, max=2)
if numPk == 3 or numPk == 4 or numPk == 5 or numPk == 6:
pars.update(pk3.make_params())
pars['Peak3_center'].set(cen[2], min=cen[2] - 10, max=cen[2] + 10)
pars['Peak3_amplitude'].set(1e7, min=0)
if eqWidth == 1:
pars['Peak3_sigma'].set(expr='Peak1_sigma')
elif eqWidth == 0:
pars['Peak3_sigma'].set(30, min=0.01, max=50)
if fitType2 == 'GND':
if eqBeta == 1:
pars['Peak3_beta'].set(expr='Peak1_beta')
elif eqBeta == 0:
pars['Peak3_beta'].set(1.5, min=1, max=2)
if numPk == 4 or numPk == 5 or numPk == 6:
pars.update(pk4.make_params())
pars['Peak4_center'].set(cen[3], min=cen[3] - 10, max=cen[3] + 10)
pars['Peak4_sigma'].set(15, min=0.01, max=50)
pars['Peak4_amplitude'].set(1e7, min=0)
if fitType4 == 'GND':
pars['Peak4_beta'].set(1.5, min=1, max=2)
if numPk == 5 or numPk == 6:
pars.update(pk5.make_params())
pars['Peak5_center'].set(cen[4], min=cen[4] - 10, max=cen[4] + 10)
pars['Peak5_sigma'].set(15, min=0.01, max=50)
pars['Peak5_amplitude'].set(1e7, min=0)
if fitType5 == 'GND':
pars['Peak5_beta'].set(1.5, min=1, max=2)
if numPk == 6:
pars.update(pk6.make_params())
pars['Peak6_center'].set(cen[5], min=cen[5] - 10, max=cen[5] + 10)
pars['Peak6_sigma'].set(15, min=0.01, max=50)
pars['Peak6_amplitude'].set(1e7, min=0)
if fitType6 == 'GND':
pars['Peak6_beta'].set(1.5, min=1, max=2)
#model definition
pkModel = Lin1
if numPk == 2:
pkModel += pk1 + pk2
elif numPk == 3:
pkModel += pk1 + pk2 + pk3
elif numPk == 4:
pkModel += pk1 + pk2 + pk3 + pk4
elif numPk == 5:
pkModel += pk1 + pk2 + pk3 + pk4 + pk5
elif numPk == 6:
pkModel += pk1 + pk2 + pk3 + pk4 + pk5 + pk6
out = pkModel.fit(y, pars, x=x, weights=1.0 / y)
if fitstats == 1:
print('\n', out.fit_report(show_correl=False))
plt.figure(dpi=150, figsize=(3.5, 2.8))
lwid = 2
#plt.title('Radial Intensity distribution',fontsize=16)
plt.plot(x, y, label='data', lw=2)
plt.plot(x, out.best_fit, 'r-', lw=lwid, label='fit')
plt.xlabel('Angle (\xb0)', fontsize=16)
plt.ylabel('Intensity (a.u.)', fontsize=16)
plt.xticks([0, 90, 180, 270, 360], fontsize=14)
plt.locator_params('y', nbins=6)
plt.ticklabel_format(axis='y', style='sci', scilimits=(0, 0))
plt.yticks(fontsize=14)
plt.tight_layout()
plt.minorticks_on()
#plt.legend(fontsize=10)
plot_components = True
if plot_components:
comps = out.eval_components(x=x)
plt.plot(x, comps['Peak1_'] + comps['BackG_'], 'c--', lw=lwid)
plt.plot(x, comps['Peak2_'] + comps['BackG_'], 'b--', lw=lwid)
if numPk == 3:
plt.plot(x, comps['Peak3_'] + comps['BackG_'], 'y--', lw=lwid)
if numPk == 4:
plt.plot(x, comps['Peak3_'] + comps['BackG_'], 'y--', lw=lwid)
plt.plot(x, comps['Peak4_'] + comps['BackG_'], 'g--', lw=lwid)
if numPk == 5:
plt.plot(x, comps['Peak3_'] + comps['BackG_'], 'y--', lw=lwid)
plt.plot(x, comps['Peak4_'] + comps['BackG_'], 'g--', lw=lwid)
plt.plot(x, comps['Peak5_'] + comps['BackG_'], 'm--', lw=lwid)
if numPk == 6:
plt.plot(x, comps['Peak3_'] + comps['BackG_'], 'y--', lw=lwid)
plt.plot(x, comps['Peak4_'] + comps['BackG_'], 'g--', lw=lwid)
plt.plot(x, comps['Peak5_'] + comps['BackG_'], 'm--', lw=lwid)
plt.plot(x, comps['Peak6_'] + comps['BackG_'], 'k--', lw=lwid)
plt.plot(x, comps['BackG_'], 'r--', lw=lwid)
#plt.title('Radial Intensity Distribution', fontsize=14)
#plt.xlabel('Angle (\xb0)', fontsize=28)
#plt.ylabel('Intensity (a.u.)', fontsize=28)
#plt.show()
yBestFit = out.best_fit - comps['BackG_']
return out, yBestFit
c = 856.0
for filename in files:
x, y = np.loadtxt(direction + filename, unpack=True)
inicio = ind = list(abs(x - 805)).index(np.nanmin(abs(x - 805)))
ind = list(abs(x - 815)).index(np.nanmin(abs(x - 815)))
cavity_y = y[ind:]
cavity_x = x[ind:]
y = y[inicio:ind]
x = x[inicio:ind]
#Semillas que se dan iterativamente
pars = L0_mod.make_params(center=center, amplitude=amplitude, sigma=sigma)
pars += L1_mod.make_params(center=center1,
amplitude=amplitude1,
sigma=sigma1)
pars2 = L2_mod.guess(cavity_y, x=cavity_x)
pars += c_mod.make_params(c=c)
pars2 += c2_mod.make_params(c=c)
#bound_parameters_sigma(pars,2,5)
#Defino funcion
mod = L0_mod + c_mod + L1_mod #+ L2_mod
mod2 = L2_mod + c2_mod
#Fiteo
out = mod.fit(y, pars, x=x)
center2= 810.5 amplitude= 5000 amplitude1= 300 amplitude2= 300 sigma=0.4 sigma1=0.15 sigma2= 0.4 c=856.0 for filename in files: x,y = np.loadtxt(direction + filename, unpack=True) pars= L0_mod.make_params(center=center+1.0, amplitude=amplitude, sigma=sigma) pars+=L1_mod.make_params(center=center1, amplitude= amplitude1, sigma=sigma1) pars+=L2_mod.make_params(center=center2, amplitude= amplitude2, sigma=sigma2, max=2*sigma2 ) pars+=c_mod.make_params(c=c) mod =L0_mod + c_mod + L1_mod + L2_mod #Aparecen picos extra a partir de estos archivos if float(filename)>=20.50: if float(filename)==20.50: pars+=L3_mod.make_params(center= center1-0.5, amplitude= amplitude1, sigma=sigma1) pars+=L4_mod.make_params(center=center2-1.5, amplitude= amplitude2, sigma=sigma2) else: pars+=L3_mod.make_params(center= center3, amplitude= amplitude3, sigma=sigma3) pars+=L4_mod.make_params(center=center4, amplitude= amplitude4, sigma=sigma4)
def find_grain_diameter(X, Y, min_size, max_size, size_step, return_figure,
peaks_params, is_bg_active):
"""
New parameters are stored in peaks_params. The old ones are still present to provide compatibility with old code.
:param X:
:param Y:
:param min_size:
:param max_size:
:param size_step:
:param center:
:param gamma_0:
:param peak_height:
:param return_figure:
:param sample_type:
:param peaks_params: [[center, gamma_0, amplitude, from, to, is_visible, is_lorentz, is fano], ...]
:return:
"""
best_d = -1
best_sigma = -1
best_center = -1
best_amplitude = -1
best_q = 5
X_ex = X
max_y = max(Y)
x_range = (X > 400) * (X < 600)
lin_mod = LinearModel(prefix="background_", min=0, max=0.5 * max_y)
pars = lin_mod.guess(Y, x=X)
final_mod = lin_mod
for ii in range(0, len(peaks_params)):
if peaks_params[ii][6] == True:
mod = LorentzianModel(prefix="l" + str(ii) + '_')
pars.update(mod.make_params())
pars['l' + str(ii) + '_center'].set(peaks_params[ii][0],
min=peaks_params[ii][3],
max=peaks_params[ii][4])
pars['l' + str(ii) + '_sigma'].set(peaks_params[ii][1])
pars['l' + str(ii) + '_amplitude'].set(peaks_params[ii][2],
min=0) #, max=max_y)
elif peaks_params[ii][7] == True:
mod = Model(fano_function)
pars.update(mod.make_params())
pars['q'].set(
-4, min=-20, max=0
) #q may be negative as well as positive, the most common values for q: [-1,5]
pars['center'].set(peaks_params[ii][0], vary=True)
pars['sigma'].set(peaks_params[ii][1], min=0.1, vary=True)
pars['amplitude'].set(peaks_params[ii][2], min=0)
else:
mod = Model(
total_intensity_fit_func
) #total_intensity_fit_func(omega, d, N, center, gamma_0, amplitude)
pars.update(mod.make_params())
pars['d'].set((max_size - min_size), min=min_size, max=max_size)
pars['N'].set(100, vary=False)
pars['center'].set(peaks_params[ii][0], vary=False)
pars['sigma'].set(peaks_params[ii][1], vary=False)
pars['amplitude'].set(peaks_params[ii][2], min=0, max=max_y)
final_mod = final_mod + mod
###########PLOT & RETURN######################################
if return_figure:
my_figure = plt.Figure()
my_plot = my_figure.add_subplot(111)
legend_labels = []
for ax in my_figure.axes:
ax.set_xlabel(u'\u03C9' + ' [cm^-1]')
ax.set_ylabel('Intensity [arb.]')
my_plot.plot(X[x_range], Y[x_range], "ro")
legend_labels.append('Data')
out = final_mod.fit(Y[x_range], pars, x=X[x_range])
if not out.success:
print("!!!!!!!!!!!!!FIT HAVE FAILED!!!!!!!!!!!")
legend_labels = ['FIT FAILED!']
if return_figure:
my_plot.legend(legend_labels)
return best_d, best_sigma, best_center, best_amplitude, my_figure
else:
return best_d, best_sigma, best_center, best_amplitude
elif not return_figure:
if (peaks_params[0][6] == True):
best_sigma = out.best_values['l' + str(0) + '_sigma']
best_center = out.best_values['l' + str(0) + '_center']
best_amplitude = out.best_values['l' + str(0) + '_amplitude']
return 0, best_sigma, best_center, best_amplitude
elif (peaks_params[0][7] == True):
best_sigma = out.best_values['sigma']
best_center = out.best_values['center']
best_amplitude = out.best_values['amplitude']
best_q = out.best_values['q']
print(best_q)
return best_q, best_sigma, best_center, best_amplitude
else:
best_sigma = out.best_values['sigma']
best_center = out.best_values['center']
best_amplitude = out.best_values['amplitude']
best_d = out.best_values['d']
print(best_d)
return best_d, best_sigma, best_center, best_amplitude
else:
print(out.fit_report(min_correl=0.5))
legend_labels.append('Best fit')
my_plot.plot(X[x_range], out.best_fit, "b-")
my_plot.plot(
X[x_range], out.best_values['background_slope'] * X[x_range] +
out.best_values['background_intercept'], '--')
legend_labels.append('background')
for jj in range(0, len(peaks_params)):
if (peaks_params[jj][6] == True):
sigma = out.best_values['l' + str(jj) + '_sigma']
center = out.best_values['l' + str(jj) + '_center']
amplitude = out.best_values['l' + str(jj) + '_amplitude']
legend_labels.append('l' + str(jj))
my_plot.plot(
X[x_range],
lorentzian(X[x_range],
center=center,
sigma=sigma,
amplitude=amplitude), '--')
elif (peaks_params[jj][7] == True):
sigma = out.best_values['sigma']
center = out.best_values['center']
amplitude = out.best_values['amplitude']
q = out.best_values['q']
legend_labels.append('fano; q=' + str(q))
my_plot.plot(
X[x_range],
fano_function(X[x_range], q, center, sigma, amplitude),
'--')
else:
sigma = out.best_values['sigma']
center = out.best_values['center']
amplitude = out.best_values['amplitude']
d = out.best_values['d']
N = out.best_values['N']
legend_labels.append('fc; d=' + str(d))
my_plot.plot(
X[x_range],
total_intensity_fit_func(X[x_range], d, N, center, sigma,
amplitude), '--')
if (peaks_params[0][7] == True):
my_figure.suptitle(
"q:{0:.1f}[nm] omega:{1:.4f}[cm^-1] sigma:{2:.4f}[cm^-1] inten:{3:.4}[arb]"
.format(float(best_q), float(best_center), float(best_sigma),
float(best_amplitude)))
else:
my_figure.suptitle(
"d:{0:.1f}[nm] omega:{1:.4f}[cm^-1] sigma:{2:.4f}[cm^-1] inten:{3:.4}[arb]"
.format(float(best_d), float(best_center), float(best_sigma),
float(best_amplitude)))
my_plot.legend(legend_labels, loc=2)
return best_d, best_sigma, best_center, best_amplitude, my_figure
profile.subplot(221)
strctural.imshow(figure=profile.fig, title="Structural Image")
profile.subplot(223)
xmcd.imshow(figure=profile.fig, title="XMCD Image")
# Make a histogram of the intesity values
hist = xmcd.hist(bins=200)
hist.column_headers = ["XMCD Signal", "Frequency"]
hist.labels = None
hist.fig = profile.fig
# Construct a two Lorentzian peak model
peak1 = LorentzianModel(prefix="peak1_")
peak2 = LorentzianModel(prefix="peak2_")
params = peak1.make_params()
params.update(peak2.make_params())
double_peak = peak1 + peak2
def guess(self, data, **kwargs):
"""Function to guess the parameters of two Lorentzian peaks."""
x = kwargs.get("x")
l = len(data)
i1 = np.argmax(data[: l // 2]) # Location of first peak
i2 = np.argmax(data[l // 2 :]) + l // 2
params = self.make_params()
for k, p in zip(
params,
[
def fit_lorentizans(x, y, p1, n=1, make_fit=True):
sub_models = []
for i in range(n):
prefix = 'l' + str(i + 1) + '_'
li = LorentzianModel(prefix=prefix)
if i == 0:
parameters = li.make_params()
else:
parameters.update(li.make_params())
A = p1[i]
sigma = p1[2 * n + i]
center = p1[n + i]
sigmap = sigma / 2
Ap = A * pi * sigmap
parameters[prefix + 'center'].set(center)
parameters[prefix + 'amplitude'].set(Ap)
parameters[prefix + 'sigma'].set(sigmap)
sub_models += [li]
mod = sub_models[0]
for i in range(1, n):
mod += sub_models[i]
init = mod.eval(parameters, x=x)
if not make_fit: return p1, [0 for i in range(3 * n)], init
out = mod.fit(y, parameters, x=x)
#print out.result.params.var_names
var_names = out.result.var_names
error_bars0 = {}
for i in var_names:
ii = var_names.index(i)
error_bar = sqrt(out.result.covar[ii][ii])
error_bars0.update({i: error_bar})
result = out.values
fit = [0 for i in range(3 * n)]
error_bars = [0 for i in range(3 * n)]
for i in range(n):
Ap = result['l' + str(i + 1) + '_amplitude']
sigmap = result['l' + str(i + 1) + '_sigma']
center = result['l' + str(i + 1) + '_center']
Ap_bar = error_bars0['l' + str(i + 1) + '_amplitude']
center_bar = error_bars0['l' + str(i + 1) + '_center']
sigmap_bar = error_bars0['l' + str(i + 1) + '_sigma']
A = Ap / pi / sigmap
sigma = 2 * sigmap
covar = out.result.covar[n * i][n * i + 2]
A_bar = A * sqrt((Ap_bar / Ap)**2 + (sigmap_bar / sigmap)**2 -
2 * covar / Ap / sigmap) / pi
sigma_bar = 2 * sigmap_bar
fit[i] = A
fit[n + i] = center
fit[2 * n + i] = sigma
error_bars[i] = A_bar
error_bars[n + i] = center_bar
error_bars[2 * n + i] = sigma_bar
fitted_curve = out.best_fit
return fit, error_bars, fitted_curve
