TTClusterAssociationMap.h

Go to the documentation of this file.

#ifndef L1_TRACK_TRIGGER_CLUSTER_ASSOCIATION_FORMAT_H
#define L1_TRACK_TRIGGER_CLUSTER_ASSOCIATION_FORMAT_H

#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/Ptr.h"
#include "DataFormats/L1TrackTrigger/interface/TTTypes.h"
#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticleFwd.h"
#include "DataFormats/Common/interface/DetSet.h"
#include "DataFormats/Common/interface/DetSetVector.h"
#include "DataFormats/Common/interface/DetSetVectorNew.h"
#include "DataFormats/DetId/interface/DetId.h"
#include "DataFormats/Phase2TrackerDigi/interface/Phase2TrackerDigi.h"
#include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"  
#include "DataFormats/L1TrackTrigger/interface/TTCluster.h"
#include "SimDataFormats/TrackerDigiSimLink/interface/PixelDigiSimLink.h"
#include "SimDataFormats/Track/interface/SimTrack.h"
#include "SimDataFormats/Track/interface/SimTrackContainer.h"
#include "SimDataFormats/EncodedEventId/interface/EncodedEventId.h"
#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h"

// Templated aliases
template <typename T>
using MapClusToVecTP = std::map<TTClusterRefT<T>, std::vector<TrackingParticlePtr>>;
template <typename T>
using MapTPToVecClus = std::map<TrackingParticlePtr, std::vector<TTClusterRefT<T>>>;

template <typename T>
class TTClusterAssociationMap {
public:
  TTClusterAssociationMap();

  ~TTClusterAssociationMap();


  const MapClusToVecTP<T>& getTTClusterToTrackingParticlesMap() const { return clusterToTrackingParticleVectorMap_; }
  const MapTPToVecClus<T>& getTrackingParticleToTTClustersMap() const { return trackingParticleToClusterVectorMap_; }

  void setTTClusterToTrackingParticlesMap(const MapClusToVecTP<T>& aMap) { clusterToTrackingParticleVectorMap_ = aMap; }
  void setTrackingParticleToTTClustersMap(const MapTPToVecClus<T>& aMap) { trackingParticleToClusterVectorMap_ = aMap; }

  const std::vector<TrackingParticlePtr>& findTrackingParticlePtrs(TTClusterRefT<T> aCluster) const;

  const TrackingParticlePtr& findTrackingParticlePtr(TTClusterRefT<T> aCluster) const;

  // Get all clusters associated to TP.
  const std::vector<TTClusterRefT<T>>& findTTClusterRefs(TrackingParticlePtr aTrackingParticle) const;


  bool isGenuine(TTClusterRefT<T> aCluster) const;
  bool isUnknown(TTClusterRefT<T> aCluster) const;
  bool isCombinatoric(TTClusterRefT<T> aCluster) const;

private:
  MapClusToVecTP<T> clusterToTrackingParticleVectorMap_;
  MapTPToVecClus<T> trackingParticleToClusterVectorMap_;

  int nclus;

  // Allow functions to return reference to null.
  static const TrackingParticlePtr nullTrackingParticlePtr_;
  static const std::vector<TrackingParticlePtr> nullVecTrackingParticlePtr_;
  static const std::vector<TTClusterRefT<T>> nullVecClusterRef_;

};  

// Static constant data members.
template <typename T>
const TrackingParticlePtr TTClusterAssociationMap<T>::nullTrackingParticlePtr_;
template <typename T>
const std::vector<TrackingParticlePtr> TTClusterAssociationMap<T>::nullVecTrackingParticlePtr_;
template <typename T>
const std::vector<TTClusterRefT<T>> TTClusterAssociationMap<T>::nullVecClusterRef_;

template <typename T>
TTClusterAssociationMap<T>::TTClusterAssociationMap() {
  nclus = 0;
}

template <typename T>
TTClusterAssociationMap<T>::~TTClusterAssociationMap() {}

template <typename T>
const std::vector<TTClusterRefT<T>>& TTClusterAssociationMap<T>::findTTClusterRefs(
    TrackingParticlePtr aTrackingParticle) const {
  if (trackingParticleToClusterVectorMap_.find(aTrackingParticle) != trackingParticleToClusterVectorMap_.end()) {
    return trackingParticleToClusterVectorMap_.find(aTrackingParticle)->second;
  } else {
    return nullVecClusterRef_;
  }
}

template <typename T>
const std::vector<TrackingParticlePtr>& TTClusterAssociationMap<T>::findTrackingParticlePtrs(
    TTClusterRefT<T> aCluster) const {
  if (clusterToTrackingParticleVectorMap_.find(aCluster) != clusterToTrackingParticleVectorMap_.end()) {
    return clusterToTrackingParticleVectorMap_.find(aCluster)->second;
  } else {
    return nullVecTrackingParticlePtr_;
  }
}

template <typename T>
const TrackingParticlePtr& TTClusterAssociationMap<T>::findTrackingParticlePtr(TTClusterRefT<T> aCluster) const {
  if (this->isGenuine(aCluster)) {
    return this->findTrackingParticlePtrs(aCluster).at(0);
  } else {
    return nullTrackingParticlePtr_;
  }
}



template <typename T>
bool TTClusterAssociationMap<T>::isGenuine(TTClusterRefT<T> aCluster) const {
  const std::vector<TrackingParticlePtr>& theseTrackingParticles = this->findTrackingParticlePtrs(aCluster);

  if (theseTrackingParticles.empty())
    return false;

  unsigned int nullTPs = 0;
  unsigned int goodDifferentTPs = 0;
  std::vector<const TrackingParticle*> tpAddressVector;

  std::vector<float> tp_mom;

  float tp_tot = 0;

  for (const auto& tp : theseTrackingParticles) {
    const TrackingParticlePtr& curTP = tp;

    if (curTP.isNull()) {
      //      nullTPs++;
      tp_mom.push_back(0);
    } else {
      tp_mom.push_back(curTP.get()->p4().pt());
      tp_tot += curTP.get()->p4().pt();
    }
  }

  if (tp_tot == 0)
    return false;

  for (unsigned int itp = 0; itp < theseTrackingParticles.size(); itp++) {
    TrackingParticlePtr curTP = theseTrackingParticles.at(itp);

    if (tp_mom.at(itp) <= 0.01 * tp_tot) {
      nullTPs++;
    } else {
      tpAddressVector.push_back(curTP.get());
    }
  }

  std::sort(tpAddressVector.begin(), tpAddressVector.end());
  tpAddressVector.erase(std::unique(tpAddressVector.begin(), tpAddressVector.end()), tpAddressVector.end());
  goodDifferentTPs = tpAddressVector.size();

  return (goodDifferentTPs == 1);
}

template <typename T>
bool TTClusterAssociationMap<T>::isUnknown(TTClusterRefT<T> aCluster) const {
  const std::vector<TrackingParticlePtr>& theseTrackingParticles = this->findTrackingParticlePtrs(aCluster);

  if (theseTrackingParticles.empty())
    return true;

  unsigned int goodDifferentTPs = 0;
  std::vector<const TrackingParticle*> tpAddressVector;

  for (unsigned int itp = 0; itp < theseTrackingParticles.size(); itp++) {
    TrackingParticlePtr curTP = theseTrackingParticles.at(itp);

    if (!curTP.isNull()) {
      tpAddressVector.push_back(curTP.get());
    }
  }

  std::sort(tpAddressVector.begin(), tpAddressVector.end());
  tpAddressVector.erase(std::unique(tpAddressVector.begin(), tpAddressVector.end()), tpAddressVector.end());
  goodDifferentTPs = tpAddressVector.size();

  return (goodDifferentTPs == 0);
}

template <typename T>
bool TTClusterAssociationMap<T>::isCombinatoric(TTClusterRefT<T> aCluster) const {
  const std::vector<TrackingParticlePtr>& theseTrackingParticles = this->findTrackingParticlePtrs(aCluster);

  if (theseTrackingParticles.empty())
    return false;

  bool genuineClu = this->isGenuine(aCluster);
  bool unknownClu = this->isUnknown(aCluster);

  if (genuineClu || unknownClu)
    return false;

  return true;

  unsigned int nullTPs = 0;
  unsigned int goodDifferentTPs = 0;
  std::vector<const TrackingParticle*> tpAddressVector;

  for (unsigned int itp = 0; itp < theseTrackingParticles.size(); itp++) {
    TrackingParticlePtr curTP = theseTrackingParticles.at(itp);

    if (curTP.isNull()) {
      nullTPs++;
    } else {
      tpAddressVector.push_back(curTP.get());
    }
  }

  std::sort(tpAddressVector.begin(), tpAddressVector.end());
  tpAddressVector.erase(std::unique(tpAddressVector.begin(), tpAddressVector.end()), tpAddressVector.end());
  goodDifferentTPs = tpAddressVector.size();

  //return ( ( nullTPs == 0 && goodDifferentTPs > 1 ) || ( nullTPs > 0 && goodDifferentTPs > 0 ) );
  return (goodDifferentTPs > 1);
}

#endif