essentially done with lmfit as fitter

	modified:   src/egui_plot_stuff/egui_line.rs
	modified:   src/fitter/common.rs
	modified:   src/fitter/fit_handler.rs
	modified:   src/fitter/fit_settings.rs
	modified:   src/fitter/main_fitter.rs
	modified:   src/fitter/models/exponential.rs
	modified:   src/fitter/models/gaussian.rs
	modified:   src/fitter/models/linear.rs
	modified:   src/fitter/models/mod.rs
	modified:   src/fitter/models/powerlaw.rs
	modified:   src/fitter/models/quadratic.rs
	modified:   src/histoer/histo1d/histogram1d.rs
	modified:   src/histogram_scripter/manual_histogram_script.rs
	renamed:    lmfit_test.py -> tests/lmfit_test.py

Author: alconley

src/egui_plot_stuff/egui_line.rs

@@ -61,9 +61,10 @@ impl EguiLine {
     }
 
     pub fn new_with_points(points: Vec<[f64; 2]>) -> Self {
-        let mut line = EguiLine::default();
-        line.points = points;
-        line
+        EguiLine {
+            points,
+            ..EguiLine::default()
+        }
     }
 
     pub fn clear_points(&mut self) {

src/fitter/common.rs

@@ -1,4 +1,4 @@
-#[derive(PartialEq, Debug, Clone, serde::Deserialize, serde::Serialize)]
+#[derive(PartialEq, Default, Debug, Clone, serde::Deserialize, serde::Serialize)]
 pub struct Data {
     pub x: Vec<f64>,
     pub y: Vec<f64>,
@@ -12,7 +12,7 @@ pub struct Parameter {
     pub initial_guess: f64,
     pub vary: bool,
     pub value: Option<f64>,
-    pub uncertainity: Option<f64>,
+    pub uncertainty: Option<f64>,
 }
 
 impl Default for Parameter {
@@ -24,7 +24,7 @@ impl Default for Parameter {
             initial_guess: 0.0,
             vary: true,
             value: None,
-            uncertainity: None,
+            uncertainty: None,
         }
     }
 }
@@ -62,7 +62,7 @@ impl Parameter {
         if let Some(value) = self.value {
             ui.separator();
             ui.label(format!("{:.3}", value));
-            ui.label(format!("{:.3}", self.uncertainity.unwrap_or(0.0)));
+            ui.label(format!("{:.3}", self.uncertainty.unwrap_or(0.0)));
         }
     }
 }

src/fitter/fit_handler.rs

@@ -171,18 +171,21 @@ impl Fits {
                 ui.label("Mean");
                 ui.label("FWHM");
                 ui.label("Area");
+                ui.label("Amplitude");
+                ui.label("Sigma");
+
                 ui.end_row();
 
                 if self.temp_fit.is_some() {
-                    ui.label("Current");
+                    ui.label("Temp");
 
-                    // if let Some(temp_fit) = &self.temp_fit {
-                    //     temp_fit.fitter_stats(ui);
-                    // }
+                    if let Some(temp_fit) = &mut self.temp_fit {
+                        temp_fit.fitter_stats(ui, true);
+                    }
                 }
 
                 if !self.stored_fits.is_empty() {
-                    for (i, fit) in self.stored_fits.iter().enumerate() {
+                    for (i, fit) in self.stored_fits.iter_mut().enumerate() {
                         ui.horizontal(|ui| {
                             ui.label(format!("{}", i));
 
@@ -194,7 +197,7 @@ impl Fits {
 
                             ui.separator();
                         });
-                        // fit.fitter_stats(ui);
+                        fit.fitter_stats(ui, true);
                     }
                 }
             });
@@ -236,6 +239,10 @@ impl Fits {
             if let Some(temp_fit) = &mut self.temp_fit {
                 temp_fit.fit_result_ui(ui);
             }
+
+            for fit in &mut self.stored_fits {
+                fit.fit_result_ui(ui);
+            }
         });
     }
 }

src/fitter/fit_settings.rs

@@ -59,29 +59,8 @@ impl FitSettings {
         ui.separator();
 
         ui.horizontal(|ui| {
-            ui.label("Show Fit Lines: ");
-            ui.checkbox(&mut self.show_decomposition, "Decomposition")
-                .on_hover_text("Show the decomposition peaks");
-            ui.checkbox(&mut self.show_composition, "Composition")
-                .on_hover_text("Show the composition line");
-            ui.checkbox(&mut self.show_background, "Background")
-                .on_hover_text("Show the background line");
-        });
+            ui.label("Background Models");
 
-        ui.separator();
-
-        ui.heading("Gaussian Fit Settings");
-        ui.horizontal(|ui| {
-            ui.checkbox(&mut self.equal_stddev, "Equal Standard Deviation")
-                .on_hover_text("Allow the standard deviation of the Gaussian to be free");
-            ui.checkbox(&mut self.free_position, "Free Position")
-                .on_hover_text("Allow the position of the Gaussian to be free");
-        });
-
-        ui.separator();
-
-        ui.heading("Background Models");
-        ui.horizontal(|ui| {
             ui.radio_value(
                 &mut self.background_model,
                 BackgroundModel::Linear(self.linear_params.clone()),
@@ -126,5 +105,27 @@ impl FitSettings {
         }
 
         ui.separator();
+
+        ui.horizontal(|ui| {
+            ui.label("Gaussian Fit Settings");
+            ui.checkbox(&mut self.equal_stddev, "Equal Standard Deviation")
+                .on_hover_text("Allow the standard deviation of the Gaussian to be free");
+            ui.checkbox(&mut self.free_position, "Free Position")
+                .on_hover_text("Allow the position of the Gaussian to be free");
+        });
+
+        ui.separator();
+
+        ui.horizontal(|ui| {
+            ui.label("Show Fit Lines: ");
+            ui.checkbox(&mut self.show_decomposition, "Decomposition")
+                .on_hover_text("Show the decomposition peaks");
+            ui.checkbox(&mut self.show_composition, "Composition")
+                .on_hover_text("Show the composition line");
+            ui.checkbox(&mut self.show_background, "Background")
+                .on_hover_text("Show the background line");
+        });
+
+        ui.separator();
     }
 }

src/fitter/main_fitter.rs

@@ -1,10 +1,10 @@
-use crate::egui_plot_stuff::egui_line::EguiLine;
-use super::models::gaussian::{GaussianFitter};
 use super::common::Data;
 use super::models::exponential::{ExponentialFitter, ExponentialParameters};
+use super::models::gaussian::GaussianFitter;
 use super::models::linear::{LinearFitter, LinearParameters};
 use super::models::powerlaw::{PowerLawFitter, PowerLawParameters};
 use super::models::quadratic::{QuadraticFitter, QuadraticParameters};
+use crate::egui_plot_stuff::egui_line::EguiLine;
 
 #[derive(Debug, Clone, serde::Deserialize, serde::Serialize, PartialEq)]
 pub enum FitModel {
@@ -34,6 +34,17 @@ pub enum BackgroundResult {
     Exponential(ExponentialFitter),
 }
 
+impl BackgroundResult {
+    pub fn get_fit_points(&self) -> Vec<[f64; 2]> {
+        match self {
+            BackgroundResult::Linear(fit) => fit.fit_points.clone(),
+            BackgroundResult::Quadratic(fit) => fit.fit_points.clone(),
+            BackgroundResult::PowerLaw(fit) => fit.fit_points.clone(),
+            BackgroundResult::Exponential(fit) => fit.fit_points.clone(),
+        }
+    }
+}
+
 #[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
 pub struct Fitter {
     pub name: String,
@@ -66,12 +77,12 @@ impl Fitter {
             fit_result: None,
 
             background_line: EguiLine::new(egui::Color32::GREEN),
-            composition_line: EguiLine::new(egui::Color32::DARK_BLUE),
+            composition_line: EguiLine::new(egui::Color32::BLUE),
             decomposition_lines: Vec::new(),
         }
     }
 
-    pub fn fit(&mut self){
+    pub fn fit(&mut self) {
         match &self.fit_model {
             FitModel::Gaussian(peak_markers, equal_stdev, free_position, bin_width) => {
                 let mut fit = GaussianFitter::new(
@@ -87,6 +98,19 @@ impl Fitter {
                 match fit.lmfit() {
                     Ok(_) => {
                         self.composition_line.points = fit.fit_points.clone();
+                        for fit in &fit.fit_result {
+                            let mut line = EguiLine::new(egui::Color32::from_rgb(150, 0, 255));
+                            line.points = fit.fit_points.clone();
+                            self.decomposition_lines.push(line);
+                        }
+
+                        if self.background_result.is_none() {
+                            if let Some(background_result) = &fit.background_result {
+                                self.background_line.points = background_result.get_fit_points();
+                                self.background_result = Some(background_result.clone());
+                            }
+                        }
+
                         self.fit_result = Some(FitResult::Gaussian(fit));
                     }
                     Err(e) => {
@@ -98,7 +122,7 @@ impl Fitter {
                 log::info!("No fitting required for 'None'");
             }
         }
-    } 
+    }
 
     pub fn fit_background(&mut self) {
         log::info!("Fitting background");
@@ -178,6 +202,20 @@ impl Fitter {
         log::info!("Finished fitting background");
     }
 
+    pub fn get_peak_markers(&self) -> Vec<f64> {
+        if self.fit_result.is_none() {
+            match &self.fit_model {
+                FitModel::Gaussian(peak_markers, _, _, _) => peak_markers.clone(),
+                FitModel::None => Vec::new(),
+            }
+        } else {
+            match &self.fit_result {
+                Some(FitResult::Gaussian(fit)) => fit.peak_markers.clone(),
+                None => Vec::new(),
+            }
+        }
+    }
+
     pub fn set_background_color(&mut self, color: egui::Color32) {
         self.background_line.color = color;
     }
@@ -214,21 +252,14 @@ impl Fitter {
         }
 
         self.background_line.name = format!("{}-Background", name);
+        self.name = name;
     }
 
     pub fn fit_result_ui(&mut self, ui: &mut egui::Ui) {
         ui.collapsing(self.name.clone(), |ui| {
             egui::ScrollArea::vertical()
                 .min_scrolled_height(300.0)
                 .show(ui, |ui| {
-                    if let Some(fit_result) = &self.fit_result {
-                        self.composition_line.menu_button(ui);
-                    }
-
-                    for line in &mut self.decomposition_lines {
-                        line.menu_button(ui);
-                    }
-
                     ui.separator();
 
                     if let Some(background_result) = &self.background_result {
@@ -252,10 +283,43 @@ impl Fitter {
                             self.background_line.menu_button(ui);
                         });
                     }
+
+                    if self.fit_result.is_some() {
+                        egui::Grid::new("fit_params_grid")
+                            .striped(true)
+                            .show(ui, |ui| {
+                                ui.label("Peak");
+                                ui.label("Mean");
+                                ui.label("FWHM");
+                                ui.label("Area");
+                                ui.label("Amplitude");
+                                ui.label("Sigma");
+
+                                ui.end_row();
+
+                                self.fitter_stats(ui, false);
+                            });
+
+                        for line in &mut self.decomposition_lines {
+                            line.menu_button(ui);
+                        }
+
+                        self.composition_line.menu_button(ui);
+                    }
                 });
         });
     }
 
+    pub fn fitter_stats(&mut self, ui: &mut egui::Ui, skip_one: bool) {
+        if let Some(fit_result) = &self.fit_result {
+            match fit_result {
+                FitResult::Gaussian(fit) => {
+                    fit.fit_params_ui(ui, skip_one);
+                }
+            }
+        }
+    }
+
     // Draw the background, decomposition, and composition lines
     pub fn draw(&self, plot_ui: &mut egui_plot::PlotUi) {
         for line in &self.decomposition_lines {

src/fitter/models/exponential.rs

@@ -16,6 +16,7 @@ impl Default for ExponentialParameters {
             },
             decay: Parameter {
                 name: "decay".to_string(),
+                initial_guess: 500.0,
                 ..Default::default()
             },
         }
@@ -66,6 +67,39 @@ impl ExponentialFitter {
         }
     }
 
+    pub fn new_from_parameters(
+        amplitude: (f64, f64),
+        decay: (f64, f64),
+        min_x: f64,
+        max_x: f64,
+    ) -> Self {
+        let mut fitter = ExponentialFitter {
+            data: Data::default(),
+            paramaters: ExponentialParameters::default(),
+            fit_points: Vec::new(),
+            fit_report: "Fitter with other model".to_string(),
+        };
+
+        // Set the parameter values and uncertainties
+        fitter.paramaters.amplitude.value = Some(amplitude.0);
+        fitter.paramaters.amplitude.uncertainty = Some(amplitude.1);
+        fitter.paramaters.decay.value = Some(decay.0);
+        fitter.paramaters.decay.uncertainty = Some(decay.1);
+
+        // Optionally generate fit points based on the x-range (min_x to max_x)
+        let num_points = 100;
+        let step_size = (max_x - min_x) / (num_points as f64);
+        fitter.fit_points.clear();
+        for i in 0..=num_points {
+            let x = min_x + i as f64 * step_size;
+            let y = fitter.paramaters.amplitude.value.unwrap_or(1.0)
+                * (-x / fitter.paramaters.decay.value.unwrap_or(1.0)).exp();
+            fitter.fit_points.push([x, y]);
+        }
+
+        fitter
+    }
+
     pub fn lmfit(&mut self) -> PyResult<()> {
         log::info!("Fitting data with a Exponential line using `lmfit`.");
         Python::with_gil(|py| {
@@ -177,9 +211,9 @@ def ExponentialFit(x_data: list, y_data: list, amplitude: list = ("amplitude", -
             let fit_report = result.get_item(3)?.extract::<String>()?;
 
             self.paramaters.amplitude.value = Some(params[0].1);
-            self.paramaters.amplitude.uncertainity = Some(params[0].2);
+            self.paramaters.amplitude.uncertainty = Some(params[0].2);
             self.paramaters.decay.value = Some(params[1].1);
-            self.paramaters.decay.uncertainity = Some(params[1].2);
+            self.paramaters.decay.uncertainty = Some(params[1].2);
 
             self.fit_points = x.iter().zip(y.iter()).map(|(&x, &y)| [x, y]).collect();
             self.fit_report = fit_report;
@@ -195,15 +229,15 @@ def ExponentialFit(x_data: list, y_data: list, amplitude: list = ("amplitude", -
                 ui.label(format!(
                     "amplitude: {:.3} ± {:.3}",
                     amplitude,
-                    self.paramaters.amplitude.uncertainity.unwrap_or(0.0)
+                    self.paramaters.amplitude.uncertainty.unwrap_or(0.0)
                 ));
             }
             ui.separator();
             if let Some(decay) = &self.paramaters.decay.value {
                 ui.label(format!(
                     "decay: {:.3} ± {:.3}",
                     decay,
-                    self.paramaters.decay.uncertainity.unwrap_or(0.0)
+                    self.paramaters.decay.uncertainty.unwrap_or(0.0)
                 ));
             }
             ui.separator();