def setUp(self):
self.x = numpy.arange(100)
self.y = 10 + 0.05 * self.x + sum_gauss(self.x, 10., 45., 15.)
# add a very narrow high amplitude peak to test strip and snip
self.y += sum_gauss(self.x, 100., 75., 2.)
self.narrow_peak_index = list(self.x).index(75)
random.seed()
def main():
# synthetic data
from silx.math.fit.functions import sum_gauss
x = numpy.arange(5000)
# (height1, center1, fwhm1, ...) 5 peaks
params1 = (50, 500, 100,
20, 2000, 200,
50, 2250, 100,
40, 3000, 75,
23, 4000, 150)
y0 = sum_gauss(x, *params1)
# random values between [-1;1]
noise = 2 * numpy.random.random(5000) - 1
# make it +- 5%
noise *= 0.05
# 2 gaussians with very large fwhm, as background signal
actual_bg = sum_gauss(x, 15, 3500, 3000, 5, 1000, 1500)
# Add 5% random noise to gaussians and add background
y = y0 + numpy.average(y0) * noise + actual_bg
# Open widget
a = qt.QApplication(sys.argv)
a.lastWindowClosed.connect(a.quit)
def mySlot(ddict):
print(ddict)
w = BackgroundDialog()
w.parametersWidget.parametersWidget.sigBackgroundParamWidgetSignal.connect(mySlot)
w.setData(x, y)
w.exec_()
def main():
# synthetic data
from silx.math.fit.functions import sum_gauss
x = numpy.arange(5000)
# (height1, center1, fwhm1, ...) 5 peaks
params1 = (50, 500, 100,
20, 2000, 200,
50, 2250, 100,
40, 3000, 75,
23, 4000, 150)
y0 = sum_gauss(x, *params1)
# random values between [-1;1]
noise = 2 * numpy.random.random(5000) - 1
# make it +- 5%
noise *= 0.05
# 2 gaussians with very large fwhm, as background signal
actual_bg = sum_gauss(x, 15, 3500, 3000, 5, 1000, 1500)
# Add 5% random noise to gaussians and add background
y = y0 + numpy.average(y0) * noise + actual_bg
# Open widget
a = qt.QApplication(sys.argv)
a.lastWindowClosed.connect(a.quit)
def mySlot(ddict):
print(ddict)
w = BackgroundDialog()
w.parametersWidget.parametersWidget.sigBackgroundParamWidgetSignal.connect(mySlot)
w.setData(x, y)
w.exec()
def gaussian_fit(y, x):
#
# Fitting
#
from silx.math.fit.functions import sum_gauss
from silx.math.fit import fittheories
from silx.math.fit.fitmanager import FitManager
p = [y.max(), 0, 5]
fit = FitManager()
fit.setdata(x=x, y=y)
fit.loadtheories(fittheories)
fit.settheory('Gaussians')
fit.estimate()
fit.runfit()
print("Searched parameters = %s" % p)
print("Obtained parameters : ")
dummy_list = []
for param in fit.fit_results:
print(param['name'], ' = ', param['fitresult'])
dummy_list.append(param['fitresult'])
print("chisq = ", fit.chisq)
fwhm_txt = "FWHM of fit = %5.3f um" % (fit.fit_results[2]['fitresult'])
y1 = sum_gauss(x, *dummy_list)
return y1
def testFitManager(self):
"""Test fit manager on synthetic data using a gaussian function
and a linear background"""
# Create synthetic data with a sum of gaussian functions
x = numpy.arange(1000).astype(numpy.float64)
p = [1000, 100., 250,
255, 650., 45,
1500, 800.5, 95]
linear_bg = 2.65 * x + 13
y = linear_bg + sum_gauss(x, *p)
y_with_nans = numpy.array(y)
y_with_nans[::10] = numpy.nan
x_with_nans = numpy.array(x)
x_with_nans[5::15] = numpy.nan
tests = {
'all finite': (x, y),
'y with NaNs': (x, y_with_nans),
'x with NaNs': (x_with_nans, y),
}
for name, (xdata, ydata) in tests.items():
with self.subTest(name=name):
# Fitting
fit = fitmanager.FitManager()
fit.setdata(x=xdata, y=ydata)
fit.loadtheories(fittheories)
# Use one of the default fit functions
fit.settheory('Gaussians')
fit.setbackground('Linear')
fit.estimate()
fit.runfit()
# fit.fit_results[]
# first 2 parameters are related to the linear background
self.assertEqual(fit.fit_results[0]["name"], "Constant")
self.assertAlmostEqual(fit.fit_results[0]["fitresult"], 13)
self.assertEqual(fit.fit_results[1]["name"], "Slope")
self.assertAlmostEqual(fit.fit_results[1]["fitresult"], 2.65)
for i, param in enumerate(fit.fit_results[2:]):
param_number = i // 3 + 1
if i % 3 == 0:
self.assertEqual(param["name"],
"Height%d" % param_number)
elif i % 3 == 1:
self.assertEqual(param["name"],
"Position%d" % param_number)
elif i % 3 == 2:
self.assertEqual(param["name"],
"FWHM%d" % param_number)
self.assertAlmostEqual(param["fitresult"],
p[i])
self.assertAlmostEqual(_order_of_magnitude(param["estimation"]),
_order_of_magnitude(p[i]))
def test():
from silx.math.fit import fittheories
from silx.math.fit import fitmanager
from silx.math.fit import functions
from silx.gui.plot.PlotWindow import PlotWindow
import numpy
a = qt.QApplication([])
x = numpy.arange(1000)
y1 = functions.sum_gauss(x, 100, 400, 100)
fit = fitmanager.FitManager(x=x, y=y1)
fitfuns = fittheories.FitTheories()
fit.addtheory(name="Gaussian",
function=functions.sum_gauss,
parameters=("height", "peak center", "fwhm"),
estimate=fitfuns.estimate_height_position_fwhm)
fit.settheory('Gaussian')
fit.configure(
PositiveFwhmFlag=True,
PositiveHeightAreaFlag=True,
AutoFwhm=True,
)
# Fit
fit.estimate()
fit.runfit()
w = ParametersTab()
w.show()
w.fillFromFit(fit.fit_results, view='Gaussians')
y2 = functions.sum_splitgauss(x, 100, 400, 100, 40, 10, 600, 50, 500, 80,
850, 10, 50)
fit.setdata(x=x, y=y2)
# Define new theory
fit.addtheory(name="Asymetric gaussian",
function=functions.sum_splitgauss,
parameters=("height", "peak center", "left fwhm",
"right fwhm"),
estimate=fitfuns.estimate_splitgauss)
fit.settheory('Asymetric gaussian')
# Fit
fit.estimate()
fit.runfit()
w.fillFromFit(fit.fit_results, view='Asymetric gaussians')
# Plot
pw = PlotWindow(control=True)
pw.addCurve(x, y1, "Gaussians")
pw.addCurve(x, y2, "Asymetric gaussians")
pw.show()
a.exec_()
def testGauss(self):
"""Compare sum_gauss with scipy.signals.gaussian"""
y = functions.sum_gauss(self.x, self.g_params["height"],
self.g_params["center"],
self.g_params["fwhm1"])
for i in range(11):
self.assertAlmostEqual(y[i], self.scipy_gaussian[i])
def test():
from silx.math.fit import fittheories
from silx.math.fit import fitmanager
from silx.math.fit import functions
from silx.gui.plot.PlotWindow import PlotWindow
import numpy
a = qt.QApplication([])
x = numpy.arange(1000)
y1 = functions.sum_gauss(x, 100, 400, 100)
fit = fitmanager.FitManager(x=x, y=y1)
fitfuns = fittheories.FitTheories()
fit.addtheory(name="Gaussian",
function=functions.sum_gauss,
parameters=("height", "peak center", "fwhm"),
estimate=fitfuns.estimate_height_position_fwhm)
fit.settheory('Gaussian')
fit.configure(PositiveFwhmFlag=True,
PositiveHeightAreaFlag=True,
AutoFwhm=True,)
# Fit
fit.estimate()
fit.runfit()
w = ParametersTab()
w.show()
w.fillFromFit(fit.fit_results, view='Gaussians')
y2 = functions.sum_splitgauss(x,
100, 400, 100, 40,
10, 600, 50, 500,
80, 850, 10, 50)
fit.setdata(x=x, y=y2)
# Define new theory
fit.addtheory(name="Asymetric gaussian",
function=functions.sum_splitgauss,
parameters=("height", "peak center", "left fwhm", "right fwhm"),
estimate=fitfuns.estimate_splitgauss)
fit.settheory('Asymetric gaussian')
# Fit
fit.estimate()
fit.runfit()
w.fillFromFit(fit.fit_results, view='Asymetric gaussians')
# Plot
pw = PlotWindow(control=True)
pw.addCurve(x, y1, "Gaussians")
pw.addCurve(x, y2, "Asymetric gaussians")
pw.show()
a.exec_()
def testGauss(self):
"""Compare sum_gauss with scipy.signals.gaussian"""
y = functions.sum_gauss(self.x,
self.g_params["height"],
self.g_params["center"],
self.g_params["fwhm1"])
for i in range(11):
self.assertAlmostEqual(y[i], self.scipy_gaussian[i])
def testQuarticcBg(self):
gaussian_params = [10000, 69, 25]
poly_params = [5e-10, 0.0005, 0.005, 2, 4]
p = numpy.poly1d(poly_params)
y = p(self.x) + sum_gauss(self.x, *gaussian_params)
fm = fitmanager.FitManager(self.x, y)
fm.loadtheories(fittheories)
fm.settheory("Gaussians")
fm.setbackground("Degree 4 Polynomial")
esti_params = fm.estimate()
fit_params = fm.runfit()[0]
for p, pfit in zip(poly_params + gaussian_params, fit_params):
self.assertAlmostEqual(p, pfit, places=5)
def testCubicBg(self):
gaussian_params = [1000, 45, 8]
poly_params = [0.0005, -0.05, 3, -4]
p = numpy.poly1d(poly_params)
y = p(self.x) + sum_gauss(self.x, *gaussian_params)
fm = fitmanager.FitManager(self.x, y)
fm.loadtheories(fittheories)
fm.settheory("Gaussians")
fm.setbackground("Degree 3 Polynomial")
esti_params = fm.estimate()
fit_params = fm.runfit()[0]
for p, pfit in zip(poly_params + gaussian_params, fit_params):
self.assertAlmostEqual(p, pfit)
def testFitManager(self):
"""Test fit manager on synthetic data using a gaussian function
and a linear background"""
# Create synthetic data with a sum of gaussian functions
x = numpy.arange(1000).astype(numpy.float)
p = [1000, 100., 250,
255, 650., 45,
1500, 800.5, 95]
linear_bg = 2.65 * x + 13
y = linear_bg + sum_gauss(x, *p)
# Fitting
fit = fitmanager.FitManager()
fit.setdata(x=x, y=y)
fit.loadtheories(fittheories)
# Use one of the default fit functions
fit.settheory('Gaussians')
fit.setbackground('Linear')
fit.estimate()
fit.runfit()
# fit.fit_results[]
# first 2 parameters are related to the linear background
self.assertEqual(fit.fit_results[0]["name"], "Constant")
self.assertAlmostEqual(fit.fit_results[0]["fitresult"], 13)
self.assertEqual(fit.fit_results[1]["name"], "Slope")
self.assertAlmostEqual(fit.fit_results[1]["fitresult"], 2.65)
for i, param in enumerate(fit.fit_results[2:]):
param_number = i // 3 + 1
if i % 3 == 0:
self.assertEqual(param["name"],
"Height%d" % param_number)
elif i % 3 == 1:
self.assertEqual(param["name"],
"Position%d" % param_number)
elif i % 3 == 2:
self.assertEqual(param["name"],
"FWHM%d" % param_number)
self.assertAlmostEqual(param["fitresult"],
p[i])
self.assertAlmostEqual(_order_of_magnitude(param["estimation"]),
_order_of_magnitude(p[i]))
def testCubicBg(self):
gaussian_params = [1000, 45, 8]
poly_params = [0.0005, -0.05, 3, -4]
p = numpy.poly1d(poly_params)
y = p(self.x) + sum_gauss(self.x, *gaussian_params)
fm = fitmanager.FitManager(self.x, y)
fm.loadtheories(fittheories)
fm.settheory("Gaussians")
fm.setbackground("Degree 3 Polynomial")
esti_params = fm.estimate()
fit_params = fm.runfit()[0]
for p, pfit in zip(poly_params + gaussian_params, fit_params):
self.assertAlmostEqual(p,
pfit)
def testQuarticcBg(self):
gaussian_params = [10000, 69, 25]
poly_params = [5e-10, 0.0005, 0.005, 2, 4]
p = numpy.poly1d(poly_params)
y = p(self.x) + sum_gauss(self.x, *gaussian_params)
fm = fitmanager.FitManager(self.x, y)
fm.loadtheories(fittheories)
fm.settheory("Gaussians")
fm.setbackground("Degree 4 Polynomial")
esti_params = fm.estimate()
fit_params = fm.runfit()[0]
for p, pfit in zip(poly_params + gaussian_params, fit_params):
self.assertAlmostEqual(p,
pfit,
places=5)
else:
chisq = data['chisq']
self.guistatus.ChisqLine.setText("%6.2f" % chisq)
if 'status' in data:
status = data['status']
self.guistatus.StatusLine.setText(str(status))
def dismiss(self):
"""Close FitWidget"""
self.close()
if __name__ == "__main__":
import numpy
x = numpy.arange(1500).astype(numpy.float64)
constant_bg = 3.14
p = [
1000, 100., 30.0, 500, 300., 25., 1700, 500., 35., 750, 700., 30.0,
1234, 900., 29.5, 302, 1100., 30.5, 75, 1300., 21.
]
y = functions.sum_gauss(x, *p) + constant_bg
a = qt.QApplication(sys.argv)
w = FitWidget()
w.setData(x=x, y=y)
w.show()
a.exec()
# fit.settheory('Area Gaussians')
# fit.settheory('Slit')
fit.estimate()
fit.runfit()
print("Searched parameters = %s" % p)
print("Obtained parameters : ")
dummy_list = []
for param in fit.fit_results:
# print(param)
print(param['name'], ' = ', param['fitresult'])
if param['name'] == "FWHM1":
print("sigma1 = ",
param['fitresult'] / (2 * numpy.sqrt(2 * numpy.log(2))))
dummy_list.append(param['fitresult'])
print("chisq = ", fit.chisq)
y1 = sum_gauss(x, *dummy_list)
# y1 = sum_agauss(x, *dummy_list)
print("Area original: ", y.sum() * (x[1] - x[0]))
print("Area fit: ", y1.sum() * (x[1] - x[0]))
plt.rc('text', usetex=True)
plt.plot(x, y)
plt.xlabel(r'$\theta_r=\theta\sqrt{L/\lambda}$') # =\sigma_{\mu}/\sigma_I')
plt.ylabel(r'$(sin(\Gamma)/\Gamma)^2$')
plt.plot(x, y1)
plt.savefig('undulator_fit.eps')
plt.show()
if 'status' in data:
status = data['status']
self.guistatus.StatusLine.setText(str(status))
def dismiss(self):
"""Close FitWidget"""
self.close()
if __name__ == "__main__":
import numpy
x = numpy.arange(1500).astype(numpy.float)
constant_bg = 3.14
p = [1000, 100., 30.0,
500, 300., 25.,
1700, 500., 35.,
750, 700., 30.0,
1234, 900., 29.5,
302, 1100., 30.5,
75, 1300., 21.]
y = functions.sum_gauss(x, *p) + constant_bg
a = qt.QApplication(sys.argv)
w = FitWidget()
w.setData(x=x, y=y)
w.show()
a.exec_()
def gaussian_fit_scan(simulation_test0,
shift_min=-5e-2,
shift_max=5e-2,
shift_n=5,
do_plot=True):
from silx.math.fit.functions import sum_gauss
from silx.math.fit import fittheories
from silx.math.fit.fitmanager import FitManager
SHIFT = np.linspace(shift_min, shift_max, shift_n)
CHI = np.zeros_like(SHIFT)
KUR = np.zeros_like(SHIFT)
for i, shift in enumerate(SHIFT):
simulation_test = simulation_test0.copy()
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>", SHIFT[i])
omega0 = simulation_test.radiation_fact.photon_frequency
omega = omega0 + omega0 * shift
simulation_test.radiation_fact.photon_frequency = omega
simulation_test.update_radiation()
#
#
#
x = 1e6 * simulation_test.radiation.Y[0, :]
y = simulation_test.radiation.intensity[0, :]
y /= y.max()
#
# Fitting
#
p = [y.max(), 0, 0.3 * x.max()]
fit = FitManager()
fit.setdata(x=x, y=y)
fit.loadtheories(fittheories)
fit.settheory('Gaussians')
fit.estimate()
fit.runfit()
print("Searched parameters = %s" % p)
print("Obtained parameters : ")
dummy_list = []
for param in fit.fit_results:
print(param['name'], ' = ', param['fitresult'])
dummy_list.append(param['fitresult'])
print("chisq = ", fit.chisq)
fwhm_txt = "FWHM of fit = %5.3f um" % (fit.fit_results[2]['fitresult'])
y1 = sum_gauss(x, *dummy_list)
# plot(x,y,x,y1,legend=["data","fit"])
print(">>>> Kurtosis0: ", scipy.stats.kurtosis(y, axis=None))
print(">>>> Kurtosis: ", scipy.stats.kurtosis(y1, axis=None))
print(">>>>>>> chi**2", ((y - y1)**2).sum())
KUR[i] = scipy.stats.kurtosis(y1, axis=None)
CHI[i] = ((y - y1)**2).sum()
plot(SHIFT, CHI, title="CHI", show=False)
plot(SHIFT, KUR, title="kur")
