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