MultiHoughSpaceFastInterceptFinder.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/findlets/base/Findlet.h>
#include <tracking/vxdHoughTracking/findlets/HitSelector.h>
#include <framework/datastore/StoreArray.h>
 
#include <string>
#include <vector>
 
namespace Belle2 {
  class ModuleParamList;
  class VxdID;
 
  namespace vxdHoughTracking {
    class VXDHoughState;
 
    class MultiHoughSpaceFastInterceptFinder : public TrackFindingCDC::Findlet<VXDHoughState, std::vector<VXDHoughState*>> {
      using Super = TrackFindingCDC::Findlet<VXDHoughState, std::vector<VXDHoughState*>>;
 
      typedef std::map<VxdID, std::vector<VxdID>> friendSensorMap;
 
    public:
      MultiHoughSpaceFastInterceptFinder();
 
      void exposeParameters(ModuleParamList* moduleParamList, const std::string& prefix) override;
 
      void initialize() override;
 
      void apply(std::vector<VXDHoughState>& hits, std::vector<std::vector<VXDHoughState*>>& rawTrackCandidates) override;
 
    private:
      // sub-findlets
      HitSelector m_HitSelector;
 
      void initializeSectorFriendMap();
 
      inline unsigned short layerFilter(const std::bitset<8>& layer)
      {
        uint layercount = layer.count();
        return (layercount >= 3 ? layercount : 0);
      }
 
      void fastInterceptFinder2d(const std::vector<VXDHoughState*>& hits, uint xmin, uint xmax, uint ymin, uint ymax,
                                 uint currentRecursion);
 
      void FindHoughSpaceCluster();
 
      void DepthFirstSearch(uint lastIndexX, uint lastIndexY);
 
      // Parameters
      uint m_maxRecursionLevel = 7;
 
      uint m_nAngleSectors = 256;
 
      uint m_nVerticalSectors = 256;
 
      double m_verticalHoughSpaceSize = 0.25;
 
      double m_minimumX = -3.168;
      double m_maximumX = 3.168;
 
      uint m_MinimumHSClusterSize = 6;
      uint m_MaximumHSClusterSize = 100;
      uint m_MaximumHSClusterSizeX = 100;
      uint m_MaximumHSClusterSizeY = 100;
 
      // class variables
      double m_unitX = 0;
      double m_unitY = 0;
 
      friendSensorMap m_fullFriendMap;
 
      std::vector<VXDHoughState*> m_currentSensorsHitList;
 
      std::array<double, 16385> m_HSSinValuesLUT = {0};
      std::array<double, 16385> m_HSCosValuesLUT = {0};
      std::array<double, 16384> m_HSCenterSinValuesLUT = {0};
      std::array<double, 16384> m_HSCenterCosValuesLUT = {0};
      std::array<double, 16385> m_HSYLUT = {0};
      std::array<double, 16384> m_HSYCenterLUT = {0};
      std::array<double, 16385> m_HSXLUT = {0};
      std::array<double, 16384> m_HSXCenterLUT = {0};
 
      struct paircompare {
        bool operator()(const std::pair<uint, uint>& lhs, const std::pair<uint, uint>& rhs) const
        {return ((int)rhs.second - (int)lhs.second) * 16384 < (int)rhs.first - (int)lhs.first;}
      };
      std::map<std::pair<uint, uint>, std::pair<int, std::vector<VXDHoughState*>>, paircompare> m_activeSectors;
 
      uint m_clusterCount = 0;
      uint m_clusterSize = 0;
 
      std::pair<uint, uint> m_clusterInitialPosition = std::make_pair(0, 0);
      std::pair<int, int> m_clusterCoG = std::make_pair(0, 0);
 
      std::vector<VXDHoughState*> m_currentTrackCandidate;
 
      std::vector<std::vector<VXDHoughState*>> m_trackCandidates;
    };
 
  }
}