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.                  *
 **************************************************************************/
 
#pragma once
 
#include <cmath>
#include <Math/Vector3D.h>
 
namespace Belle2 {
  struct clustererParams  {
    unsigned short minWeight      =    24;
    unsigned char minPts         =    1;
    bool diagonal                 =    true;
    unsigned short minTotalWeight  =    450;
    unsigned short minPeakWeight   =    32;
    unsigned char iterations      =    5;
    unsigned char omegaTrim                =    5;
    unsigned char phiTrim                  =    4;
    unsigned char thetaTrim                =    4;
    std::vector<bool> varCyclic = {false, true, false};
    std::vector<std::string> varLabels = {"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 defaultValue = 0;
      cell_index cell(m_dim, defaultValue);
      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 nextEntry)
    {
      m_C.push_back(nextEntry);
    }

    void addHit(unsigned short hit, unsigned short weight, unsigned short orient)
    {
      m_hits.push_back(hit);
      m_hitWeights.push_back(weight);
      m_orientSum += orient; 
    }

    unsigned long getNAxial()
    {
      return m_orientSum;
    }

    unsigned long getNStereo()
    {
      return m_hits.size() - m_orientSum;
    }

    std::vector<unsigned short> getHits()
    {
      return m_hits;
    }

    std::vector<unsigned short> getWeights()
    {
      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 clustererParams& params): m_params(params)
    {
    }
 
    clustererParams 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& houghmapPlain)
    {
      m_houghVals = &houghmapPlain;
      m_houghVisit = c3array(m_c3shape);
    }


    bool hasBefore(cell_index entry, ushort dim);
 
    cell_index before(cell_index entry, ushort dim);
 
    bool hasAfter(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();
 
    std::pair<cell_index, unsigned long> getGlobalMax();
 
    void deleteMax(cell_index maxIndex);
 
    std::vector<SimpleCluster> makeClusters();
 
    std::pair<SimpleCluster, unsigned long> createCluster(cell_index maxIndex);
 
    unsigned long checkSurroundings(cell_index maxIndex);
 
    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:
    clustererParams 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);
  };

}