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	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () 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)

void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup) override

template<>
void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup)
	Implement the producer. More...

Private Attributes
edm::EDGetTokenT< TTClusterAssociationMap< T > >	TTClusterTruthToken

edm::EDGetTokenT< TTStubAssociationMap< T > >	TTStubTruthToken

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

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 80 of file TTTrackAssociator.h.

References edm::ParameterSet::getParameter(), TTTrackAssociator< T >::TTClusterTruthToken, TTTrackAssociator< T >::TTStubTruthToken, TTTrackAssociator< T >::TTTracksInputTags, and TTTrackAssociator< T >::TTTracksTokens.

 {
   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" ));
 
   for ( auto iTag =  TTTracksInputTags.begin(); iTag!=  TTTracksInputTags.end(); iTag++ )
   {
     TTTracksTokens.push_back(consumes< std::vector< TTTrack< T > > >(*iTag));
 
     produces< TTTrackAssociationMap< T > >( (*iTag).instance() );
   }
 }

template<typename T >

TTTrackAssociator< T >::~TTTrackAssociator ( )

override

Destructor.

Definition at line 96 of file TTTrackAssociator.h.

96 {}

Member Function Documentation

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 100 of file TTTrackAssociator.h.

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

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.

References iEvent, and TTTrackAssociator< T >::produce().

108 {}

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 19Implement 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.

References spr::find(), edm::Ptr< T >::get(), edm::Event::getByToken(), edm::Ptr< T >::isNull(), edm::EventBase::isRealData(), eostools::move(), edm::Event::put(), edm::second(), and tier0::unique().

 {
   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)->getClusterRef(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 );
 
     iEvent.put( std::move(associationMapForOutput), TTTracksInputTags.at(ncont1).instance() );
 
     ++ncont1;
   } 
 }