GaussianTrackDensity.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file GaussianTrackDensity.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/EventData/TrackParameters.hpp"

#include <map>
#include <set>

namespace Acts {

template <typename input_track_t>
class GaussianTrackDensity {
 public:
  struct TrackEntry {
    TrackEntry() = default;
    TrackEntry(double z_, double c0_, double c1_, double c2_,
               double lowerBound_, double upperBound_)
        : z(z_),
          c0(c0_),
          c1(c1_),
          c2(c2_),
          lowerBound(lowerBound_),
          upperBound(upperBound_) {}

    double z = 0;
    // Cached information for a single track
    // z-independent term in exponent
    double c0 = 0;
    // linear coefficient in exponent
    double c1 = 0;
    // quadratic coefficient in exponent
    double c2 = 0;
    // The lower bound
    double lowerBound = 0;
    // The upper bound
    double upperBound = 0;
  };

  struct Config {
    Config(double d0Sig = 3.5, double z0Sig = 12.)
        : d0MaxSignificance(d0Sig),
          z0MaxSignificance(z0Sig),
          d0SignificanceCut(d0Sig * d0Sig),
          z0SignificanceCut(z0Sig * z0Sig) {}

    // Assumed shape of density function:
    // Gaussian (true) or parabolic (false)
    bool isGaussianShaped = true;

    // Maximum d0 impact parameter significance to use a track
    double d0MaxSignificance;
    // Maximum z0 impact parameter significance to use a track
    double z0MaxSignificance;
    // Correspondig cut values
    double d0SignificanceCut;
    double z0SignificanceCut;
  };

  struct State {
    // Constructor with size track map
    State(unsigned int nTracks) { trackEntries.reserve(nTracks); }
    // Vector to cache track information
    std::vector<TrackEntry> trackEntries;
  };

  GaussianTrackDensity() = default;

  GaussianTrackDensity(const Config& cfg) : m_cfg(cfg) {}

  std::pair<double, double> globalMaximumWithWidth(
      State& state, const std::vector<const input_track_t*>& trackList,
      const std::function<BoundTrackParameters(input_track_t)>&
          extractParameters) const;

  double globalMaximum(State& state,
                       const std::vector<const input_track_t*>& trackList,
                       const std::function<BoundTrackParameters(input_track_t)>&
                           extractParameters) const;

 private:
  Config m_cfg;

  void addTracks(State& state,
                 const std::vector<const input_track_t*>& trackList,
                 const std::function<BoundTrackParameters(input_track_t)>&
                     extractParameters) const;

  std::tuple<double, double, double> trackDensityAndDerivatives(State& state,
                                                                double z) const;

  std::tuple<double, double, double> updateMaximum(
      double newZ, double newValue, double newSecondDerivative, double maxZ,
      double maxValue, double maxSecondDerivative) const;

  double stepSize(double y, double dy, double ddy) const;

  // Helper class to evaluate and store track density at specific position
  class GaussianTrackDensityStore {
   public:
    // Initialise at the z coordinate at which the density is to be evaluated
    GaussianTrackDensityStore(double z_coordinate) : m_z(z_coordinate) {}

    // Add the contribution of a single track to the density
    void addTrackToDensity(const TrackEntry& entry);

    // Return density, first and second derivatives
    inline std::tuple<double, double, double> densityAndDerivatives() const {
      return {m_density, m_firstDerivative, m_secondDerivative};
    }

   private:
    // Store density and derivatives for z position m_z
    double m_z;
    double m_density{0};
    double m_firstDerivative{0};
    double m_secondDerivative{0};
  };
};

#include "Acts/Vertexing/GaussianTrackDensity.ipp"
}  // namespace Acts