AxialLegendreLeafProcessor.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/eventdata/tracks/CDCTrack.h>
#include <tracking/trackFindingCDC/eventdata/hits/CDCRLWireHit.h>
#include <tracking/trackFindingCDC/eventdata/trajectories/CDCTrajectory2D.h>
 
#include <tracking/trackFindingCDC/hough/perigee/CurvRep.h>
 
#include <tracking/trackFindingCDC/hough/baseelements/WithSharedMark.h>
 
#include <vector>
 
namespace Belle2 {
  class ModuleParamList;
  namespace TrackFindingCDC {
    template<class ANode>
    class AxialLegendreLeafProcessor {
 
    public:
      using Candidate = std::pair<CDCTrajectory2D, std::vector<CDCRLWireHit> >;
 
    public:
      explicit AxialLegendreLeafProcessor(int maxLevel)
        : m_param_maxLevel(maxLevel)
      {}
 
    public: // Node hook to interact with the tree walk
      bool operator()(ANode* node)
      {
        ++m_nNodes;
        if (skip(node)) {
          ++m_nSkippedNodes;
          return true;
        } else if (isLeaf(node)) {
          ++m_nLeafs;
          processLeaf(node);
          return true;
        } else {
          return false;
        }
      }
 
      bool skip(const ANode* node)
      {
        bool tooLowWeight = not(node->getWeight() >= m_param_minWeight);
        bool tooHighCurvature = (static_cast<float>(node->template getLowerBound<DiscreteCurv>()) > m_param_maxCurv or
                                 - static_cast<float>(node->template getUpperBound<DiscreteCurv>()) > m_param_maxCurv);
        return tooLowWeight or tooHighCurvature;
      }
 
      bool isLeaf(const ANode* node)
      {
        //if (node->getLevel() <= 6) return false;
        if (node->getLevel() >= m_param_maxLevel) return true;
 
        // Compare the resolution at the mean curvature to the resolution defined by the resolution function
        std::array<DiscreteCurv, 2> curvs = node->template getBounds<DiscreteCurv>();
        float lowerCurv = *(curvs[0]);
        float upperCurv = *(curvs[1]);
        float curvWidth = std::fabs(upperCurv - lowerCurv);
        double curvRes = m_curvResolution((lowerCurv + upperCurv) / 2.0);
        if (curvRes >= curvWidth) return true;
        return false;
      }
 
      void processLeaf(ANode* leaf);
 
    public: // Helper method to execute some steps in the creation of a candidate from a leaf
      std::vector<WithSharedMark<CDCRLWireHit> >
      searchRoad(const ANode& node, const CDCTrajectory2D& trajectory2D);
 
    public:
      std::vector<Candidate> getCandidates() const;
 
      const std::vector<CDCTrack>& getTracks() const
      {
        return m_tracks;
      }
 
      void clear()
      {
        m_tracks.clear();
        m_axialWireHits.clear();
      }
 
      void setAxialWireHits(std::vector<const CDCWireHit*> axialWireHits)
      {
        m_axialWireHits = std::move(axialWireHits);
      }
 
    public:
      void exposeParameters(ModuleParamList* moduleParamList, const std::string& prefix);
 
      void beginWalk();
 
    public:
      int m_nNodes = 0;
 
      int m_nSkippedNodes = 0;
 
      int m_nLeafs = 0;
 
    private:
      int m_param_maxLevel = 1;
 
      double m_param_minWeight = 0;
 
      double m_param_maxCurv = NAN;
 
      double m_param_curlCurv = 0.018;
 
      int m_param_nRoadSearches = 0;
 
      int m_param_roadLevel = 0;
 
      std::string m_param_curvResolution = "const";
 
      /*
      double m_param_maxDistance = 0.2;
 
      double m_param_newHitDistance = 0.15;
      */
    private:
      std::vector<CDCTrack> m_tracks;
 
      std::vector<const CDCWireHit*> m_axialWireHits;
 
      std::function<double(double)> m_curvResolution;
    };
  }
}