CandidatesForMiddleSp.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2018-2022 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 <algorithm>
#include <limits>
#include <memory>
#include <tuple>
#include <vector>

namespace Acts {
template <typename external_space_point_t>
struct TripletCandidate {
  TripletCandidate() = default;

  ~TripletCandidate() = default;

  TripletCandidate(external_space_point_t& b, external_space_point_t& m,
                   external_space_point_t& t, float w, float z, bool q)
      : bottom(&b), middle(&m), top(&t), weight(w), zOrigin(z), isQuality(q) {}

  TripletCandidate(const TripletCandidate&) = default;
  TripletCandidate& operator=(const TripletCandidate&) = default;

  TripletCandidate(TripletCandidate&&) = default;
  TripletCandidate& operator=(TripletCandidate&&) = default;

  external_space_point_t* bottom{nullptr};
  external_space_point_t* middle{nullptr};
  external_space_point_t* top{nullptr};
  float weight{0.};
  float zOrigin{0.};
  bool isQuality{false};
};


template <typename external_space_point_t>
class CandidatesForMiddleSp {
 public:
  using value_type = TripletCandidate<external_space_point_t>;

  CandidatesForMiddleSp() = default;
  ~CandidatesForMiddleSp() = default;

  void setMaxElements(std::size_t n_low, std::size_t n_high);

  std::vector<value_type> storage();

  bool push(external_space_point_t& SpB, external_space_point_t& SpM,
            external_space_point_t& SpT, float weight, float zOrigin,
            bool isQuality);

  void clear();

  static bool descendingByQuality(const value_type& i1, const value_type& i2);

  static bool ascendingByQuality(const value_type& i1, const value_type& i2);

 private:
  bool push(std::vector<std::size_t>& indices, std::size_t& n,
            const std::size_t n_max, external_space_point_t& SpB,
            external_space_point_t& SpM, external_space_point_t& SpT,
            float weight, float zOrigin, bool isQuality);

  bool exists(const std::size_t n, const std::size_t max_size) const;

  void pop(std::vector<std::size_t>& indices, std::size_t& current_size);

  float weight(const std::vector<std::size_t>& indices, std::size_t n) const;

  void bubbleup(std::vector<std::size_t>& indices, std::size_t n);

  void bubbledw(std::vector<std::size_t>& indices, std::size_t n,
                std::size_t actual_size);

  void addToCollection(std::vector<std::size_t>& indices, std::size_t& n,
                       const std::size_t n_max, value_type&& element);

 private:
  // sizes
  // m_max_size_* is the maximum size of the indices collections. These values
  // are set by the user once
  std::size_t m_max_size_high{0};
  std::size_t m_max_size_low{0};
  // m_n_* is the current size of the indices collections [0, m_max_size_*).
  // These values are set internally by the class
  std::size_t m_n_high{0};
  std::size_t m_n_low{0};

  // storage contains the collection of the candidates
  std::vector<value_type> m_storage{};

  // The following vectors store indexes to elements in the storage
  // They are sorted as a min heap tree, in which
  // Each node is lower than its children
  // Thus, it is guaranteed that the lower elements is at the front
  // Sorting criteria is the seed quality
  //
  // This is in effect faster sorted container - implementation with std::set
  // and std::priority_queue were tried and were found to be slower.

  // list of indexes of candidates with high quality in the storage
  std::vector<std::size_t> m_indices_high{};
  // list of indexes of candidates with low quality in the storage
  std::vector<std::size_t> m_indices_low{};
};

}  // namespace Acts

#include "Acts/Seeding/CandidatesForMiddleSp.ipp"