TTTrackAssociator< T > Class Template Reference

Plugin to create the MC truth for TTTracks. More...

#include <TTTrackAssociator.h>

Inheritance diagram for TTTrackAssociator< T >:

Public Member Functions
	TTTrackAssociator (const edm::ParameterSet &iConfig)
	Constructors. More...
	~TTTrackAssociator () override
	Destructor. More...
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

Private Member Functions
void	beginRun (const edm::Run &run, const edm::EventSetup &iSetup) override
	Mandatory methods. More...
void	endRun (const edm::Run &run, const edm::EventSetup &iSetup) override
	End run. More...
template<>
void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup)
	More...
template<>
void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup)
	Implement the producer. More...
void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup) override

Private Attributes
edm::EDGetTokenT< TTClusterAssociationMap< T > >	TTClusterTruthToken
edm::EDGetTokenT< TTStubAssociationMap< T > >	TTStubTruthToken
bool	TTTrackAllowOneFalse2SStub
std::vector< edm::InputTag >	TTTracksInputTags
	Data members. More...
std::vector< edm::EDGetTokenT< std::vector< TTTrack< T > > > >	TTTracksTokens

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

template<typename T>
class TTTrackAssociator< T >

Plugin to create the MC truth for TTTracks.

After moving from SimDataFormats to DataFormats, the template structure of the class was maintained in order to accomodate any types other than PixelDigis in case there is such a need in the future.

Author

Nicola Pozzobon

Date

2013, Jul 19

Definition at line 40 of file TTTrackAssociator.h.

Constructor & Destructor Documentation

TTTrackAssociator()

template<typename T >

TTTrackAssociator< T >::TTTrackAssociator ( const edm::ParameterSet &  iConfig )

explicit

Constructors.

Close class.

NOTE since pattern hit correlation must be performed within a stacked module, one must store Clusters in a proper way, providing easy access to them in a detector/member-wise way

Implementation of methods

Here, in the header file, the methods which do not depend on the specific type <T> that can fit the template. Other methods, with type-specific features, are implemented in the source file. Constructors

Definition at line 77 of file TTTrackAssociator.h.

                                                                      {
  TTTracksInputTags = iConfig.getParameter<std::vector<edm::InputTag> >("TTTracks");
  TTClusterTruthToken = consumes<TTClusterAssociationMap<T> >(iConfig.getParameter<edm::InputTag>("TTClusterTruth"));
  TTStubTruthToken = consumes<TTStubAssociationMap<T> >(iConfig.getParameter<edm::InputTag>("TTStubTruth"));
  TTTrackAllowOneFalse2SStub = iConfig.getParameter<bool>("TTTrackAllowOneFalse2SStub");
  if (TTTrackAllowOneFalse2SStub) {
    edm::LogInfo("TTTrackAssociator< ") << "Allow track if no more than one 2S stub doesn't match truth.";
  } else {
    edm::LogInfo("TTTrackAssociator< ") << "All 2S stubs must match truth.";
  }
 
  for (auto iTag = TTTracksInputTags.begin(); iTag != TTTracksInputTags.end(); iTag++) {
    TTTracksTokens.push_back(consumes<std::vector<TTTrack<T> > >(*iTag));
 
    produces<TTTrackAssociationMap<T> >((*iTag).instance());
  }
}

References edm::ParameterSet::getParameter(), and TTTrackAssociation_cfi::TTTrackAllowOneFalse2SStub.

~TTTrackAssociator()

template<typename T >

TTTrackAssociator< T >::~TTTrackAssociator ( )

override

Destructor.

Definition at line 97 of file TTTrackAssociator.h.

{}

Member Function Documentation

beginRun()

template<typename T >

void TTTrackAssociator< T >::beginRun ( const edm::Run &  run, const edm::EventSetup &  iSetup  )

overrideprivate

Mandatory methods.

Begin run.

Print some information when loaded

Definition at line 101 of file TTTrackAssociator.h.

                                                                                  {
  edm::LogInfo("TTStubAssociator< ") << "TTTrackAssociator< " << templateNameFinder<T>() << " > loaded.";
}

endRun()

template<typename T >

void TTTrackAssociator< T >::endRun ( const edm::Run &  run, const edm::EventSetup &  iSetup  )

overrideprivate

End run.

Definition at line 108 of file TTTrackAssociator.h.

{}

produce() [1/3]

template<>

void TTTrackAssociator< Ref_Phase2TrackerDigi_ >::produce ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

private

Here, in the source file, the methods which do depend on the specific type <T> that can fit the template.

Author

Nicola Pozzobon

Date

2013, Jul 19 Implement the producer

Exit if real data

Get the Stub and Cluster MC truth

Loop over InputTags to handle multiple collections

Prepare output

Get the Tracks already stored away

Prepare the necessary maps

Counter needed to build the edm::Ptr to the TTTrack

Make the pointer to be put in the map

Get the stubs of the TTTrack (theseStubs)

Auxiliary map to store TP addresses and TP edm::Ptr

Fill the inclusive map which is careless of the stub classification

Prepare the maps wrt TrackingParticle

Fill the auxiliary map

Fill the other auxiliary map

End of loop over the clusters

Check if the stub is unknown

End of loop over the stubs

If there more than 2 unknown stubs, go to the next track as this track may be COMBINATORIC or UNKNOWN

If we are here, all the stubs are either combinatoric or genuine and there is no more than one fake stub in the track Loop over all the TrackingParticle which have been found in the track at some point (stored in auxMap)

Get all the stubs from this TrackingParticle

Loop over the stubs

We want that all the stubs of the track are included in the container of all the stubs produced by this particular TrackingParticle which we already know is one of the TrackingParticles that released hits in this track we are evaluating right now

If the TrackingParticle does not appear in all stubs but one then go to the next track

If we are here, it means that the TrackingParticle generates hits in all stubs but one of the current track so put it into the vector

Count how many TrackingParticles we do have

If only one TrackingParticle, GENUINE if different than one, COMBINATORIC

Here, the track may only be GENUINE Fill the map

End of loop over Tracks

Clean the only map that needs cleaning Prepare the output map wrt TrackingParticle

Get the vector of edm::Ptr< TTTrack >

Sort and remove duplicates

Also, create the pointer to the TTClusterAssociationMap

Put the maps in the association object

Put output in the event

End of loop over InputTags

Definition at line 14 of file TTTrackAssociator.cc.

                                                                                                     {
  if (iEvent.isRealData())
    return;
 
  edm::Handle<TTClusterAssociationMap<Ref_Phase2TrackerDigi_>> TTClusterAssociationMapHandle;
  iEvent.getByToken(TTClusterTruthToken, TTClusterAssociationMapHandle);
  edm::Handle<TTStubAssociationMap<Ref_Phase2TrackerDigi_>> TTStubAssociationMapHandle;
  iEvent.getByToken(TTStubTruthToken, TTStubAssociationMapHandle);
 
  int ncont1 = 0;
 
  for (auto iTag = TTTracksTokens.begin(); iTag != TTTracksTokens.end(); iTag++) {
    auto associationMapForOutput = std::make_unique<TTTrackAssociationMap<Ref_Phase2TrackerDigi_>>();
 
    edm::Handle<std::vector<TTTrack<Ref_Phase2TrackerDigi_>>> TTTrackHandle;
    iEvent.getByToken(*iTag, TTTrackHandle);
 
    std::map<edm::Ptr<TTTrack<Ref_Phase2TrackerDigi_>>, edm::Ptr<TrackingParticle>> trackToTrackingParticleMap;
    std::map<edm::Ptr<TrackingParticle>, std::vector<edm::Ptr<TTTrack<Ref_Phase2TrackerDigi_>>>>
        trackingParticleToTrackVectorMap;
    trackToTrackingParticleMap.clear();
    trackingParticleToTrackVectorMap.clear();
 
    // Start the loop on tracks
 
    unsigned int j = 0;  
    typename std::vector<TTTrack<Ref_Phase2TrackerDigi_>>::const_iterator inputIter;
    for (inputIter = TTTrackHandle->begin(); inputIter != TTTrackHandle->end(); ++inputIter) {
      edm::Ptr<TTTrack<Ref_Phase2TrackerDigi_>> tempTrackPtr(TTTrackHandle, j++);
 
      std::vector<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>>>
          theseStubs = tempTrackPtr->getStubRefs();
 
      std::map<const TrackingParticle*, edm::Ptr<TrackingParticle>> auxMap;
      auxMap.clear();
      int mayCombinUnknown = 0;
 
      for (unsigned int is = 0; is < theseStubs.size(); is++) {
        //        std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< Ref_Phase2TrackerDigi_ > >, TTCluster< Ref_Phase2TrackerDigi_ > > > theseClusters = theseStubs.at(is)->getClusterRefs();
        for (unsigned int ic = 0; ic < 2; ic++) {
          std::vector<edm::Ptr<TrackingParticle>> tempTPs =
              TTClusterAssociationMapHandle->findTrackingParticlePtrs(theseStubs.at(is)->clusterRef(ic));
          for (unsigned int itp = 0; itp < tempTPs.size(); itp++)  // List of TPs linked to stub clusters
          {
            edm::Ptr<TrackingParticle> testTP = tempTPs.at(itp);
 
            if (testTP.isNull())  // No TP linked to this cluster
              continue;
 
            if (trackingParticleToTrackVectorMap.find(testTP) == trackingParticleToTrackVectorMap.end()) {
              std::vector<edm::Ptr<TTTrack<Ref_Phase2TrackerDigi_>>> trackVector;
              trackVector.clear();
              trackingParticleToTrackVectorMap.insert(std::make_pair(testTP, trackVector));
            }
            trackingParticleToTrackVectorMap.find(testTP)->second.push_back(tempTrackPtr);  
 
            if (auxMap.find(testTP.get()) == auxMap.end()) {
              auxMap.insert(std::make_pair(testTP.get(), testTP));
            }
          }
        }  
 
        if (TTStubAssociationMapHandle->isUnknown(theseStubs.at(is)))
          ++mayCombinUnknown;
 
      }  
 
      if (mayCombinUnknown >= 2)
        continue;
 
 
      std::vector<const TrackingParticle*> tpInAllStubs;
 
      std::map<const TrackingParticle*, edm::Ptr<TrackingParticle>>::const_iterator iterAuxMap;
      for (iterAuxMap = auxMap.begin(); iterAuxMap != auxMap.end(); ++iterAuxMap) {
        std::vector<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>>>
            tempStubs = TTStubAssociationMapHandle->findTTStubRefs(iterAuxMap->second);
 
        int nnotfound = 0;
        //bool allFound = true;
        //        for ( unsigned int js = 0; js < theseStubs.size() && allFound; js++ )
        for (unsigned int js = 0; js < theseStubs.size(); js++) {
          if (std::find(tempStubs.begin(), tempStubs.end(), theseStubs.at(js)) == tempStubs.end()) {
            //  allFound = false;
            ++nnotfound;
          }
        }
 
        if (nnotfound > 1)
          //if (!allFound)
          continue;
 
        tpInAllStubs.push_back(iterAuxMap->first);
      }
 
      std::sort(tpInAllStubs.begin(), tpInAllStubs.end());
      tpInAllStubs.erase(std::unique(tpInAllStubs.begin(), tpInAllStubs.end()), tpInAllStubs.end());
      unsigned int nTPs = tpInAllStubs.size();
 
      if (nTPs != 1)
        continue;
 
      trackToTrackingParticleMap.insert(std::make_pair(tempTrackPtr, auxMap.find(tpInAllStubs.at(0))->second));
 
    }  
 
    typename std::map<edm::Ptr<TrackingParticle>, std::vector<edm::Ptr<TTTrack<Ref_Phase2TrackerDigi_>>>>::iterator
        iterMapToClean;
    for (iterMapToClean = trackingParticleToTrackVectorMap.begin();
         iterMapToClean != trackingParticleToTrackVectorMap.end();
         ++iterMapToClean) {
      std::vector<edm::Ptr<TTTrack<Ref_Phase2TrackerDigi_>>> tempVector = iterMapToClean->second;
 
      std::sort(tempVector.begin(), tempVector.end());
      tempVector.erase(std::unique(tempVector.begin(), tempVector.end()), tempVector.end());
 
      iterMapToClean->second = tempVector;
    }
 
    edm::RefProd<TTStubAssociationMap<Ref_Phase2TrackerDigi_>> theStubAssoMap(TTStubAssociationMapHandle);
 
    associationMapForOutput->setTTTrackToTrackingParticleMap(trackToTrackingParticleMap);
    associationMapForOutput->setTrackingParticleToTTTracksMap(trackingParticleToTrackVectorMap);
    associationMapForOutput->setTTStubAssociationMap(theStubAssoMap);
    associationMapForOutput->setAllowOneFalse2SStub(TTTrackAllowOneFalse2SStub);
 
    iEvent.put(std::move(associationMapForOutput), TTTracksInputTags.at(ncont1).instance());
 
    ++ncont1;
  }  
}

References spr::find(), edm::Ptr< T >::get(), iEvent, edm::Ptr< T >::isNull(), dqmiolumiharvest::j, eostools::move(), edm::second(), TTTrackAssociation_cfi::TTTrackAllowOneFalse2SStub, and tier0::unique().

produce() [2/3]

template<>

void TTTrackAssociator< Ref_Phase2TrackerDigi_ >::produce ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

private

Implement the producer.

produce() [3/3]

template<typename T >

void TTTrackAssociator< T >::produce ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

overrideprivate

Member Data Documentation

TTClusterTruthToken

template<typename T >

edm::EDGetTokenT<TTClusterAssociationMap<T> > TTTrackAssociator< T >::TTClusterTruthToken

private

Definition at line 57 of file TTTrackAssociator.h.

TTStubTruthToken

template<typename T >

edm::EDGetTokenT<TTStubAssociationMap<T> > TTTrackAssociator< T >::TTStubTruthToken

private

Definition at line 56 of file TTTrackAssociator.h.

TTTrackAllowOneFalse2SStub

template<typename T >

bool TTTrackAssociator< T >::TTTrackAllowOneFalse2SStub

private

Definition at line 59 of file TTTrackAssociator.h.

TTTracksInputTags

template<typename T >

std::vector<edm::InputTag> TTTrackAssociator< T >::TTTracksInputTags

private

Data members.

Definition at line 52 of file TTTrackAssociator.h.

TTTracksTokens

template<typename T >

std::vector<edm::EDGetTokenT<std::vector<TTTrack<T> > > > TTTrackAssociator< T >::TTTracksTokens

private

Definition at line 54 of file TTTrackAssociator.h.