AdaptiveGridTrackDensity.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2020-2023 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 <unordered_map>

#include <boost/functional/hash.hpp>

namespace Acts {

template <int spatialTrkGridSize = 15, int temporalTrkGridSize = 1>
class AdaptiveGridTrackDensity {
  // Assert odd spatial and temporal track grid size
  static_assert(spatialTrkGridSize % 2);
  static_assert(temporalTrkGridSize % 2);

 public:
  // The first (second) integer indicates the bin's z (t) position
  using Bin = std::pair<int, int>;
  // Mapping between bins and track densities
  using DensityMap = std::unordered_map<Bin, float, boost::hash<Bin>>;
  // Coordinates in the z-t plane; the t value will be set to 0 if time
  // vertex seeding is disabled
  using ZTPosition = std::pair<float, float>;
  // z-t position of a maximum and its width
  using ZTPositionAndWidth = std::pair<ZTPosition, float>;

  struct Config {
    Config(float spatialBinExtent_) : spatialBinExtent(spatialBinExtent_) {
      if constexpr (temporalTrkGridSize > 1) {
        throw std::invalid_argument(
            "temporalBinExtent must be provided if temporalTrkGridSize > 1 "
            "(i.e., if time vertex seeding is enabled).");
      }
    }

    Config(float spatialBinExtent_, float temporalBinExtent_)
        : spatialBinExtent(spatialBinExtent_),
          temporalBinExtent(temporalBinExtent_) {
      if constexpr (temporalTrkGridSize == 1) {
        throw std::invalid_argument(
            "temporalBinExtent must not be provided if temporalTrkGridSize == "
            "1 (i.e., if time vertex seeding is disabled).");
      }
    }

    // Spatial extent of a bin in d0 and z0 direction, should always be set to a
    // positive value
    float spatialBinExtent = 0.;  // mm

    // Temporal extent of a bin, should be set to 0 if time vertex seeding is
    // disabled (i.e., if temporalTrkGridSize = 1)
    float temporalBinExtent = 0.;  // mm

    // Do NOT use just the z-bin with the highest
    // track density, but instead check (up to)
    // first three density maxima (only those that have
    // a maximum relative deviation of 'relativeDensityDev'
    // from the main maximum) and take the z-bin of the
    // maximum with the highest surrounding density sum
    bool useHighestSumZPosition = false;

    // The maximum relative density deviation from the main
    // maximum to consider the second and third maximum for
    // the highest-sum approach from above
    float maxRelativeDensityDev = 0.01;
  };

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

  static float getBinCenter(int bin, float binExtent);

  static int getBin(float value, float binExtent);

  DensityMap::const_iterator highestDensityEntry(
      const DensityMap& densityMap) const;

  Result<ZTPosition> getMaxZTPosition(DensityMap& densityMap) const;

  Result<ZTPositionAndWidth> getMaxZTPositionAndWidth(
      DensityMap& densityMap) const;

  DensityMap addTrack(const BoundTrackParameters& trk,
                      DensityMap& mainDensityMap) const;

  void subtractTrack(const DensityMap& trackDensityMap,
                     DensityMap& mainDensityMap) const;

 private:
  DensityMap createTrackGrid(const Acts::Vector3& impactParams,
                             const Bin& centralBin,
                             const Acts::SquareMatrix3& cov) const;

  Result<float> estimateSeedWidth(const DensityMap& densityMap,
                                  const ZTPosition& maxZT) const;

  template <unsigned int nDim>
  static float multivariateGaussian(const Acts::ActsVector<nDim>& args,
                                    const Acts::ActsSquareMatrix<nDim>& cov);

  Bin highestDensitySumBin(DensityMap& densityMap) const;

  float getDensitySum(const DensityMap& densityMap, const Bin& bin) const;

  Config m_cfg;
};

}  // namespace Acts

#include "Acts/Vertexing/AdaptiveGridTrackDensity.ipp"