SimpleHitBasedHoughTree.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 <tracking/trackFindingCDC/hough/perigee/StereoHitContained.h>
#include <tracking/trackFindingCDC/hough/trees/BoxDivisionHoughTree.h>
#include <tracking/trackFindingCDC/hough/perigee/CurvRep.h>
 
#include <vector>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    template<class AHitPtr,
             class InBox,
             size_t ... divisions>
    class SimpleHitBasedHoughTree :
      public BoxDivisionHoughTree<AHitPtr, typename InBox::HoughBox, divisions...> {
 
    private:
      using Super = BoxDivisionHoughTree<AHitPtr, typename InBox::HoughBox, divisions...>;
 
    public:
      using Node = typename Super::Node;
 
      using HoughBox = typename InBox::HoughBox;
 
    public:
      explicit SimpleHitBasedHoughTree(size_t maxLevel, float curlCurv = NAN) :
        Super(maxLevel),
        m_curlCurv(curlCurv),
        m_stereoHitContainedInBox(curlCurv)
      {}
 
    public:
      std::vector<std::pair<HoughBox,  std::vector<AHitPtr> > >
      find(const Weight& minWeight, const double maxCurv = NAN)
      {
        auto skipHighCurvatureAndLowWeightNode = [minWeight, maxCurv](const Node * node) {
          const HoughBox& houghBox = *node;
          return not(node->getWeight() >= minWeight and not(getLowerCurv(houghBox) > maxCurv));
        };
        return this->getTree()->findLeavesDisjoint(m_stereoHitContainedInBox,
                                                   this->getMaxLevel(),
                                                   skipHighCurvatureAndLowWeightNode);
      }
 
      std::vector<std::pair<HoughBox,  std::vector<AHitPtr> > >
      findBest(const Weight& minWeight, const double maxCurv = NAN)
      {
        auto skipHighCurvatureAndLowWeightNode = [minWeight, maxCurv](const Node * node) {
          const HoughBox& houghBox = *node;
          return not(node->getWeight() >= minWeight and not(getLowerCurv(houghBox) > maxCurv));
        };
        return this->getTree()->findHeaviestLeafRepeated(m_stereoHitContainedInBox,
                                                         this->getMaxLevel(),
                                                         skipHighCurvatureAndLowWeightNode);
      }
 
      std::vector<std::pair<HoughBox,  std::vector<AHitPtr> > >
      findSingleBest(const Weight& minWeight, const double maxCurv = NAN)
      {
        auto skipHighCurvatureAndLowWeightNode = [minWeight, maxCurv](const Node * node) {
          const HoughBox& houghBox = *node;
          return not(node->getWeight() >= minWeight and not(getLowerCurv(houghBox) > maxCurv));
        };
        std::unique_ptr<std::pair<HoughBox,  std::vector<AHitPtr> > > found =
          this->getTree()->findHeaviestLeafSingle(m_stereoHitContainedInBox,
                                                  this->getMaxLevel(),
                                                  skipHighCurvatureAndLowWeightNode);
 
        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;
      }
 
      template<class ALeafProcessor>
      void findUsing(ALeafProcessor& leafProcessor)
      {
        return this->getTree()->fillWalk(m_stereoHitContainedInBox,
                                         leafProcessor);
      }
 
    private:
      double m_curlCurv = 0.018;
 
      StereoHitContained<InBox> m_stereoHitContainedInBox;
    };
  }
}