SimpleBoxDivisionHoughTree.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2015 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Nils Braun, Oliver Frost                                 *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
#include <tracking/trackFindingCDC/hough/trees/BoxDivisionHoughTree.h>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    template<class AHitPtr, class AInBoxAlgorithm, size_t divisionX, size_t divisionY>
    class SimpleBoxDivisionHoughTree : public BoxDivisionHoughTree<AHitPtr, typename AInBoxAlgorithm::HoughBox, divisionX, divisionY> {
 
    private:
      using Super = BoxDivisionHoughTree<AHitPtr, typename AInBoxAlgorithm::HoughBox, divisionX, divisionY>;
 
      using HoughBox = typename AInBoxAlgorithm::HoughBox;
 
      template <size_t I>
      using Width = typename HoughBox::template Width<I>;
 
    public:
      SimpleBoxDivisionHoughTree(float maximumX,
                                 float maximumY,
                                 Width<0> overlapX = 0,
                                 Width<1> overlapY = 0)
        : Super(0)
        , m_maximumX(maximumX)
        , m_maximumY(maximumY)
        , m_overlapX(overlapX)
        , m_overlapY(overlapY)
      {
      }
 
      void initialize()
      {
        Super::template constructArray<0>(-getMaximumX(), getMaximumX(), getOverlapX());
        Super::template constructArray<1>(-getMaximumY(), getMaximumY(), getOverlapY());
 
        Super::initialize();
      }
 
      std::vector<std::pair<HoughBox, std::vector<AHitPtr>>>
      findSingleBest(const Weight& minWeight)
      {
        AInBoxAlgorithm inBoxAlgorithm;
        auto skipLowWeightNode = [minWeight](const typename Super::Node * node) {
          return not(node->getWeight() >= minWeight);
        };
        auto found = this->getTree()->findHeaviestLeafSingle(inBoxAlgorithm, this->getMaxLevel(), skipLowWeightNode);
 
        std::vector<std::pair<HoughBox, std::vector<AHitPtr>>> result;
        if (found) {
          // Move the found content over. unique_ptr still destroys the left overs.
          result.push_back(std::move(*found));
        }
        return result;
      }
 
      float getMaximumX() const
      {
        return m_maximumX;
      }
 
      float getMaximumY() const
      {
        return m_maximumY;
      }
 
      Width<0> getOverlapX() const
      {
        return m_overlapX;
      }
 
      Width<1> getOverlapY() const
      {
        return m_overlapY;
      }
 
    private:
      float m_maximumX = 0;
 
      float m_maximumY = 0;
 
      Width<0> m_overlapX = 0;
 
      Width<1> m_overlapY = 0;
    };
  }
}