SectoredLinearDivision.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/utilities/Product.h>
 
#include <framework/utilities/Utils.h>
 
#include <utility>
#include <vector>
#include <cassert>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    template<class ABox, std::size_t... divisions>
    class SectoredLinearDivision {
 
    public:
      static const std::size_t s_nSubBoxes = Product<divisions...>::value;
 
    private:
      static constexpr std::size_t s_divisions[sizeof...(divisions)] = {divisions...};
 
    public:
      explicit SectoredLinearDivision(const typename ABox::Delta& overlaps = typename ABox::Delta(),
                                      int sectorLevelSkip = 0)
        : m_overlaps(overlaps)
        , m_sectorLevelSkip(sectorLevelSkip)
      {
      }
 
    public:
      template <class ANode>
      std::vector<ABox> operator()(const ANode& node)
      {
        const ABox& box = node;
        if (branch_unlikely(node.getLevel() == 0)) {
          std::vector<ABox> result = makeSubBoxes(box, std::make_index_sequence<s_nSubBoxes>());
          // Apply further divisions sectorLevelSkip times and return all boxes.
          for (int iSkipped = 0; iSkipped < m_sectorLevelSkip; ++iSkipped) {
            std::vector<ABox> sectoredBoxes;
            sectoredBoxes.reserve(result.size() * s_nSubBoxes);
            for (const ABox& boxToDivide : result) {
              for (const ABox& dividedBox : makeSubBoxes(boxToDivide, std::make_index_sequence<s_nSubBoxes>())) {
                sectoredBoxes.push_back(dividedBox);
              }
            }
            result = std::move(sectoredBoxes);
          }
 
          return result;
        }
        return makeSubBoxes(box, std::make_index_sequence<s_nSubBoxes>());
      }
 
      template<std::size_t... Is>
      std::vector<ABox>
      makeSubBoxes(const ABox& box, std::index_sequence<Is...> /*globalSubBoxIndex*/)
      {
        return {{ makeSubBox(box, Is, std::make_index_sequence<sizeof...(divisions)>())... }};
      }
 
      template <std::size_t... Is>
      ABox makeSubBox(const ABox& box, std::size_t globalISubBox, std::index_sequence<Is...> /*coordinatesIndex*/)
      {
        std::array<std::size_t, sizeof...(divisions)> indices;
        for (size_t c_Index = 0 ; c_Index <  sizeof...(divisions); ++c_Index) {
          indices[c_Index] = globalISubBox % s_divisions[c_Index];
          globalISubBox /= s_divisions[c_Index];
        }
        assert(globalISubBox == 0);
        return ABox(box.template getDivisionBoundsWithOverlap<Is>(std::get<Is>(m_overlaps),
                                                                  s_divisions[Is],
                                                                  indices[Is]) ...);
      }
 
    private:
      typename ABox::Delta m_overlaps;
 
      int m_sectorLevelSkip;
    };
 
    // Extra mention of the constexpr such that it acquires external linkage.
    template<class ABox, std::size_t... divisions>
    constexpr std::size_t SectoredLinearDivision<ABox, divisions...>::s_divisions[sizeof...(divisions)];
  }
}