Added chi2 to fit results (#131)

- fit_gaus and fit_pol1 now return a dict
- calculate chi2 after fit
- cleaned up code

python/CMakeLists.txt

@@ -49,11 +49,10 @@ set(PYTHON_EXAMPLES
     examples/fits.py
 )
 
-
-
 # Copy the python examples to the build directory
 foreach(FILE ${PYTHON_EXAMPLES})
     configure_file(${FILE} ${CMAKE_BINARY_DIR}/${FILE}  )
+    message(STATUS "Copying ${FILE} to ${CMAKE_BINARY_DIR}/${FILE}")
 endforeach(FILE ${PYTHON_EXAMPLES})
 
 

python/examples/play.py

@@ -8,61 +8,15 @@ import numpy as np
 import boost_histogram as bh
 import time
 
-<<<<<<< HEAD
-from aare import File, ClusterFinder, VarClusterFinder, ClusterFile, CtbRawFile
-from aare import gaus, fit_gaus
+import aare
 
-base = Path('/mnt/sls_det_storage/moench_data/Julian/MOENCH05/20250113_first_xrays_redo/raw_files/')
-cluster_file = Path('/home/l_msdetect/erik/tmp/Cu.clust')
+data = np.random.normal(10, 1, 1000)
 
-t0 = time.perf_counter()
-offset= -0.5
-hist3d = bh.Histogram(
-    bh.axis.Regular(160, 0+offset, 160+offset),  #x
-    bh.axis.Regular(150, 0+offset, 150+offset),  #y
-    bh.axis.Regular(200, 0, 6000), #ADU
-)
+hist = bh.Histogram(bh.axis.Regular(10, 0, 20))
+hist.fill(data)
 
-total_clusters = 0
-with ClusterFile(cluster_file, chunk_size = 1000) as f:
-    for i, clusters in enumerate(f):
-        arr = np.array(clusters)
-        total_clusters += clusters.size
-        hist3d.fill(arr['y'],arr['x'], clusters.sum_2x2()) #python talks [row, col] cluster finder [x,y]
-=======
-from aare import RawFile
-
-f = RawFile('/mnt/sls_det_storage/jungfrau_data1/vadym_tests/jf12_M431/laser_scan/laserScan_pedestal_G0_master_0.json')
-
-print(f'{f.frame_number(1)}')
-
-for i in range(10):
-    header, img = f.read_frame()
-    print(header['frameNumber'], img.shape)
->>>>>>> developer
-
-        
-t_elapsed = time.perf_counter()-t0
-print(f'Histogram filling took: {t_elapsed:.3f}s {total_clusters/t_elapsed/1e6:.3f}M clusters/s')
-
-histogram_data = hist3d.counts()
-x = hist3d.axes[2].edges[:-1]
-
-y = histogram_data[100,100,:]
-xx = np.linspace(x[0], x[-1])
-# fig, ax = plt.subplots()
-# ax.step(x, y, where = 'post')
-
-y_err = np.sqrt(y)
-y_err = np.zeros(y.size)
-y_err += 1
-
-# par = fit_gaus2(y,x, y_err)
-# ax.plot(xx, gaus(xx,par))
-# print(par)
-
-res = fit_gaus(y,x)
-res2 = fit_gaus(y,x, y_err)
-print(res)
-print(res2)
 
+x = hist.axes[0].centers
+y = hist.values()
+y_err = np.sqrt(y)+1
+res = aare.fit_gaus(x, y, y_err, chi2 = True)

python/src/fit.hpp

@@ -7,6 +7,7 @@
 #include "aare/Fit.hpp"
 
 namespace py = pybind11;
+using namespace pybind11::literals;
 
 void define_fit_bindings(py::module &m) {
 
@@ -29,7 +30,8 @@ void define_fit_bindings(py::module &m) {
             The points at which to evaluate the Gaussian function.
         par : array_like
             The parameters of the Gaussian function. The first element is the amplitude, the second element is the mean, and the third element is the standard deviation.
-        )", py::arg("x"), py::arg("par"));
+        )",
+        py::arg("x"), py::arg("par"));
 
     m.def(
         "pol1",
@@ -49,7 +51,8 @@ void define_fit_bindings(py::module &m) {
             The points at which to evaluate the polynomial function.
         par : array_like
             The parameters of the polynomial function. The first element is the intercept, and the second element is the slope.    
-        )", py::arg("x"), py::arg("par"));
+        )",
+        py::arg("x"), py::arg("par"));
 
     m.def(
         "fit_gaus",
@@ -72,7 +75,7 @@ void define_fit_bindings(py::module &m) {
                 throw std::runtime_error("Data must be 1D or 3D");
             }
         },
-R"(
+        R"(
 Fit a 1D Gaussian to data.
 
 Parameters
@@ -90,8 +93,8 @@ n_threads : int, optional
         "fit_gaus",
         [](py::array_t<double, py::array::c_style | py::array::forcecast> x,
            py::array_t<double, py::array::c_style | py::array::forcecast> y,
-           py::array_t<double, py::array::c_style | py::array::forcecast>
-               y_err, int n_threads) {
+           py::array_t<double, py::array::c_style | py::array::forcecast> y_err,
+           int n_threads) {
             if (y.ndim() == 3) {
                 // Allocate memory for the output
                 // Need to have pointers to allow python to manage
@@ -99,15 +102,20 @@ n_threads : int, optional
                 auto par = new NDArray<double, 3>({y.shape(0), y.shape(1), 3});
                 auto par_err =
                     new NDArray<double, 3>({y.shape(0), y.shape(1), 3});
+                auto chi2 = new NDArray<double, 2>({y.shape(0), y.shape(1)});
 
+                // Make views of the numpy arrays
                 auto y_view = make_view_3d(y);
                 auto y_view_err = make_view_3d(y_err);
                 auto x_view = make_view_1d(x);
+
                 aare::fit_gaus(x_view, y_view, y_view_err, par->view(),
-                               par_err->view(), n_threads);
-                // return return_image_data(par);
-                return py::make_tuple(return_image_data(par),
-                                      return_image_data(par_err));
+                               par_err->view(), chi2->view(), n_threads);
+
+                return py::dict("par"_a = return_image_data(par),
+                                "par_err"_a = return_image_data(par_err),
+                                "chi2"_a = return_image_data(chi2),
+                                "Ndf"_a = y.shape(2) - 3);
             } else if (y.ndim() == 1) {
                 // Allocate memory for the output
                 // Need to have pointers to allow python to manage
@@ -120,15 +128,20 @@ n_threads : int, optional
                 auto y_view_err = make_view_1d(y_err);
                 auto x_view = make_view_1d(x);
 
+
+                double chi2 = 0;
                 aare::fit_gaus(x_view, y_view, y_view_err, par->view(),
-                               par_err->view());
-                return py::make_tuple(return_image_data(par),
-                                      return_image_data(par_err));
+                               par_err->view(), chi2);
+
+                return py::dict("par"_a = return_image_data(par),
+                                "par_err"_a = return_image_data(par_err),
+                                "chi2"_a = chi2, "Ndf"_a = y.size() - 3);
+
             } else {
                 throw std::runtime_error("Data must be 1D or 3D");
             }
         },
-R"(
+        R"(
 Fit a 1D Gaussian to data with error estimates.
 
 Parameters
@@ -172,11 +185,10 @@ n_threads : int, optional
         "fit_pol1",
         [](py::array_t<double, py::array::c_style | py::array::forcecast> x,
            py::array_t<double, py::array::c_style | py::array::forcecast> y,
-           py::array_t<double, py::array::c_style | py::array::forcecast>
-               y_err, int n_threads) {
+           py::array_t<double, py::array::c_style | py::array::forcecast> y_err,
+           int n_threads) {
             if (y.ndim() == 3) {
-                auto par =
-                    new NDArray<double, 3>({y.shape(0), y.shape(1), 2});
+                auto par = new NDArray<double, 3>({y.shape(0), y.shape(1), 2});
                 auto par_err =
                     new NDArray<double, 3>({y.shape(0), y.shape(1), 2});
 
@@ -184,10 +196,15 @@ n_threads : int, optional
                 auto y_view_err = make_view_3d(y_err);
                 auto x_view = make_view_1d(x);
 
-                aare::fit_pol1(x_view, y_view,y_view_err, par->view(),
-                               par_err->view(), n_threads);
-                return py::make_tuple(return_image_data(par),
-                                      return_image_data(par_err));
+                auto chi2 = new NDArray<double, 2>({y.shape(0), y.shape(1)});
+
+                aare::fit_pol1(x_view, y_view, y_view_err, par->view(),
+                               par_err->view(), chi2->view(), n_threads);
+                return py::dict("par"_a = return_image_data(par),
+                                "par_err"_a = return_image_data(par_err), 
+                                "chi2"_a = return_image_data(chi2),
+                                "Ndf"_a = y.shape(2) - 2);
+
 
             } else if (y.ndim() == 1) {
                 auto par = new NDArray<double, 1>({2});
@@ -197,15 +214,18 @@ n_threads : int, optional
                 auto y_view_err = make_view_1d(y_err);
                 auto x_view = make_view_1d(x);
 
+                double chi2 = 0;
+
                 aare::fit_pol1(x_view, y_view, y_view_err, par->view(),
-                               par_err->view());
-                return py::make_tuple(return_image_data(par),
-                                      return_image_data(par_err));
+                               par_err->view(), chi2);
+                return py::dict("par"_a = return_image_data(par),
+                                "par_err"_a = return_image_data(par_err),
+                                "chi2"_a = chi2, "Ndf"_a = y.size() - 2);
             } else {
                 throw std::runtime_error("Data must be 1D or 3D");
             }
         },
-R"(
+        R"(
 Fit a 1D polynomial to data with error estimates.
 
 Parameters