SeedFinderOrthogonal.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file SeedFinderOrthogonal.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/EventData/SpacePointData.hpp"
#include "Acts/Seeding/InternalSeed.hpp"
#include "Acts/Seeding/InternalSpacePoint.hpp"
#include "Acts/Seeding/SeedFilter.hpp"
#include "Acts/Seeding/SeedFinderConfig.hpp"
#include "Acts/Seeding/SeedFinderOrthogonalConfig.hpp"
#include "Acts/Utilities/KDTree.hpp"

#include <array>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>

namespace Acts {
template <typename external_spacepoint_t>
class SeedFinderOrthogonal {
 public:
  static constexpr std::size_t NDims = 3;

  using seed_t = Seed<external_spacepoint_t>;

  using internal_sp_t = InternalSpacePoint<external_spacepoint_t>;

  using tree_t = KDTree<NDims, internal_sp_t *, ActsScalar, std::array, 4>;

  SeedFinderOrthogonal(
      const Acts::SeedFinderOrthogonalConfig<external_spacepoint_t> &config);

  ~SeedFinderOrthogonal() = default;

  SeedFinderOrthogonal() = default;
  SeedFinderOrthogonal(const SeedFinderOrthogonal<external_spacepoint_t> &) =
      delete;
  SeedFinderOrthogonal<external_spacepoint_t> &operator=(
      const SeedFinderOrthogonal<external_spacepoint_t> &) = default;

  template <typename input_container_t, typename output_container_t,
            typename callable_t>
  void createSeeds(const Acts::SeedFinderOptions &options,
                   const input_container_t &spacePoints,
                   output_container_t &out_cont,
                   callable_t &&extract_coordinates) const;

  template <typename input_container_t, typename callable_t>
  std::vector<seed_t> createSeeds(const Acts::SeedFinderOptions &options,
                                  const input_container_t &spacePoints,
                                  callable_t &&extract_coordinates) const;

 private:
  enum Dim { DimPhi = 0, DimR = 1, DimZ = 2 };

  typename tree_t::range_t validTupleOrthoRangeLH(
      const internal_sp_t &low) const;

  typename tree_t::range_t validTupleOrthoRangeHL(
      const internal_sp_t &high) const;

  bool validTuple(const SeedFinderOptions &options, const internal_sp_t &low,
                  const internal_sp_t &high, bool isMiddleInverted) const;

  tree_t createTree(const std::vector<internal_sp_t *> &spacePoints) const;

  void filterCandidates(
      const SeedFinderOptions &options, internal_sp_t &middle,
      std::vector<internal_sp_t *> &bottom, std::vector<internal_sp_t *> &top,
      SeedFilterState seedFilterState,
      CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>
          &candidates_collector,
      Acts::SpacePointData &spacePointData) const;

  template <typename output_container_t>
  void processFromMiddleSP(const SeedFinderOptions &options, const tree_t &tree,
                           output_container_t &out_cont,
                           const typename tree_t::pair_t &middle_p,
                           Acts::SpacePointData &spacePointData) const;

  Acts::SeedFinderOrthogonalConfig<external_spacepoint_t> m_config;
};
}  // namespace Acts

#include "Acts/Seeding/SeedFinderOrthogonal.ipp"