IterativeVertexFinder.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2019 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/Logger.hpp"
#include "Acts/Utilities/Result.hpp"
#include "Acts/Vertexing/FsmwMode1dFinder.hpp"
#include "Acts/Vertexing/FullBilloirVertexFitter.hpp"
#include "Acts/Vertexing/HelicalTrackLinearizer.hpp"
#include "Acts/Vertexing/ImpactPointEstimator.hpp"
#include "Acts/Vertexing/Vertex.hpp"
#include "Acts/Vertexing/VertexFitterConcept.hpp"
#include "Acts/Vertexing/VertexingOptions.hpp"
#include "Acts/Vertexing/ZScanVertexFinder.hpp"

namespace Acts {

template <typename vfitter_t, typename sfinder_t>
class IterativeVertexFinder {
  static_assert(VertexFitterConcept<vfitter_t>,
                "Vertex fitter does not fulfill vertex fitter concept.");
  using Propagator_t = typename vfitter_t::Propagator_t;
  using Linearizer_t = typename vfitter_t::Linearizer_t;

 public:
  using InputTrack_t = typename vfitter_t::InputTrack_t;
  using IPEstimator = ImpactPointEstimator<InputTrack_t, Propagator_t>;

  struct Config {
    Config(const vfitter_t& fitter, Linearizer_t lin, sfinder_t sfinder,
           const IPEstimator& est)
        : vertexFitter(fitter),
          linearizer(std::move(lin)),
          seedFinder(std::move(sfinder)),
          ipEst(est) {}

    vfitter_t vertexFitter;

    Linearizer_t linearizer;

    sfinder_t seedFinder;

    IPEstimator ipEst;

    double significanceCutSeeding = 10;
    double maximumChi2cutForSeeding = 36.;
    int maxVertices = 50;

    bool createSplitVertices = false;
    int splitVerticesTrkInvFraction = 2;
    bool reassignTracksAfterFirstFit = false;
    bool doMaxTracksCut = false;
    int maxTracks = 5000;
    double cutOffTrackWeight = 0.01;
    double cutOffTrackWeightReassign = 1;
  };

  struct State {
    State(const MagneticFieldProvider& field,
          const Acts::MagneticFieldContext& magContext)
        : ipState(field.makeCache(magContext)),
          linearizerState(field.makeCache(magContext)),
          fitterState(field.makeCache(magContext)) {}
    typename IPEstimator::State ipState;
    typename Linearizer_t::State linearizerState;
    typename vfitter_t::State fitterState;
  };

  template <
      typename T = InputTrack_t,
      std::enable_if_t<std::is_same<T, BoundTrackParameters>::value, int> = 0>
  IterativeVertexFinder(Config& cfg,
                        std::unique_ptr<const Logger> logger = getDefaultLogger(
                            "IterativeVertexFinder", Logging::INFO))
      : m_cfg(std::move(cfg)),
        m_extractParameters([](T params) { return params; }),
        m_logger(std::move(logger)) {}

  IterativeVertexFinder(Config& cfg,
                        std::function<BoundTrackParameters(InputTrack_t)> func,
                        std::unique_ptr<const Logger> logger = getDefaultLogger(
                            "IterativeVertexFinder", Logging::INFO))
      : m_cfg(std::move(cfg)),
        m_extractParameters(func),
        m_logger(std::move(logger)) {}

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

 private:
  const Config m_cfg;

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

  std::unique_ptr<const Logger> m_logger;

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

  Result<Vertex<InputTrack_t>> getVertexSeed(
      const std::vector<const InputTrack_t*>& seedTracks,
      const VertexingOptions<InputTrack_t>& vertexingOptions) const;

  void removeTracks(const std::vector<const InputTrack_t*>& tracksToRemove,
                    std::vector<const InputTrack_t*>& seedTracks) const;

  Result<double> getCompatibility(
      const BoundTrackParameters& params, const Vertex<InputTrack_t>& vertex,
      const Surface& perigeeSurface,
      const VertexingOptions<InputTrack_t>& vertexingOptions,
      State& state) const;

  Result<void> removeUsedCompatibleTracks(
      Vertex<InputTrack_t>& vertex,
      std::vector<const InputTrack_t*>& tracksToFit,
      std::vector<const InputTrack_t*>& seedTracks,
      const VertexingOptions<InputTrack_t>& vertexingOptions,
      State& state) const;

  Result<void> fillTracksToFit(
      const std::vector<const InputTrack_t*>& seedTracks,
      const Vertex<InputTrack_t>& seedVertex,
      std::vector<const InputTrack_t*>& tracksToFitOut,
      std::vector<const InputTrack_t*>& tracksToFitSplitVertexOut,
      const VertexingOptions<InputTrack_t>& vertexingOptions,
      State& state) const;

  Result<bool> reassignTracksToNewVertex(
      std::vector<Vertex<InputTrack_t>>& vertexCollection,
      Vertex<InputTrack_t>& currentVertex,
      std::vector<const InputTrack_t*>& tracksToFit,
      std::vector<const InputTrack_t*>& seedTracks,
      const std::vector<const InputTrack_t*>& origTracks,
      const VertexingOptions<InputTrack_t>& vertexingOptions,
      State& state) const;

  int countSignificantTracks(const Vertex<InputTrack_t>& vtx) const;
};

}  // namespace Acts

#include "IterativeVertexFinder.ipp"