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/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"
 
template <typename T>
class TTClusterAssociationMap {
public:
  TTClusterAssociationMap();
 
  ~TTClusterAssociationMap();
 
 
  std::map<edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> >, std::vector<edm::Ptr<TrackingParticle> > >
  getTTClusterToTrackingParticlesMap() const {
    return clusterToTrackingParticleVectorMap;
  }
  std::map<edm::Ptr<TrackingParticle>, std::vector<edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > > >
  getTrackingParticleToTTClustersMap() const {
    return trackingParticleToClusterVectorMap;
  }
 
  void setTTClusterToTrackingParticlesMap(std::map<edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> >,
                                                   std::vector<edm::Ptr<TrackingParticle> > > aMap) {
    clusterToTrackingParticleVectorMap = aMap;
  }
  void setTrackingParticleToTTClustersMap(
      std::map<edm::Ptr<TrackingParticle>, std::vector<edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > > >
          aMap) {
    trackingParticleToClusterVectorMap = aMap;
  }
 
  std::vector<edm::Ptr<TrackingParticle> > findTrackingParticlePtrs(
      edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > aCluster) const;
  edm::Ptr<TrackingParticle> findTrackingParticlePtr(
      edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > aCluster) const;
  std::vector<edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > > findTTClusterRefs(
      edm::Ptr<TrackingParticle> aTrackingParticle) const;
 
  bool isGenuine(edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > aCluster) const;
  bool isCombinatoric(edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > aCluster) const;
  bool isUnknown(edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > aCluster) const;
 
private:
  std::map<edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> >, std::vector<edm::Ptr<TrackingParticle> > >
      clusterToTrackingParticleVectorMap;
  std::map<edm::Ptr<TrackingParticle>, std::vector<edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > > >
      trackingParticleToClusterVectorMap;
 
  int nclus;
 
};  
 
template <typename T>
TTClusterAssociationMap<T>::TTClusterAssociationMap() {
  clusterToTrackingParticleVectorMap.clear();
  trackingParticleToClusterVectorMap.clear();
  nclus = 0;
}
 
template <typename T>
TTClusterAssociationMap<T>::~TTClusterAssociationMap() {}
 
template <typename T>
std::vector<edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > >
TTClusterAssociationMap<T>::findTTClusterRefs(edm::Ptr<TrackingParticle> aTrackingParticle) const {
  if (trackingParticleToClusterVectorMap.find(aTrackingParticle) != trackingParticleToClusterVectorMap.end()) {
    return trackingParticleToClusterVectorMap.find(aTrackingParticle)->second;
  }
 
  std::vector<edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > > tempVector;
  tempVector.clear();
  return tempVector;
}
 
template <typename T>
std::vector<edm::Ptr<TrackingParticle> > TTClusterAssociationMap<T>::findTrackingParticlePtrs(
    edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > aCluster) const {
  if (clusterToTrackingParticleVectorMap.find(aCluster) != clusterToTrackingParticleVectorMap.end()) {
    return clusterToTrackingParticleVectorMap.find(aCluster)->second;
  }
 
  std::vector<edm::Ptr<TrackingParticle> > tempVector;
  tempVector.clear();
  return tempVector;
}
 
 
 
template <typename T>
bool TTClusterAssociationMap<T>::isGenuine(edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > aCluster) const {
  std::vector<edm::Ptr<TrackingParticle> > 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 edm::Ptr<TrackingParticle>& 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++) {
    edm::Ptr<TrackingParticle> 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(edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > aCluster) const {
  std::vector<edm::Ptr<TrackingParticle> > 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++) {
    edm::Ptr<TrackingParticle> 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(
    edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > aCluster) const {
  std::vector<edm::Ptr<TrackingParticle> > 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++) {
    edm::Ptr<TrackingParticle> 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);
}
 
template <typename T>
edm::Ptr<TrackingParticle> TTClusterAssociationMap<T>::findTrackingParticlePtr(
    edm::Ref<edmNew::DetSetVector<TTCluster<T> >, TTCluster<T> > aCluster) const {
  if (this->isGenuine(aCluster)) {
    return this->findTrackingParticlePtrs(aCluster).at(0);
  }
 
  edm::Ptr<TrackingParticle>* temp = new edm::Ptr<TrackingParticle>();
  return *temp;
}
 
#endif