Interpolate (#137)

- added eta based interpolation

include/aare/ClusterFile.hpp

@@ -8,11 +8,17 @@
 
 namespace aare {
 
+//TODO! Template this? 
 struct Cluster3x3 {
     int16_t x;
     int16_t y;
     int32_t data[9];
 };
+struct Cluster2x2 {
+    int16_t x;
+    int16_t y;
+    int32_t data[4];
+};
 
 typedef enum {
     cBottomLeft = 0,
@@ -37,6 +43,7 @@ struct Eta2 {
     double x;
     double y;
     corner c;
+    int32_t sum;
 };
 
 struct ClusterAnalysis {
@@ -97,6 +104,8 @@ class ClusterFile {
      */
     ClusterVector<int32_t> read_clusters(size_t n_clusters);
 
+    ClusterVector<int32_t> read_clusters(size_t n_clusters, ROI roi);
+
     /**
      * @brief Read a single frame from the file and return the clusters. The
      * cluster vector will have the frame number set.
@@ -131,5 +140,6 @@ int analyze_cluster(Cluster3x3 &cl, int32_t *t2, int32_t *t3, char *quad,
 
 NDArray<double, 2> calculate_eta2(ClusterVector<int> &clusters);
 Eta2 calculate_eta2(Cluster3x3 &cl);
+Eta2 calculate_eta2(Cluster2x2 &cl);
 
 } // namespace aare

include/aare/ClusterVector.hpp

@@ -231,6 +231,10 @@ template <typename T, typename CoordType = int16_t> class ClusterVector {
         return *reinterpret_cast<V *>(element_ptr(i));
     }
 
+    template <typename V> const V &at(size_t i) const {
+        return *reinterpret_cast<const V *>(element_ptr(i));
+    }
+
     const std::string_view fmt_base() const {
         // TODO! how do we match on coord_t?
         return m_fmt_base;

include/aare/Interpolator.hpp

@@ -0,0 +1,29 @@
+#pragma once
+#include "aare/NDArray.hpp"
+#include "aare/NDView.hpp"
+#include "aare/ClusterVector.hpp"
+#include "aare/ClusterFile.hpp" //Cluster_3x3
+namespace aare{
+
+struct Photon{
+    double x;
+    double y;
+    double energy;
+};
+
+class Interpolator{
+    NDArray<double, 3> m_ietax;
+    NDArray<double, 3> m_ietay;
+
+    NDArray<double, 1> m_etabinsx;
+    NDArray<double, 1> m_etabinsy;
+    NDArray<double, 1> m_energy_bins;
+    public:
+        Interpolator(NDView<double, 3> etacube, NDView<double, 1> xbins, NDView<double, 1> ybins, NDView<double, 1> ebins);
+        NDArray<double, 3> get_ietax(){return m_ietax;}
+        NDArray<double, 3> get_ietay(){return m_ietay;}
+
+        std::vector<Photon> interpolate(const ClusterVector<int32_t>& clusters);
+};
+
+} // namespace aare

include/aare/NDArray.hpp

@@ -102,6 +102,9 @@ class NDArray : public ArrayExpr<NDArray<T, Ndim>, Ndim> {
     auto begin() { return data_; }
     auto end() { return data_ + size_; }
 
+    auto begin() const { return data_; }
+    auto end() const { return data_ + size_; }
+
     using value_type = T;
 
     NDArray &operator=(NDArray &&other) noexcept; // Move assign

include/aare/algorithm.hpp

@@ -0,0 +1,55 @@
+
+#pragma once
+#include <algorithm>
+#include <array>
+#include <vector>
+#include <aare/NDArray.hpp>
+
+namespace aare {
+/**
+ * @brief Find the index of the last element smaller than val
+ * assume a sorted array
+ */
+template <typename T>
+size_t last_smaller(const T* first, const T* last, T val) {
+    for (auto iter = first+1; iter != last; ++iter) {
+        if (*iter > val) {
+            return std::distance(first, iter-1);
+        }
+    }
+    return std::distance(first, last-1);
+}
+
+template <typename T>
+size_t last_smaller(const NDArray<T, 1>& arr, T val) {
+    return last_smaller(arr.begin(), arr.end(), val);
+}
+
+
+template <typename T>
+size_t nearest_index(const T* first, const T* last, T val) {
+    auto iter = std::min_element(first, last,
+    [val](T a, T b) {
+        return std::abs(a - val) < std::abs(b - val);
+    });
+    return std::distance(first, iter);
+}
+
+template <typename T>
+size_t nearest_index(const NDArray<T, 1>& arr, T val) {
+    return nearest_index(arr.begin(), arr.end(), val);
+}
+
+template <typename T>
+size_t nearest_index(const std::vector<T>& vec, T val) {
+    return nearest_index(vec.data(), vec.data()+vec.size(), val);
+}
+
+template <typename T, size_t N>
+size_t nearest_index(const std::array<T,N>& arr, T val) {
+    return nearest_index(arr.data(), arr.data()+arr.size(), val);
+}
+
+
+
+} // namespace aare