IndexedSurfacesGenerator.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file IndexedSurfacesGenerator.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2023 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include "Acts/Definitions/Algebra.hpp"
#include "Acts/Detector/detail/IndexedGridFiller.hpp"
#include "Acts/Navigation/SurfaceCandidatesUpdators.hpp"
#include "Acts/Utilities/Enumerate.hpp"

#include <algorithm>
#include <array>
#include <memory>

namespace Acts {
namespace Experimental {
namespace detail {

template <typename surface_container, template <typename> class indexed_updator>
struct IndexedSurfacesGenerator {
  surface_container surfaces = {};
  // Indices of surfaces that are to be assigned to all bins
  std::vector<std::size_t> assignToAll = {};
  std::vector<BinningValue> bValues = {};
  // Bin expansion
  std::vector<std::size_t> binExpansion = {};
  Transform3 transform = Transform3::Identity();
  std::unique_ptr<const Logger> oLogger =
      getDefaultLogger("IndexedSurfacesGenerator", Logging::INFO);

  template <typename axis_generator, typename reference_generator>
  SurfaceCandidatesUpdator operator()(
      const GeometryContext& gctx, const axis_generator& aGenerator,
      const reference_generator& rGenerator) const {
    ACTS_DEBUG("Indexing " << surfaces.size() << " surface, "
                           << assignToAll.size() << " of which into all bins.");
    // Create the grid with the provided axis generator
    using GridType =
        typename axis_generator::template grid_type<std::vector<std::size_t>>;
    GridType grid(std::move(aGenerator()));

    std::array<BinningValue, decltype(grid)::DIM> bvArray = {};
    for (auto [ibv, bv] : enumerate(bValues)) {
      bvArray[ibv] = bv;
    }

    indexed_updator<GridType> indexedSurfaces(std::move(grid), bvArray,
                                              transform);
    // Fill the bin indices
    IndexedGridFiller filler{binExpansion};
    filler.oLogger = oLogger->cloneWithSuffix("_filler");
    filler.fill(gctx, indexedSurfaces, surfaces, rGenerator, assignToAll);

    // The portal delegate
    AllPortalsImpl allPortals;

    // The chained delegate: indexed surfaces and all portals
    using DelegateType =
        IndexedSurfacesAllPortalsImpl<decltype(grid), indexed_updator>;
    auto indexedSurfacesAllPortals = std::make_unique<const DelegateType>(
        std::tie(allPortals, indexedSurfaces));

    // Create the delegate and connect it
    SurfaceCandidatesUpdator nStateUpdator;
    nStateUpdator.connect<&DelegateType::update>(
        std::move(indexedSurfacesAllPortals));
    return nStateUpdator;
  }

  const Logger& logger() const { return *oLogger; }
};

}  // namespace detail
}  // namespace Experimental
}  // namespace Acts