Clusterizend.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#ifndef CLUSTERIZEND_H
#define CLUSTERIZEND_H
 
#include <cmath>
 
 
namespace Belle2 {
  struct clusterer_params  {
    unsigned short minweight      =    24;
    unsigned short minpts         =    1;
    bool diagonal                 =    true;
    std::vector<bool> var_cyclic = {false, true, false};
    std::vector<std::string> var_labels = {"omega", "phi", "theta"};
  };
 
 
  class SimpleCluster {
  public:
    SimpleCluster()
    {
      setParams(3);
      initClCellsNew();
    }
    explicit SimpleCluster(cell_index entry)
    {
      setParams(3);
      initClCellsNew();
      append(entry);
    }
    virtual ~SimpleCluster() {}
    void initClCellsNew()
    {
      unsigned short init_ClSize = 0;
      unsigned short default_value = 0;
      cell_index cell(m_dim, default_value);
      std::vector<cell_index> C(init_ClSize, cell);
      m_C = C;
    }
    void setParams(unsigned short dim)
    {
      m_dim = dim;
      m_orientSum = 0;
    }
    std::vector<cell_index> getEntries()
    {
      return m_C;
    }
    void append(cell_index next_entry)
    {
      m_C.push_back(next_entry);
    }
    void add_hit(unsigned short hit, unsigned short weight, unsigned short orient)
    {
      m_hits.push_back(hit);
      m_hitWeights.push_back(weight);
      m_orientSum += orient; 
    }
    unsigned long get_naxial()
    {
      return m_orientSum;
    }
    unsigned long get_nstereo()
    {
      return m_hits.size() - m_orientSum;
    }
    std::vector<unsigned short> get_hits()
    {
      return m_hits;
    }
    std::vector<unsigned short> get_weights()
    {
      return m_hitWeights;
    }
  private:
    std::vector<cell_index> m_C;
    unsigned short m_dim;
    std::vector<unsigned short> m_hits;
    std::vector<unsigned short> m_hitWeights;
    unsigned short m_orientSum;
  };
 
 
  class Clusterizend {
  public:
    Clusterizend()
    {
    }
    virtual ~Clusterizend() {}
    explicit Clusterizend(const clusterer_params& params): m_params(params)
    {
    }
 
    clusterer_params getParams()
    {
      return m_params;
    }
 
    void setPlaneShape(std::vector<ushort> planeShape)
    {
      m_dimsize = planeShape.size();
      m_planeShape = planeShape;
      m_valmax = std::vector<ushort>(m_planeShape);
      for (ushort idim = 0; idim < m_dimsize; idim++) {
        m_valmax[idim] -= 1;
      }
      m_valmax.push_back(1);
 
    }
    void setNewPlane(c3array& houghmap_plain)
    {
      m_houghVals = &houghmap_plain;
      m_houghVisit = c3array(m_c3shape);
    }
 
    bool has_before(cell_index entry, ushort dim);
 
    cell_index before(cell_index entry, ushort dim);
 
    bool has_after(cell_index entry, ushort dim);
 
    cell_index after(cell_index entry, ushort dim);
 
    void blockcheck(std::vector<cell_index>* neighbors, cell_index elem, ushort dim);
 
    std::vector<cell_index>  regionQuery(cell_index entry);
 
    std::vector<SimpleCluster> dbscan();
 
    void expandCluster(std::vector<cell_index>& N, SimpleCluster& C);
 
    std::vector<cell_index> getCandidates();
 
 
    template<class T>
    std::string printVector(std::vector<T> vecX)
    {
      std::stringstream result;
      result << " ";
      for (T& elem : vecX) { result << elem << " ";}
      std::string rest;
      result >> rest;
      result >> rest;
      return result.str();
    }
 
    template<class T>
    std::string printCells(std::vector<T> vecX)
    {
      std::stringstream result;
      for (T& elem : vecX) { result << " {" << printVector(elem) << "}";}
      return result.str();
    }
  private:
    clusterer_params m_params;
    std::vector<ushort> m_planeShape;
    std::vector<ushort> m_valmax;
    ushort m_dimsize;
    boost::array<c3index, 3> m_c3shape =  {{ 40, 384, 9 }};
    c3array* m_houghVals{0};
    c3array m_houghVisit = c3array(m_c3shape);
  };
}
 
#endif