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