AdaptiveGridDensityVertexFinder.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2020 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/EventData/TrackParameters.hpp"
#include "Acts/Utilities/Result.hpp"
#include "Acts/Vertexing/AdaptiveGridTrackDensity.hpp"
#include "Acts/Vertexing/DummyVertexFitter.hpp"
#include "Acts/Vertexing/Vertex.hpp"
#include "Acts/Vertexing/VertexingOptions.hpp"

#include <unordered_map>

namespace Acts {

template <int trkGridSize = 15, typename vfitter_t = DummyVertexFitter<>>
class AdaptiveGridDensityVertexFinder {
  // Assert odd trkGridSize
  static_assert(trkGridSize % 2);

  using InputTrack_t = typename vfitter_t::InputTrack_t;
  using GridDensity = AdaptiveGridTrackDensity<trkGridSize>;

 public:
  using DensityMap = typename GridDensity::DensityMap;

  struct Config {
    Config(float binSize = 0.1)
        : gridDensity(typename GridDensity::Config(binSize)) {}
    Config(const GridDensity& gDensity) : gridDensity(gDensity) {}

    // The grid density object
    GridDensity gridDensity;

    // Cache the main grid and the density contributions (trackGrid and z-bin)
    // for every single track.
    // This option enables the possibility to calculate the entire main grid
    // only once in the first iteration. If tracks are removed from the track
    // collection, the individual track density contributions to the main grid
    // can just be removed without calculating the entire grid from scratch.
    bool cacheGridStateForTrackRemoval = true;

    // Maximum d0 impact parameter significance to use a track
    double maxD0TrackSignificance = 3.5;
    // Maximum z0 impact parameter significance to use a track
    double maxZ0TrackSignificance = 12.;
    // The actual corresponding cut values in the algorithm
    double d0SignificanceCut = maxD0TrackSignificance * maxD0TrackSignificance;
    double z0SignificanceCut = maxZ0TrackSignificance * maxZ0TrackSignificance;
    bool estimateSeedWidth = false;
  };

  struct State {
    // Map from the z bin values to the corresponding track density
    DensityMap mainDensityMap;

    // Map from input track to corresponding track density map
    std::unordered_map<const InputTrack_t*, DensityMap> trackDensities;

    // Map to store bool if track has passed track selection or not
    std::unordered_map<const InputTrack_t*, bool> trackSelectionMap;

    // Store tracks that have been removed from track collection. These
    // tracks will be removed from the main grid
    std::vector<const InputTrack_t*> tracksToRemove;

    bool isInitialized = false;
  };

  Result<std::vector<Vertex<InputTrack_t>>> find(
      const std::vector<const InputTrack_t*>& trackVector,
      const VertexingOptions<InputTrack_t>& vertexingOptions,
      State& state) const;

  template <
      typename T = InputTrack_t,
      std::enable_if_t<std::is_same<T, BoundTrackParameters>::value, int> = 0>
  AdaptiveGridDensityVertexFinder(const Config& cfg)
      : m_cfg(cfg), m_extractParameters([](T params) { return params; }) {}

  template <
      typename T = InputTrack_t,
      std::enable_if_t<std::is_same<T, BoundTrackParameters>::value, int> = 0>
  AdaptiveGridDensityVertexFinder()
      : m_extractParameters([](T params) { return params; }) {}

  AdaptiveGridDensityVertexFinder(
      const Config& cfg,
      const std::function<BoundTrackParameters(InputTrack_t)>& func)
      : m_cfg(cfg), m_extractParameters(func) {}

  AdaptiveGridDensityVertexFinder(
      const std::function<BoundTrackParameters(InputTrack_t)>& func)
      : m_extractParameters(func) {}

 private:
  bool doesPassTrackSelection(const BoundTrackParameters& trk) const;

  // The configuration object
  const Config m_cfg;

  std::function<BoundTrackParameters(InputTrack_t)> m_extractParameters;
};

}  // namespace Acts

#include "AdaptiveGridDensityVertexFinder.ipp"