ported reading clusters (#95)

include/aare/ClusterFile.hpp

@@ -0,0 +1,59 @@
+
+
+#include "aare/defs.hpp"
+
+#include <fstream>
+
+namespace aare {
+
+struct Cluster {
+    int16_t x;
+    int16_t y;
+    int32_t data[9];
+};
+
+typedef enum {
+    cBottomLeft = 0,
+    cBottomRight = 1,
+    cTopLeft = 2,
+    cTopRight = 3
+} corner;
+
+typedef enum {
+    pBottomLeft = 0,
+    pBottom = 1,
+    pBottomRight = 2,
+    pLeft = 3,
+    pCenter = 4,
+    pRight = 5,
+    pTopLeft = 6,
+    pTop = 7,
+    pTopRight = 8
+} pixel;
+
+struct ClusterAnalysis {
+    uint32_t c;
+    int32_t tot;
+    double etax;
+    double etay;
+};
+
+class ClusterFile {
+    FILE *fp{};
+    uint32_t m_num_left{};
+
+  public:
+    ClusterFile(const std::filesystem::path &fname);
+    std::vector<Cluster> read_clusters(size_t n_clusters);
+    std::vector<Cluster>
+    read_cluster_with_cut(size_t n_clusters, double *noise_map, int nx, int ny);
+
+    int analyze_data(int32_t *data, int32_t *t2, int32_t *t3, char *quad,
+                 double *eta2x, double *eta2y, double *eta3x, double *eta3y);
+    int analyze_cluster(Cluster cl, int32_t *t2, int32_t *t3, char *quad,
+                    double *eta2x, double *eta2y, double *eta3x,
+                    double *eta3y);
+
+};
+
+} // namespace aare

include/aare/ClusterFinder.hpp

@@ -53,7 +53,7 @@ class ClusterFinder {
         return m_pedestal.mean();
     }
 
-    std::vector<Cluster>
+    std::vector<DynamicCluster>
     find_clusters_without_threshold(NDView<FRAME_TYPE, 2> frame,
                                     // Pedestal<PEDESTAL_TYPE> &pedestal,
                                     bool late_update = false) {
@@ -64,7 +64,7 @@ class ClusterFinder {
         };
         std::vector<pedestal_update> pedestal_updates;
 
-        std::vector<Cluster> clusters;
+        std::vector<DynamicCluster> clusters;
         std::vector<std::vector<eventType>> eventMask;
         for (int i = 0; i < frame.shape(0); i++) {
             eventMask.push_back(std::vector<eventType>(frame.shape(1)));
@@ -115,7 +115,7 @@ class ClusterFinder {
                 if (eventMask[iy][ix] == PHOTON &&
                     (frame(iy, ix) - m_pedestal.mean(iy, ix)) >= max) {
                     eventMask[iy][ix] = PHOTON_MAX;
-                    Cluster cluster(m_cluster_sizeX, m_cluster_sizeY,
+                    DynamicCluster cluster(m_cluster_sizeX, m_cluster_sizeY,
                                     Dtype(typeid(PEDESTAL_TYPE)));
                     cluster.x = ix;
                     cluster.y = iy;
@@ -149,11 +149,11 @@ class ClusterFinder {
     }
 
     // template <typename FRAME_TYPE, typename PEDESTAL_TYPE>
-    std::vector<Cluster>
+    std::vector<DynamicCluster>
     find_clusters_with_threshold(NDView<FRAME_TYPE, 2> frame,
                                  Pedestal<PEDESTAL_TYPE> &pedestal) {
         assert(m_threshold > 0);
-        std::vector<Cluster> clusters;
+        std::vector<DynamicCluster> clusters;
         std::vector<std::vector<eventType>> eventMask;
         for (int i = 0; i < frame.shape(0); i++) {
             eventMask.push_back(std::vector<eventType>(frame.shape(1)));
@@ -230,7 +230,7 @@ class ClusterFinder {
                 if (eventMask[iy][ix] == PHOTON &&
                     frame(iy, ix) - pedestal.mean(iy, ix) >= max) {
                     eventMask[iy][ix] = PHOTON_MAX;
-                    Cluster cluster(m_cluster_sizeX, m_cluster_sizeY,
+                    DynamicCluster cluster(m_cluster_sizeX, m_cluster_sizeY,
                                     Dtype(typeid(FRAME_TYPE)));
                     cluster.x = ix;
                     cluster.y = iy;

include/aare/defs.hpp

@@ -41,7 +41,7 @@ namespace aare {
 void assert_failed(const std::string &msg);
 
 
-class Cluster {
+class DynamicCluster {
   public:
     int cluster_sizeX;
     int cluster_sizeY;
@@ -53,36 +53,36 @@ class Cluster {
     std::byte *m_data;
 
   public:
-    Cluster(int cluster_sizeX_, int cluster_sizeY_,
+    DynamicCluster(int cluster_sizeX_, int cluster_sizeY_,
             Dtype dt_ = Dtype(typeid(int32_t)))
         : cluster_sizeX(cluster_sizeX_), cluster_sizeY(cluster_sizeY_),
           dt(dt_) {
         m_data = new std::byte[cluster_sizeX * cluster_sizeY * dt.bytes()]{};
     }
-    Cluster() : Cluster(3, 3) {}
-    Cluster(const Cluster &other)
-        : Cluster(other.cluster_sizeX, other.cluster_sizeY, other.dt) {
+    DynamicCluster() : DynamicCluster(3, 3) {}
+    DynamicCluster(const DynamicCluster &other)
+        : DynamicCluster(other.cluster_sizeX, other.cluster_sizeY, other.dt) {
         if (this == &other)
             return;
         x = other.x;
         y = other.y;
         memcpy(m_data, other.m_data, other.bytes());
     }
-    Cluster &operator=(const Cluster &other) {
+    DynamicCluster &operator=(const DynamicCluster &other) {
         if (this == &other)
             return *this;
-        this->~Cluster();
-        new (this) Cluster(other);
+        this->~DynamicCluster();
+        new (this) DynamicCluster(other);
         return *this;
     }
-    Cluster(Cluster &&other) noexcept
+    DynamicCluster(DynamicCluster &&other) noexcept
         : cluster_sizeX(other.cluster_sizeX),
           cluster_sizeY(other.cluster_sizeY), x(other.x), y(other.y),
           dt(other.dt), m_data(other.m_data) {
         other.m_data = nullptr;
         other.dt = Dtype(Dtype::TypeIndex::ERROR);
     }
-    ~Cluster() { delete[] m_data; }
+    ~DynamicCluster() { delete[] m_data; }
     template <typename T> T get(int idx) {
         (sizeof(T) == dt.bytes())
             ? 0
@@ -95,10 +95,6 @@ class Cluster {
             : throw std::invalid_argument("[ERROR] Type size mismatch");
         return memcpy(m_data + idx * dt.bytes(), &val, (size_t)dt.bytes());
     }
-    // auto x() const { return x; }
-    // auto y() const { return y; }
-    // auto x(int16_t x_) { return x = x_; }
-    // auto y(int16_t y_) { return y = y_; }
 
     template <typename T> std::string to_string() const {
         (sizeof(T) == dt.bytes())