implemented multi gaussian for n=3, changed some var names

Author: LAKESIDE\LindaT18

PythonGUI_apps/Spectrum_analysis/Spectra_fit_funcs.py

@@ -56,12 +56,20 @@ def gaussian_model(self):
         result = gmodel.fit(y, pars, x=x, nan_policy='propagate')
         return result
 
-    def gaussian_model_w_lims(self, center_initial_guess=None, sigma_initial_guess=None, center_min=None, center_max=None):
+    # def gaussian_model_w_lims(self, center_initial_guess=None, sigma_initial_guess=None, center_min=None, center_max=None):
+    #     x,y = self.background_correction()
+    #     gmodel = GaussianModel(prefix = 'g1_') # calling gaussian model
+    #     pars = gmodel.guess(y, x=x) # parameters - center, width, height
+    #     pars['g1_center'].set(center_initial_guess, min=center_min, max=center_max)
+    #     pars['g1_sigma'].set(sigma_initial_guess)
+    #     result = gmodel.fit(y, pars, x=x, nan_policy='propagate')
+    #     return result #770 760 780   sigma 15 
+    def gaussian_model_w_lims(self, peak_pos, sigma, min_max_range):
         x,y = self.background_correction()
         gmodel = GaussianModel(prefix = 'g1_') # calling gaussian model
         pars = gmodel.guess(y, x=x) # parameters - center, width, height
-        pars['g1_center'].set(center_initial_guess, min=center_min, max=center_max)
-        pars['g1_sigma'].set(sigma_initial_guess)
+        pars['g1_center'].set(peak_pos, min=min_max_range[0], max=min_max_range[1])
+        pars['g1_sigma'].set(sigma)
         result = gmodel.fit(y, pars, x=x, nan_policy='propagate')
         return result #770 760 780   sigma 15 
 
@@ -88,12 +96,12 @@ def lorentzian_model(self):
     #     result = lmodel.fit(y, pars, x=x, nan_policy='propagate')
     #     return result
 
-    def lorentzian_model_w_lims(self, center_initial_guess=None, sigma_initial_guess=None, center_min = None, center_max = None):
+    def lorentzian_model_w_lims(self, peak_pos, sigma, min_max_range):
         x,y = self.background_correction()
         lmodel = LorentzianModel(prefix = 'l1_') # calling lorentzian model
         pars = lmodel.guess(y, x=x) # parameters - center, width, height
-        pars['l1_center'].set(center_initial_guess, min = center_min, max = center_max)
-        pars['l1_sigma'].set(sigma_initial_guess)
+        pars['l1_center'].set(peak_pos, min = min_max_range[0], max = min_max_range[1])
+        pars['l1_sigma'].set(sigma)
         result = lmodel.fit(y, pars, x=x, nan_policy='propagate')
         return result
 
@@ -118,22 +126,22 @@ def gaussian_model(self):
         result = gmodel.fit(y, pars, x=x, nan_policy='propagate')
         return result
 
-    def gaussian_model_w_lims(self, center_initial_guesses=None, sigma_initial_guesses=None, min_max_range=None):
+    def gaussian_model_w_lims(self, peak_pos, sigma, min_max_range):
         #center_initial_guesses - list containing initial guesses for peak centers. [center_guess1, center_guess2]
         #sigma_initial_guesses - list containing initial guesses for sigma. [sigma1, sigma2]
         #min_max_range - list containing lists of min and max for peak center. [ [min1, max1], [min2, max2] ] 
 
         x,y = self.background_correction()
         gmodel_1 = GaussianModel(prefix='g1_') # calling gaussian model
         pars = gmodel_1.guess(y, x=x) # parameters - center, width, height
-        pars['g1_center'].set(center_initial_guesses[0], min = min_max_range[0][0], max = min_max_range[0][1])
-        pars['g1_sigma'].set(sigma_initial_guesses[0])
+        pars['g1_center'].set(peak_pos[0], min = min_max_range[0][0], max = min_max_range[0][1])
+        pars['g1_sigma'].set(sigma[0])
         pars['g1_amplitude'].set(min=0)
 
         gmodel_2 = GaussianModel(prefix='g2_')
         pars.update(gmodel_2.make_params()) # update parameters - center, width, height
-        pars['g2_center'].set(center_initial_guesses[1], min = min_max_range[1][0], max = min_max_range[1][1])
-        pars['g2_sigma'].set(sigma_initial_guesses[1])
+        pars['g2_center'].set(peak_pos[1], min = min_max_range[1][0], max = min_max_range[1][1])
+        pars['g2_sigma'].set(sigma[1],  min = composite_pars['g1_sigma'].value)
         pars['g2_amplitude'].set(min = 0)
 
         gmodel = gmodel_1 + gmodel_2
@@ -142,13 +150,45 @@ def gaussian_model_w_lims(self, center_initial_guesses=None, sigma_initial_guess
 
 class Multi_Gaussian(Spectra_Fit):
 
-    def __init__(self, data, ref, num_of_gaussians, peak_pos, min_max_range):
-        Spectra_Fit.__init__(self, data, ref)
+    # def __init__(self, data, ref, num_of_gaussians, peak_pos, sigma, min_max_range):
+    #     Spectra_Fit.__init__(self, data, ref)
+    #     self.num_of_gaussians = num_of_gaussians
+    #     self.peak_pos = peak_pos
+    #     self.min_max_range = min_max_range
+    def __init__(self, data, ref, num_of_gaussians, wlref=None):
+        Spectra_Fit.__init__(self, data, ref, wlref)
         self.num_of_gaussians = num_of_gaussians
+
+    def gaussian_model(self):
+        composite_model = None
+        composite_pars = None
+        
+        x,y = self.background_correction()
+                
+        for i in range(self.num_of_gaussians):
+
+            model = GaussianModel(prefix='g'+str(i+1)+'_')
+
+            if composite_pars is None:
+                composite_pars = model.guess(y, x=x)
+#                 composite_pars = model.make_params()
+               
+            else:
+                composite_pars.update(model.make_params())
+
+            if composite_model is None:
+                composite_model = model
+            else:
+                composite_model += model
+        
+        result = composite_model.fit(y, composite_pars, x=x, nan_policy='propagate')
+        return result
+        
+    def gaussian_model_w_lims(self, peak_pos, sigma, min_max_range):
         self.peak_pos = peak_pos
+        self.sigma = sigma
         self.min_max_range = min_max_range
 
-    def multi_gaussian(self):
         composite_model = None
         composite_pars = None
 
@@ -167,14 +207,14 @@ def multi_gaussian(self):
 #                 composite_pars = model.make_params()
                 composite_pars['g'+str(i+1)+'_center'].set(self.peak_pos[i], 
                                                            min = self.min_max_range[0][0], max = self.min_max_range[0][1])
-                composite_pars['g'+str(i+1)+'_sigma'].set(15)
+                composite_pars['g'+str(i+1)+'_sigma'].set(self.sigma[i])
                 composite_pars['g'+str(i+1)+'_amplitude'].set(min = 0)
 
             else:
                 composite_pars.update(model.make_params())
                 composite_pars['g'+str(i+1)+'_center'].set(self.peak_pos[i],
                                                           min = self.min_max_range[i][0], max = self.min_max_range[i][1])
-                composite_pars['g'+str(i+1)+'_sigma'].set(min = composite_pars['g1_sigma'].value)
+                composite_pars['g'+str(i+1)+'_sigma'].set(self.sigma[i], min = composite_pars['g1_sigma'].value)
                 composite_pars['g'+str(i+1)+'_amplitude'].set(min = 0)
 
 

PythonGUI_apps/Spectrum_analysis/Spectra_plot_fit.py

@@ -19,9 +19,9 @@
 import customplotting.mscope as cpm
 # local modules
 try:
-	from Spectra_fit_funcs import Spectra_Fit, Single_Gaussian, Single_Lorentzian, Double_Gaussian
+	from Spectra_fit_funcs import Spectra_Fit, Single_Gaussian, Single_Lorentzian, Double_Gaussian, Multi_Gaussian
 except:
-	from Spectrum_analysis.Spectra_fit_funcs import Spectra_Fit, Single_Gaussian, Single_Lorentzian, Double_Gaussian
+	from Spectrum_analysis.Spectra_fit_funcs import Spectra_Fit, Single_Gaussian, Single_Lorentzian, Double_Gaussian, Multi_Gaussian
 
 
 """Recylce params for plotting"""
@@ -71,14 +71,15 @@ def __init__(self):
 
 		self.ui.fit_pushButton.clicked.connect(self.fit_and_plot)
 		self.ui.fit_scan_pushButton.clicked.connect(self.fit_and_plot_scan)
-		self.ui.config_fit_params_pushButton.clicked.connect(self.configure_fit_params)
+		# self.ui.config_fit_params_pushButton.clicked.connect(self.configure_fit_params)
 		self.ui.clear_pushButton.clicked.connect(self.clear_plot)
 		self.ui.export_fig_pushButton.clicked.connect(self.pub_ready_plot_export)
 
 		self.ui.import_pkl_pushButton.clicked.connect(self.open_pkl_file)
 		self.ui.data_txt_pushButton.clicked.connect(self.pkl_data_to_txt)
 		self.ui.scan_params_txt_pushButton.clicked.connect(self.pkl_params_to_txt)
 
+		self.ui.tabWidget.currentChanged.connect(self.switch_overall_tab)
 		self.ui.fitFunc_comboBox.currentTextChanged.connect(self.switch_bounds_and_guess_tab)
 		self.ui.adjust_param_checkBox.stateChanged.connect(self.switch_adjust_param)
 
@@ -173,6 +174,17 @@ def save_file(self):# not used yet!
 		except:
 			pass
 
+	def switch_overall_tab(self):
+		if self.ui.tabWidget.currentIndex() == 0:
+			self.ui.fitting_settings_groupBox.setEnabled(True)
+			self.ui.scan_fit_settings_groupBox.setEnabled(False)
+		elif self.ui.tabWidget.currentIndex() == 1:
+			self.ui.fitting_settings_groupBox.setEnabled(False)
+			self.ui.scan_fit_settings_groupBox.setEnabled(True)
+		elif self.ui.tabWidget.currentIndex() == 2:
+			self.ui.fitting_settings_groupBox.setEnabled(False)
+			self.ui.scan_fit_settings_groupBox.setEnabled(False)
+
 	def switch_bounds_and_guess_tab(self):
 		fit_func = self.ui.fitFunc_comboBox.currentText()
 		if fit_func == "Single Gaussian" or fit_func == "Single Lorentzian":
@@ -345,9 +357,9 @@ def clear_check(self):
 			return False
 
 	"""Open param window and get peak center range values and assign it to variables to use later"""
-	def configure_fit_params(self):
-		self.param_window = ParamWindow()
-		self.param_window.peak_range.connect(self.peak_range)
+	# def configure_fit_params(self):
+	# 	self.param_window = ParamWindow()
+	# 	self.param_window.peak_range.connect(self.peak_range)
 
 	def peak_range(self, peaks):
 		self.center_min = peaks[0]
@@ -373,8 +385,8 @@ def fit_and_plot(self):
 						center1_max = self.ui.single_peakcenter1_max_spinBox.value()
 						center1_guess = self.ui.single_peakcenter1_guess_spinBox.value()
 						sigma1_guess = self.ui.single_sigma1_guess_spinBox.value()
-						self.result = single_gauss.gaussian_model_w_lims(center_initial_guess=center1_guess, sigma_initial_guess=sigma1_guess,
-							center_min=center1_min, center_max=center1_max)
+						self.result = single_gauss.gaussian_model_w_lims(center1_guess, sigma1_guess,
+							[center1_min, center1_max])
 					else:
 						self.result = single_gauss.gaussian_model()
 					self.ui.plot.plot(self.x, self.y, clear=self.clear_check(), pen='r')
@@ -389,16 +401,15 @@ def fit_and_plot(self):
 						center1_max = self.ui.single_peakcenter1_max_spinBox.value()
 						center1_guess = self.ui.single_peakcenter1_guess_spinBox.value()
 						sigma1_guess = self.ui.single_sigma1_guess_spinBox.value()
-						self.result = single_lorentzian.lorentzian_model_w_lims(center_initial_guess=center1_guess, sigma_initial_guess=sigma1_guess,
-								center_min = center1_min, center_max = center1_max)
+						self.result = single_lorentzian.lorentzian_model_w_lims(center1_guess, sigma1_guess,
+								[center1_min, center1_max])
 					else:
 						self.result = single_lorentzian.lorentzian_model()
 					self.ui.plot.plot(self.x, self.y, clear=self.clear_check(), pen='r')
 					self.ui.plot.plot(self.x, self.result.best_fit, clear=False, pen='k')
 					self.ui.result_textBrowser.setText(self.result.fit_report())
 
 				elif fit_func == "Double Gaussian" and self.ui.subtract_bck_checkBox.isChecked() == True:
-					self.ui.result_textBrowser.setText("Not Implemented Yet!")
 					double_gauss = Double_Gaussian(self.file, self.bck_file, wlref=self.wlref_file)
 					if self.ui.adjust_param_checkBox.isChecked():
 						center1_min = self.ui.double_peakcenter1_min_spinBox.value()
@@ -410,8 +421,10 @@ def fit_and_plot(self):
 						center2_guess = self.ui.double_peakcenter2_guess_spinBox.value()
 						sigma2_guess = self.ui.double_sigma2_guess_spinBox.value()
 
-						self.result = double_gauss.gaussian_model_w_lims(center_initial_guesses=[center1_guess, center2_guess], 
-							sigma_initial_guesses=[sigma1_guess, sigma2_guess], min_max_range=[ [center1_min, center1_max], [center2_min, center2_max]])
+						peak_pos = [center1_guess, center2_guess]
+						sigma = [sigma1_guess, sigma2_guess]
+						min_max_range = [ [center1_min, center1_max], [center2_min, center2_max] ]
+						self.result = double_gauss.gaussian_model_w_lims(peak_pos, sigma, min_max_range)
 
 					else:
 						self.result = double_gauss.gaussian_model()
@@ -426,7 +439,39 @@ def fit_and_plot(self):
 					self.ui.result_textBrowser.setText(self.result.fit_report())
 
 				elif fit_func == "Multiple Gaussians" and self.ui.subtract_bck_checkBox.isChecked() == True:
-					self.ui.result_textBrowser.setText("Not Implemented Yet!")
+					#currently only works for triple gaussian (n=3)
+					multiple_gauss = Multi_Gaussian(self.file, self.bck_file, 3, wlref=self.wlref_file)
+					if self.ui.adjust_param_checkBox.isChecked():
+						center1_min = self.ui.multi_peakcenter1_min_spinBox.value()
+						center1_max = self.ui.multi_peakcenter1_max_spinBox.value()
+						center2_min = self.ui.multi_peakcenter2_min_spinBox.value()
+						center2_max = self.ui.multi_peakcenter2_max_spinBox.value()
+						center3_min = self.ui.multi_peakcenter3_min_spinBox.value()
+						center3_max = self.ui.multi_peakcenter3_max_spinBox.value()
+						center1_guess = self.ui.multi_peakcenter1_guess_spinBox.value()
+						sigma1_guess = self.ui.multi_sigma1_guess_spinBox.value()
+						center2_guess = self.ui.multi_peakcenter2_guess_spinBox.value()
+						sigma2_guess = self.ui.multi_sigma2_guess_spinBox.value()
+						center3_guess = self.ui.multi_peakcenter3_guess_spinBox.value()
+						sigma3_guess = self.ui.multi_sigma3_guess_spinBox.value()
+						num_gaussians = 3
+						peak_pos = [center1_guess, center2_guess, center3_guess]
+						sigma = [sigma1_guess, sigma2_guess, sigma3_guess]
+						min_max_range = [ [center1_min, center1_max], [center2_min, center2_max], [center3_min, center3_max] ]
+						
+						self.result = multiple_gauss.gaussian_model_w_lims(peak_pos, sigma, min_max_range)
+					else:
+						self.result = multiple_gauss.gaussian_model()
+
+					self.ui.plot.plot(self.x, self.y, clear=self.clear_check(), pen='r')
+					self.ui.plot.plot(self.x, self.result.best_fit, clear=False, pen='k')
+					if self.ui.plot_components_checkBox.isChecked():
+						comps = self.result.eval_components(x=self.x)
+						self.ui.plot.plot(self.x, comps['g1_'], pen='b', clear=False)
+						self.ui.plot.plot(self.x, comps['g2_'], pen='g', clear=False)
+						self.ui.plot.plot(self.x, comps['g3_'], pen='c', clear=False)
+					self.ui.result_textBrowser.setText(self.result.fit_report())
+
 
 		except Exception as e:
 			self.ui.result_textBrowser.setText(str(e))
@@ -571,37 +616,37 @@ def close_application(self):
 
 
 """Parameter Window GUI and Functions"""
-param_file_path = (base_path / "peak_bounds_input.ui").resolve()
+# param_file_path = (base_path / "peak_bounds_input.ui").resolve()
 
-param_uiFile = param_file_path
+# param_uiFile = param_file_path
 
-param_WindowTemplate, param_TemplateBaseClass = pg.Qt.loadUiType(param_uiFile)
+# param_WindowTemplate, param_TemplateBaseClass = pg.Qt.loadUiType(param_uiFile)
 
-class ParamWindow(param_TemplateBaseClass):
+# class ParamWindow(param_TemplateBaseClass):
 
-	peak_range = QtCore.pyqtSignal(list)
+# 	peak_range = QtCore.pyqtSignal(list)
 
-	def __init__(self):
-#        super(param_TemplateBaseClass, self).__init__()
-		param_TemplateBaseClass.__init__(self)
+# 	def __init__(self):
+# #        super(param_TemplateBaseClass, self).__init__()
+# 		param_TemplateBaseClass.__init__(self)
 
-		# Create the param window
-		self.pui = param_WindowTemplate()
-		self.pui.setupUi(self)
+# 		# Create the param window
+# 		self.pui = param_WindowTemplate()
+# 		self.pui.setupUi(self)
 
-		self.pui.pushButton.clicked.connect(self.done)
+# 		self.pui.pushButton.clicked.connect(self.done)
 
-		self.show()
+# 		self.show()
 
-	def current_peak_range(self):
-		center_min = self.pui.cent_min_doubleSpinBox.value()
-		center_max = self.pui.cent_max_doubleSpinBox.value()
-		return center_min, center_max
+# 	def current_peak_range(self):
+# 		center_min = self.pui.cent_min_doubleSpinBox.value()
+# 		center_max = self.pui.cent_max_doubleSpinBox.value()
+# 		return center_min, center_max
 
-	def done(self):
-		center_min, center_max = self.current_peak_range()
-		self.peak_range.emit([center_min, center_max])
-		self.close()
+# 	def done(self):
+# 		center_min, center_max = self.current_peak_range()
+# 		self.peak_range.emit([center_min, center_max])
+# 		self.close()
 
 """Run the Main Window"""    
 def run():