TTStubAssociationMap.h

Go to the documentation of this file.

#ifndef SimDataFormats_Associations_TTStubAssociationMap_h
#define SimDataFormats_Associations_TTStubAssociationMap_h

#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/RefProd.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/TTStub.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"
#include "SimDataFormats/Associations/interface/TTClusterAssociationMap.h"

// Templated aliases
template <typename T>
using MapStubToTP = std::map<TTStubRefT<T>, TrackingParticlePtr>;
template <typename T>
using MapTPToVecStub = std::map<TrackingParticlePtr, std::vector<TTStubRefT<T>>>;

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

  ~TTStubAssociationMap();


  const MapStubToTP<T>& getTTStubToTrackingParticleMap() const { return stubToTrackingParticleMap_; }
  const MapTPToVecStub<T>& getTrackingParticleToTTStubsMap() const { return trackingParticleToStubVectorMap_; }

  void setTTStubToTrackingParticleMap(const MapStubToTP<T>& aMap) { stubToTrackingParticleMap_ = aMap; }
  void setTrackingParticleToTTStubsMap(const MapTPToVecStub<T>& aMap) { trackingParticleToStubVectorMap_ = aMap; }

  void setTTClusterAssociationMap(edm::RefProd<TTClusterAssociationMap<T>> aCluAssoMap) {
    theClusterAssociationMap_ = aCluAssoMap;
  }

  const TrackingParticlePtr& findTrackingParticlePtr(TTStubRefT<T> aStub) const;

  const std::vector<TTStubRefT<T>>& findTTStubRefs(TrackingParticlePtr aTrackingParticle) const;



  bool isGenuine(TTStubRefT<T> aStub) const;
  bool isCombinatoric(TTStubRefT<T> aStub) const;
  bool isUnknown(TTStubRefT<T> aStub) const;

private:
  MapStubToTP<T> stubToTrackingParticleMap_;
  MapTPToVecStub<T> trackingParticleToStubVectorMap_;
  edm::RefProd<TTClusterAssociationMap<T>> theClusterAssociationMap_;

  // Allow functions to return reference to null.
  static const TrackingParticlePtr nullTrackingParticlePtr_;
  static const std::vector<TTStubRefT<T>> nullVecStubRef_;

};  

// Static constant data members.
template <typename T>
const TrackingParticlePtr TTStubAssociationMap<T>::nullTrackingParticlePtr_;
template <typename T>
const std::vector<TTStubRefT<T>> TTStubAssociationMap<T>::nullVecStubRef_;

template <typename T>
TTStubAssociationMap<T>::TTStubAssociationMap() {
}

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

template <typename T>
const TrackingParticlePtr& TTStubAssociationMap<T>::findTrackingParticlePtr(TTStubRefT<T> aStub) const {
  if (stubToTrackingParticleMap_.find(aStub) != stubToTrackingParticleMap_.end()) {
    return stubToTrackingParticleMap_.find(aStub)->second;
  } else {
    return nullTrackingParticlePtr_;
  }
}

template <typename T>
const std::vector<TTStubRefT<T>>& TTStubAssociationMap<T>::findTTStubRefs(TrackingParticlePtr aTrackingParticle) const {
  if (trackingParticleToStubVectorMap_.find(aTrackingParticle) != trackingParticleToStubVectorMap_.end()) {
    return trackingParticleToStubVectorMap_.find(aTrackingParticle)->second;
  } else {
    return nullVecStubRef_;
  }
}

template <typename T>
bool TTStubAssociationMap<T>::isGenuine(TTStubRefT<T> aStub) const {
  if ((this->findTrackingParticlePtr(aStub)).isNull())
    return false;

  return true;
}

template <typename T>
bool TTStubAssociationMap<T>::isCombinatoric(TTStubRefT<T> aStub) const {
  if (this->isGenuine(aStub))
    return false;

  if (this->isUnknown(aStub))
    return false;

  return true;
}

template <typename T>
bool TTStubAssociationMap<T>::isUnknown(TTStubRefT<T> aStub) const {

  if (theClusterAssociationMap_.isNull()) {
    return true;
  }

  if (theClusterAssociationMap_->isUnknown(aStub->clusterRef(0)) &&
      theClusterAssociationMap_->isUnknown(aStub->clusterRef(1)))
    return true;

  return false;
}

#endif