VertexFinder.h

Go to the documentation of this file.

#ifndef __L1Trigger_VertexFinder_VertexFinder_h__
#define __L1Trigger_VertexFinder_VertexFinder_h__

#include "DataFormats/Common/interface/Ptr.h"
#include "DataFormats/L1TrackTrigger/interface/TTTrack.h"
#include "DataFormats/L1Trigger/interface/VertexWord.h"
#include "DataFormats/Math/interface/deltaPhi.h"
#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "L1Trigger/VertexFinder/interface/AlgoSettings.h"
#include "L1Trigger/VertexFinder/interface/RecoVertex.h"
#include "PhysicsTools/TensorFlow/interface/TensorFlow.h"

#include <algorithm>
#include <cmath>
#include <iterator>
#include <vector>

namespace l1tVertexFinder {

  // Returns the number of bits needed to represent and integer decimal
  static constexpr unsigned BitsToRepresent(unsigned x) { return x < 2 ? 1 : 1 + BitsToRepresent(x >> 1); }

  typedef std::vector<L1Track> FitTrackCollection;
  typedef std::vector<RecoVertex<>> RecoVertexCollection;

  class VertexFinder {
  public:
    VertexFinder(FitTrackCollection& fitTracks, const AlgoSettings& settings) {
      fitTracks_ = fitTracks;
      settings_ = &settings;
    }
    ~VertexFinder() {}

    struct SortTracksByZ0 {
      inline bool operator()(const L1Track track0, const L1Track track1) { return (track0.z0() < track1.z0()); }
    };

    struct SortTracksByPt {
      inline bool operator()(const L1Track track0, const L1Track track1) {
        return (std::abs(track0.pt()) > std::abs(track1.pt()));
      }
    };


    const FitTrackCollection& fitTracks() const { return fitTracks_; }
    unsigned int iterationsPerTrack() const { return double(iterations_) / double(fitTracks_.size()); }
    unsigned int numInputTracks() const { return fitTracks_.size(); }
    unsigned int numIterations() const { return iterations_; }
    unsigned int numVertices() const { return vertices_.size(); }
    unsigned int numVerticesEmulation() const { return verticesEmulation_.size(); }
    template <typename T>
    T PrimaryVertex() const {
      if ((settings_->vx_precision() == Precision::Simulation) && (pv_index_ < vertices_.size()))
        return vertices_[pv_index_];
      else if ((settings_->vx_precision() == Precision::Emulation) && (pv_index_ < vertices_.size()))
        return verticesEmulation_[pv_index_];
      else {
        edm::LogWarning("VertexFinder") << "PrimaryVertex::No primary vertex has been found.";
        return RecoVertex<>();
      }
    }
    unsigned int primaryVertexId() const { return pv_index_; }
    const std::vector<RecoVertex<>>& vertices() const { return vertices_; }
    const l1t::VertexWordCollection& verticesEmulation() const { return verticesEmulation_; }

    void findPrimaryVertex();
    void associatePrimaryVertex(double trueZ0);
    void GapClustering();
    float maxDistance(RecoVertex<> cluster0, RecoVertex<> cluster1);
    float minDistance(RecoVertex<> cluster0, RecoVertex<> cluster1);
    float meanDistance(RecoVertex<> cluster0, RecoVertex<> cluster1);
    float centralDistance(RecoVertex<> cluster0, RecoVertex<> cluster1);
    void agglomerativeHierarchicalClustering();
    void adaptiveVertexReconstruction();
    void fastHistoLooseAssociation();
    void fastHisto(const TrackerTopology* tTopo);
    void fastHistoEmulation();
    void NNVtxEmulation(tensorflow::Session* TrackWeightSesh = nullptr,
                        tensorflow::Session* PatternRecSesh = nullptr,
                        tensorflow::Session* AssociationSesh = nullptr);

    void sortVerticesInPt();
    void sortVerticesInZ0();

    template <class data_type, typename stream_type = std::ostream>
    void printHistogram(stream_type& stream,
                        std::vector<data_type> data,
                        int width = 80,
                        int minimum = 0,
                        int maximum = -1,
                        std::string title = "",
                        std::string color = "");

    template <typename ForwardIterator, typename T>
    void strided_iota(ForwardIterator first, ForwardIterator last, T value, T stride) {
      while (first != last) {
        *first++ = value;
        value += stride;
      }
    }


    void computeAndSetVertexParameters(RecoVertex<>& vertex,
                                       const std::vector<float>& bin_centers,
                                       const std::vector<unsigned int>& counts);
    void DBSCAN();
    void HPV();
    void Kmeans();
    void PVR();

  private:
    const AlgoSettings* settings_;
    RecoVertexCollection vertices_;
    l1t::VertexWordCollection verticesEmulation_;
    unsigned int numMatchedVertices_;
    FitTrackCollection fitTracks_;
    unsigned int pv_index_;
    unsigned int iterations_;
  };

}  // end namespace l1tVertexFinder

#endif