def draw_model_fit(self, path, wavelength, flux):
""" Generate the gauss model, draw the model results based on x value range
and update the table that shows the results parameters"""
self.__quadraticDeque.append(1)
for i, key in enumerate(self.__quadraticDict.keys()):
self.__quadraticDict[key] = self.__quadraticDeque[i]
#Obtain the wavelength values on given range
wavelengthValues = wavelength[
(wavelength >= self.__quadraticDict['left'][0])
& (wavelength <= self.__quadraticDict['right'][0])]
#Obtain de indexes from the initial wavelength array
#based on the min a max values of the slice made previously
index1 = np.where(wavelength == np.amin(wavelengthValues))
index2 = np.where(wavelength == np.amax(wavelengthValues))
#Obtain the flux values between the indexes obtained previously
fluxValues = flux[index1[0][0]:(index2[0][0] + 1)]
quadratic_model = Model(quadratic_fitting_function, name='model1')
slope = calculate_slope(self.__quadraticDict['left'][0],
self.__quadraticDict['left'][1],
self.__quadraticDict['right'][0],
self.__quadraticDict['right'][1])
inital_y_values = self._generate_initial_quadratic_model(
wavelengthValues,
calculate_intercept(slope, self.__quadraticDict['left'][0],
self.__quadraticDict['left'][1]), slope)
params = quadratic_model.make_params(a=calculate_intercept(
slope, self.__quadraticDict['left'][0],
self.__quadraticDict['left'][1]),
b=slope)
init = quadratic_model.eval(params, x=wavelengthValues)
result = quadratic_model.fit(fluxValues, params, x=wavelengthValues)
#Update table of results parameters
resultText = "Path: {}".format(path)
resultText = resultText + "\n" + \
"Quadratic model: {} + {} * x + {} * x**2".format(str(result.params['a'].value), str(result.params['b'].value), str(result.params['c2'].value))
quadraticFitResultList = [
key + " = " + str(result.params[key].value)
for key in result.params
]
for resultParams in quadraticFitResultList:
resultText = resultText + "\n" + resultParams
resultText = resultText + "\n" + "Chi-square" + " = " + str(
result.chisqr)
return result, resultText, wavelengthValues, fluxValues, inital_y_values, None
def draw_model_fit(self, path, wavelength, flux):
""" Generate the gauss model, draw the model results based on x value range
and update the table that shows the results parameters"""
if self.__typeCont == 'quadratic':
self.__modelDeque.append(1)
for i, key in enumerate(self.__modelDict.keys()):
self.__modelDict[key] = self.__modelDeque[i]
#Obtain the wavelength values on given range
wavelengthValues = wavelength[(wavelength >= self.__modelDict['left'][0]) & (wavelength <= self.__modelDict['right'][0])]
#Obtain de indexes from the initial wavelength array
#based on the min a max values of the slice made previously
index1 = np.where(wavelength == np.amin(wavelengthValues))
index2 = np.where(wavelength == np.amax(wavelengthValues))
#Obtain the flux values between the indexes obtained previously
fluxValues = flux[index1[0][0]:(index2[0][0]+1)]
gauss = Model(gauss_fitting_function, prefix='p1_', name = 'model2')
lorentz = Model(lorentzian_fitting_function, prefix='p2_', name = 'model1')
#Check type of continuum used
if self.__typeCont == 'line':
line = Model(line_fitting_function, name = 'continuum_fitting_function')
lorentzGauss_model = lorentz + gauss + line
slope = calculate_slope(self.__modelDict['left'][0], self.__modelDict['left'][1],self.__modelDict['right'][0], self.__modelDict['right'][1])
params = lorentzGauss_model.make_params(p1_h = self.__modelDict['p1_top'][1] - (self.__modelDict['left'][1] + self.__modelDict['right'][1])/2.,
p1_c = self.__modelDict['p1_top'][0],
p1_sigma=abs(self.__modelDict['p1_sigma2'][0]-self.__modelDict['p1_sigma1'][0])/2.355,
p2_h=self.__modelDict['p2_top'][1] - (self.__modelDict['left'][1] + self.__modelDict['right'][1])/2.,
p2_c=self.__modelDict['p2_top'][0],
p2_sigma=abs(self.__modelDict['p2_sigma2'][0]-self.__modelDict['p2_sigma1'][0])/2.,
a=calculate_intercept(slope, self.__modelDict['left'][0], self.__modelDict['left'][1]),
b=slope)
init = lorentzGauss_model.eval(params, x=wavelengthValues)
result = lorentzGauss_model.fit(fluxValues, params, x=wavelengthValues)
#Obtain the initial values of the gaussian model to be drawn
initial_y1_values = self._generate_initial_lorentz_model(wavelengthValues, self.__modelDict['p1_top'][1] - (self.__modelDict['left'][1] + self.__modelDict['p1_top'][0])/2., self.__modelDict['p1_top'][0], abs(self.__modelDict['p1_sigma2'][0] - self.__modelDict['p1_sigma1'][0])/2.)
initial_y2_values = self._generate_initial_gauss_model(wavelengthValues, self.__modelDict['p2_top'][1] - (self.__modelDict['left'][1] + self.__modelDict['p2_top'][0])/2., self.__modelDict['p2_top'][0], abs(self.__modelDict['p2_sigma2'][0] - self.__modelDict['p2_sigma1'][0])/2.355)
#Update table of results parameters
resultText = "Path: {}".format(path)
resultText = resultText + "\n" + \
"Lorentz model: (2*{}*{}/pi)*({}/(x-{})**2 + {}**2)".format(str(result.params['p1_sigma']. value), str(result.params['p1_h'].value), str(result.params['p1_sigma'].value), str(result.params['p1_c'].value) , str(result.params['p1_sigma'].value))
resultText = resultText + "\n" + \
"Gauss model: {} * e ** ((x-{})**2/(-2*{}**2))".format(str(result.params['p2_h'].value), str(result.params['p2_c'].value), str(result.params['p2_sigma'].value))
resultText = resultText + "\n" + "Line model: {} + {} * x".format(str(result.params['a'].value), str(result.params['b'].value))
resultText = resultText + "\n" + "Lorentz integrated flux : "+ " = " + str(integrated_flux(result.params['p1_h'].value, result.params['p1_sigma'].value, 'lorentz'))
lorentzGaussFitResultList = [key + " = " + str(result.params[key].value) for key in result.params]
for resultParams in lorentzGaussFitResultList:
if resultParams.startswith('p2_h'):
resultText = resultText + "\n" + "Gaussian integrated flux : "+ " = " + str(integrated_flux(result.params['p2_h'].value, result.params['p2_sigma'].value, 'gauss'))
resultText = resultText + "\n" + resultParams
resultText = resultText + "\n" + "Chi-square" + " = " + str(result.chisqr)
return result, resultText, wavelengthValues, fluxValues, initial_y1_values, initial_y2_values
elif self.__typeCont == 'quadratic':
quadratic = Model(quadratic_fitting_function, name= 'continuum_fitting_function')
lorentzGauss_model = lorentz + gauss + quadratic
slope = calculate_slope(self.__modelDict['left'][0], self.__modelDict['left'][1],self.__modelDict['right'][0], self.__modelDict['right'][1])
params = lorentzGauss_model.make_params(p1_h = self.__modelDict['p1_top'][1] - (self.__modelDict['left'][1] + self.__modelDict['right'][1])/2.,
p1_c = self.__modelDict['p1_top'][0],
p1_sigma=abs(self.__modelDict['p1_sigma2'][0]-self.__modelDict['p1_sigma1'][0])/2.355,
p2_h=self.__modelDict['p2_top'][1] - (self.__modelDict['left'][1] + self.__modelDict['right'][1])/2.,
p2_c=self.__modelDict['p2_top'][0],
p2_sigma=abs(self.__modelDict['p2_sigma2'][0]-self.__modelDict['p2_sigma1'][0])/2.,
a=calculate_intercept(slope, self.__modelDict['left'][0], self.__modelDict['left'][1]),
b=slope,
c2=1)
init = lorentzGauss_model.eval(params, x=wavelengthValues)
result = lorentzGauss_model.fit(fluxValues, params, x=wavelengthValues)
#Obtain the initial values of the gaussian model to be drawn
initial_y1_values = self._generate_initial_lorentz_model(wavelengthValues, self.__modelDict['p1_top'][1] - (self.__modelDict['left'][1] + self.__modelDict['p1_top'][0])/2., self.__modelDict['p1_top'][0], abs(self.__modelDict['p1_sigma2'][0] - self.__modelDict['p1_sigma1'][0])/2.)
initial_y2_values = self._generate_initial_gauss_model(wavelengthValues, self.__modelDict['p2_top'][1] - (self.__modelDict['left'][1] + self.__modelDict['p2_top'][0])/2., self.__modelDict['p2_top'][0], abs(self.__modelDict['p2_sigma2'][0] - self.__modelDict['p2_sigma1'][0])/2.355)
#Update table of results parameters
resultText = "Path: {}".format(path)
resultText = resultText + "\n" + \
"Lorentz model: (2*{}*{}/pi)*({}/(x-{})**2 + {}**2)".format(str(result.params['p1_sigma']. value), str(result.params['p1_h'].value), str(result.params['p1_sigma'].value), str(result.params['p1_c'].value) , str(result.params['p1_sigma'].value))
resultText = resultText + "\n" + \
"Gauss model: {} * e ** ((x-{})**2/(-2*{}**2))".format(str(result.params['p2_h'].value), str(result.params['p2_c'].value), str(result.params['p2_sigma'].value))
resultText = resultText + "\n" + "Quadratic model: {} + {} * x + {}*x**2".format(str(result.params['a'].value), str(result.params['b'].value), str(result.params['c2'].value))
resultText = resultText + "\n" + "Lorentz integrated flux : "+ " = " + str(integrated_flux(result.params['p1_h'].value, result.params['p1_sigma'].value, 'lorentz'))
lorentzGaussFitResultList = [key + " = " + str(result.params[key].value) for key in result.params]
for resultParams in lorentzGaussFitResultList:
if resultParams.startswith('p2_h'):
resultText = resultText + "\n" + "Gaussian integrated flux : "+ " = " + str(integrated_flux(result.params['p2_h'].value, result.params['p2_sigma'].value, 'gauss'))
resultText = resultText + "\n" + resultParams
resultText = resultText + "\n" + "Chi-square" + " = " + str(result.chisqr)
return result, resultText, wavelengthValues, fluxValues, initial_y1_values, initial_y2_values
def test_intercept():
intersect = 4.6- 3*3.5
intercept2 = calculate_intercept(3, 3.5, 4.6)
def draw_model_fit(self, path, wavelength, flux):
""" Generate the gauss model, draw the model results based on x value range
and update the table that shows the results parameters"""
if self.__typeCont == 'quadratic':
self.__gaussDeque.append(1)
#print(self.__gaussDict)
#print(self.__gaussDeque)
for i, key in enumerate(self.__gaussDict.keys()):
self.__gaussDict[key] = self.__gaussDeque[i]
#Obtain the wavelength values on given range
wavelengthValues = wavelength[
(wavelength >= self.__gaussDict['left'][0])
& (wavelength <= self.__gaussDict['right'][0])]
#Obtain de indexes from the initial wavelength array
#based on the min a max values of the slice made previously
index1 = np.where(wavelength == np.amin(wavelengthValues))
index2 = np.where(wavelength == np.amax(wavelengthValues))
#Obtain the flux values between the indexes obtained previously
fluxValues = flux[index1[0][0]:(index2[0][0] + 1)]
gauss = Model(gauss_fitting_function, name='model1')
if self.__typeCont == 'line':
inital_y_values = self._generate_initial_gauss_model(
wavelengthValues, self.__gaussDict['top'][1] -
(self.__gaussDict['left'][1] + self.__gaussDict['right'][1]) /
2., self.__gaussDict['top'][0],
abs(self.__gaussDict['sigma2'][0] -
self.__gaussDict['sigma1'][0]) / 2.355)
line = Model(line_fitting_function,
name='continuum_fitting_function')
gauss_model = gauss + line
slope = calculate_slope(self.__gaussDict['left'][0],
self.__gaussDict['left'][1],
self.__gaussDict['right'][0],
self.__gaussDict['right'][1])
params = gauss_model.make_params(
h=self.__gaussDict['top'][1] -
(self.__gaussDict['left'][1] + self.__gaussDict['right'][1]) /
2.,
c=self.__gaussDict['top'][0],
sigma=abs(self.__gaussDict['sigma2'][1] -
self.__gaussDict['sigma1'][1]) / 2.355,
a=calculate_intercept(slope, self.__gaussDict['left'][0],
self.__gaussDict['left'][1]),
b=slope)
init = gauss_model.eval(params, x=wavelengthValues)
result = gauss_model.fit(fluxValues, params, x=wavelengthValues)
#Update table of results parameters
resultText = "Path: {}".format(path)
resultText = resultText + "\n" + \
"Gauss model: {} * e ** ((x-{})**2/(-2*{}**2))".format(str(result.params['h'].value), str(result.params['c'].value), str(result.params['sigma'].value))
resultText = resultText + "\n" + "Line model: {} + {} * x".format(
str(result.params['a'].value), str(result.params['b'].value))
resultText = resultText + "\n" + "Gaussian integrated flux : " + " = " + str(
integrated_flux(result.params['h'].value,
result.params['sigma'].value, 'gauss'))
gaussFitResultList = [
key + " = " + str(result.params[key].value)
for key in result.params
]
for resultParams in gaussFitResultList:
resultText = resultText + "\n" + resultParams
resultText = resultText + "\n" + "Chi-square" + " = " + str(
result.chisqr)
return result, resultText, wavelengthValues, fluxValues, inital_y_values, None
elif self.__typeCont == 'quadratic':
inital_y_values = self._generate_initial_gauss_model(
wavelengthValues, self.__gaussDict['top'][1] -
(self.__gaussDict['left'][1] + self.__gaussDict['right'][1]) /
2., self.__gaussDict['top'][0],
abs(self.__gaussDict['sigma2'][0] -
self.__gaussDict['sigma1'][0]) / 2.355)
quadratic = Model(quadratic_fitting_function,
name='continuum_fitting_function')
gauss_model = gauss + quadratic
slope = calculate_slope(self.__gaussDict['left'][0],
self.__gaussDict['left'][1],
self.__gaussDict['right'][0],
self.__gaussDict['right'][1])
params = gauss_model.make_params(
h=self.__gaussDict['top'][1] -
(self.__gaussDict['left'][1] + self.__gaussDict['right'][1]) /
2.,
c=self.__gaussDict['top'][0],
sigma=abs(self.__gaussDict['sigma2'][1] -
self.__gaussDict['sigma1'][1]) / 2.355,
a=calculate_intercept(slope, self.__gaussDict['left'][0],
self.__gaussDict['left'][1]),
b=slope,
c2=1.)
init = gauss_model.eval(params, x=wavelengthValues)
result = gauss_model.fit(fluxValues, params, x=wavelengthValues)
#Update table of results parameters
resultText = "Path: {}".format(path)
resultText = resultText + "\n" + \
"Gauss model: {} * e ** ((x-{})**2/(-2*{}**2))".format(str(result.params['h'].value), str(result.params['c'].value), str(result.params['sigma'].value))
resultText = resultText + "\n" + "Quadratic model: {} + {} * x + {}*x**2".format(
str(result.params['a'].value), str(result.params['b'].value),
str(result.params['c2'].value))
resultText = resultText + "\n" + "Gaussian integrated flux : " + " = " + str(
integrated_flux(result.params['h'].value,
result.params['sigma'].value, 'gauss'))
gaussFitResultList = [
key + " = " + str(result.params[key].value)
for key in result.params
]
for resultParams in gaussFitResultList:
resultText = resultText + "\n" + resultParams
resultText = resultText + "\n" + "Chi-square" + " = " + str(
result.chisqr)
return result, resultText, wavelengthValues, fluxValues, inital_y_values, None