TrackDensity.hpp

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

namespace Acts {

class TrackDensity {
 public:
  struct TrackEntry {
    // Default constructor
    TrackEntry() = default;
    // Constructor initializing all members
    TrackEntry(double z, double c0in, double c1in, double c2in, double zMin,
               double zMax)
        : z(z),
          c0(c0in),
          c1(c1in),
          c2(c2in),
          lowerBound(zMin),
          upperBound(zMax) {}

    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 {
    // Assumed shape of density function:
    // Gaussian (true) or parabolic (false)
    bool isGaussianShaped = true;
  };

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

  TrackDensity() = default;

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

  void addTrack(State& state, const BoundParameters& trk,
                double d0SignificanceCut, double z0SignificanceCut) const;

  std::pair<double, double> globalMaximumWithWidth(State& state) const;

  double globalMaximum(State& state) const;

  double trackDensity(State& state, double z) const;

  double trackDensity(State& state, double z, double& firstDerivative,
                      double& secondDerivative) const;

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

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

    // Retrieve the density and its derivatives
    inline double density() const { return m_density; }
    inline double firstDerivative() const { return m_firstDerivative; }
    inline double secondDerivative() const { return 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};
  };

  Config m_cfg;

  void updateMaximum(double newZ, double newValue, double newSecondDerivative,
                     double& maxZ, double& maxValue,
                     double& maxSecondDerivative) const;

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

}  // namespace Acts