AxialHitQuadTreeProcessor.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/legendre/quadtree/QuadTreeProcessor.h>
#include <tracking/trackFindingCDC/legendre/precisionFunctions/PrecisionUtil.h>
 
#include <tracking/trackingUtilities/numerics/LookupTable.h>
 
#include <Math/Vector2D.h>
 
#include <vector>
 
namespace Belle2 {
 
  namespace TrackingUtilities {
    class CDCWireHit;
  }
 
  namespace TrackFindingCDC {

    class AxialHitQuadTreeProcessor : public QuadTreeProcessor<long, float, const TrackingUtilities::CDCWireHit> {
 
    public:
      static const TrackingUtilities::LookupTable<ROOT::Math::XYVector>& getCosSinLookupTable();
      static std::vector<float> createCurvBound(YSpan curvSpan, int lastLevel);
 
    public:
      AxialHitQuadTreeProcessor(int lastLevel,
                                int seedLevel,
                                const XYSpans& ranges,
                                PrecisionUtil::PrecisionFunction precisionFunction);

      AxialHitQuadTreeProcessor(const ROOT::Math::XYVector& localOrigin,
                                const YSpan& curvSpan,
                                const TrackingUtilities::LookupTable<ROOT::Math::XYVector>* cosSinLookupTable);
 
    protected: // Section of specialized functions
      bool isLeaf(QuadTree* node) const final;

      XYSpans createChild(QuadTree* node, int i, int j) const final;

      bool isInNode(QuadTree* node, const TrackingUtilities::CDCWireHit* wireHit) const final;

      void insertItemsInNodes(const std::vector<QuadTree*>& nodes,
                              const std::vector<Item*>& items) final;
 
    protected: // Implementation details
      bool checkDerivative(QuadTree* node, const TrackingUtilities::CDCWireHit* wireHit) const;

      bool checkExtremum(QuadTree* node, const TrackingUtilities::CDCWireHit* wireHit) const;
 
    public: // debug stuff
      void drawHits(const std::vector<const TrackingUtilities::CDCWireHit*>& hits, unsigned int color = 46) const;
      void drawNode(QuadTree* node) const;
 
    private:
      struct ThetaSpanCache {
        long xMin = 0;

        long xMax = 0;

        const ROOT::Math::XYVector* thetaVecMin = nullptr;

        const ROOT::Math::XYVector* thetaVecMax = nullptr;

        float rHitMinRight = 0;

        float rHitMaxRight = 0;

        float rHitMinLeft = 0;

        float rHitMaxLeft = 0;

        float rHitMinExtr = 0;

        float rHitMaxExtr = 0;

        bool derivativeOk = false;

        bool hasExtremum = false;

        bool extremumIsBetween = false;
      };

      struct NodeCache {
        float yMin = 0;

        float yMax = 0;

        int iThetaSpan = 0;

        bool needsDerivativeCheck = false;
      };

      std::vector<ThetaSpanCache> m_thetaSpanCaches;

      std::vector<NodeCache> m_nodeCaches;
 
    private:
      PrecisionUtil::PrecisionFunction m_precisionFunction;

      ROOT::Math::XYVector m_localOrigin;

      const TrackingUtilities::LookupTable<ROOT::Math::XYVector>* m_cosSinLookupTable {};

      const double c_curlCurv = 0.02;

      bool m_twoSidedPhaseSpace;
    };
  }
}