Replacement for TrackingTruthProducer in the new pileup mixing setup. More...

#include <TrackingTruthAccumulator.h>

Inheritance diagram for TrackingTruthAccumulator:

Classes
struct	OutputCollections

Public Member Functions
	TrackingTruthAccumulator (const edm::ParameterSet &config, edm::stream::EDProducerBase &mixMod, edm::ConsumesCollector &iC)

Public Member Functions inherited from DigiAccumulatorMixMod
virtual void	accumulate (edm::Event const &event, edm::EventSetup const &setup)=0

virtual void	accumulate (PileUpEventPrincipal const &event, edm::EventSetup const &setup, edm::StreamID const &)=0

virtual void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup)

virtual void	beginRun (edm::Run const &run, edm::EventSetup const &setup)

	DigiAccumulatorMixMod ()

virtual void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup)

virtual void	endRun (edm::Run const &run, edm::EventSetup const &setup)

virtual void	finalizeBunchCrossing (edm::Event &event, edm::EventSetup const &setup, int bunchCrossing)

virtual void	finalizeEvent (edm::Event &event, edm::EventSetup const &setup)=0

virtual PileupMixingContent *	getEventPileupInfo ()

virtual void	initializeBunchCrossing (edm::Event const &event, edm::EventSetup const &setup, int bunchCrossing)

virtual void	initializeEvent (edm::Event const &event, edm::EventSetup const &setup)=0

virtual void	StorePileupInformation (std::vector< int > &numInteractionList, std::vector< int > &bunchCrossingList, std::vector< float > &TrueInteractionList, std::vector< edm::EventID > &eventList, int bunchSpace)

virtual	~DigiAccumulatorMixMod ()

Private Member Functions
virtual void	accumulate (const edm::Event &event, const edm::EventSetup &setup)

virtual void	accumulate (const PileUpEventPrincipal &event, const edm::EventSetup &setup, edm::StreamID const &)

template<class T >
void	accumulateEvent (const T &event, const edm::EventSetup &setup, const edm::Handle< edm::HepMCProduct > &hepMCproduct)
	Both forms of accumulate() delegate to this templated method. More...

template<class T >
void	fillSimHits (std::vector< const PSimHit * > &returnValue, const T &event, const edm::EventSetup &setup)
	Fills the supplied vector with pointers to the SimHits, checking for bad modules if required. More...

virtual void	finalizeEvent (edm::Event &event, const edm::EventSetup &setup)

virtual void	initializeEvent (const edm::Event &event, const edm::EventSetup &setup)

Private Attributes
const bool	addAncestors_
	Whether or not to add the full parentage of any TrackingParticle that is inserted in the collection. More...

bool	allowDifferentProcessTypeForDifferentDetectors_
	When counting hits, allows hits in different detectors to have a different process type. More...

bool	chargedOnly_
	Uses the same config as selector_, but can be used to drop out early since selector_ requires the TrackingParticle to be created first. More...

std::vector< edm::InputTag >	collectionTags_

const bool	createInitialVertexCollection_
	Whether or not to create a separate collection for just the initial interaction vertices. More...

const bool	createMergedCollection_

const bool	createUnmergedCollection_
	If bremsstrahlung merging, whether to also add the unmerged collection to the event or not. More...

edm::InputTag	genParticleLabel_

edm::InputTag	hepMCproductLabel_
	Needed to add HepMC::GenVertex to SimVertex. More...

const bool	ignoreTracksOutsideVolume_

const unsigned int	maximumPreviousBunchCrossing_

const unsigned int	maximumSubsequentBunchCrossing_

OutputCollections	mergedOutput_

const std::string	messageCategory_
	The message category used to send messages to MessageLogger. More...

std::unique_ptr< TrackingVertexCollection >	pInitialVertices_

const bool	removeDeadModules_
	As of 11/Feb/2013 this option hasn't been implemented yet. More...

TrackingParticleSelector	selector_

bool	selectorFlag_

bool	signalOnly_
	Uses the same config as selector_, but can be used to drop out early since selector_ requires the TrackingParticle to be created first. More...

const edm::InputTag	simTrackLabel_

const edm::InputTag	simVertexLabel_

OutputCollections	unmergedOutput_

const double	vertexDistanceCut_
	maximum distance for HepMC::GenVertex to be added to SimVertex More...

const double	volumeRadius_

const double	volumeZ_

Detailed Description

Replacement for TrackingTruthProducer in the new pileup mixing setup.

The configuration parameters are:

Parameter name	Type	Description
volumeRadius	double	The volume radius in cm used if ignoreTracksOutsideVolume is true.
volumeZ	double	The volume z in cm used if ignoreTracksOutsideVolume is true.
ignoreTracksOutsideVolume	bool	If true, sim tracks that have a production vertex outside the volume specified by volumeRadius and volumeZ won't be turned into TrackingParticles. Doesn't make much difference to be honest, over a huge range of volume sizes so there must be a cut earlier in the simulation.
maximumPreviousBunchCrossing	unsigned int	Bunch crossings before this number (inclusive; use positive integer) won't be included. Setting to zero means only in-time.
maximumSubsequentBunchCrossing	unsigned int	Bunch crossings after this won't create any TrackingParticles.
createUnmergedCollection	bool	Whether to create the TrackingParticle collection without bremsstrahlung merged.
createMergedBremsstrahlung	bool	Whether to create the TrackingParticle collection with bremsstrahlung merged. At least one of createUnmergedCollection or createMergedBremsstrahlung should be true otherwise nothing will be produced.
createInitialVertexCollection	bool	Whether to create a collection of just the initial vertices. You can usually get this information from one of the other collections (merged or unmerged bremsstrahlung), but for this collection no selection is applied. Hence you will always have all of the initial vertices regardless of how tightly you select TrackingParticles with the "select" parameter. Note that the collection will have no links to the products of these vertices. If you want to know what came off these vertices you will have to look in one of the other collections. The name of the collection will be "InitialVertices".
alwaysAddAncestors	bool	If a sim track passes selection and is turned into a TrackingParticle, all of it's parents will also be created even if they fail the selection. This was the default behaviour for the old TrackingParticleProducer.
removeDeadModules	bool	Hasn't been implemented yet (as of 22/May/2013).
simTrackCollection	edm::InputTag	The input SimTrack collection
simVertexCollection	edm::InputTag	The input SimVerted collection
simHitCollections	edm::ParameterSet	A ParameterSet of vectors of InputTags that are the input PSimHits
genParticleCollection	edm::InputTag	The input reco::GenParticle collection. Note that there's a difference between reco::GenParticle and HepMC::GenParticle; the old TrackingTruthProducer used to use HepMC::GenParticle.
allowDifferentSimHitProcesses	bool	Should be false for FullSim and true for FastSim. There's more documentation in the code if you're really interested.
select	edm::ParameterSet	A ParameterSet used to configure a TrackingParticleSelector. If the TrackingParticle doesn't pass this selector then it's not added to the output.

Author: Mark Grimes (mark..nosp@m.grim.nosp@m.es@br.nosp@m.isto.nosp@m.l.ac..nosp@m.uk)

Date
11/Oct/2012

Definition at line 75 of file TrackingTruthAccumulator.h.

Constructor & Destructor Documentation

TrackingTruthAccumulator::TrackingTruthAccumulator	(	const edm::ParameterSet &	config,
		edm::stream::EDProducerBase &	mixMod,
		edm::ConsumesCollector &	iC
	)

explicit

Definition at line 224 of file TrackingTruthAccumulator.cc.

References chargedOnly_, collectionTags_, edm::ConsumesCollector::consumes(), createInitialVertexCollection_, createMergedCollection_, createUnmergedCollection_, edm::ParameterSet::exists(), genParticleLabel_, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), edm::ParameterSet::getParameterSet(), hepMCproductLabel_, messageCategory_, selector_, selectorFlag_, signalOnly_, simTrackLabel_, and simVertexLabel_.

                                                                                                                                              :
         messageCategory_("TrackingTruthAccumulator"),
         volumeRadius_( config.getParameter<double>("volumeRadius") ),
         volumeZ_( config.getParameter<double>("volumeZ") ),
         vertexDistanceCut_( config.getParameter<double>("vertexDistanceCut") ),
         ignoreTracksOutsideVolume_( config.getParameter<bool>("ignoreTracksOutsideVolume") ),
         maximumPreviousBunchCrossing_( config.getParameter<unsigned int>("maximumPreviousBunchCrossing") ),
         maximumSubsequentBunchCrossing_( config.getParameter<unsigned int>("maximumSubsequentBunchCrossing") ),
         createUnmergedCollection_( config.getParameter<bool>("createUnmergedCollection") ),
         createMergedCollection_(config.getParameter<bool>("createMergedBremsstrahlung") ),
         createInitialVertexCollection_(config.getParameter<bool>("createInitialVertexCollection") ),
         addAncestors_( config.getParameter<bool>("alwaysAddAncestors") ),
         removeDeadModules_( config.getParameter<bool>("removeDeadModules") ),
         simTrackLabel_( config.getParameter<edm::InputTag>("simTrackCollection") ),
         simVertexLabel_( config.getParameter<edm::InputTag>("simVertexCollection") ),
         collectionTags_( ),
         genParticleLabel_( config.getParameter<edm::InputTag>("genParticleCollection") ),
         hepMCproductLabel_( config.getParameter<edm::InputTag>("HepMCProductLabel") ),
         allowDifferentProcessTypeForDifferentDetectors_( config.getParameter<bool>("allowDifferentSimHitProcesses") )
 {
     //
     // Make sure at least one of the merged and unmerged collections have been set
     // to be created.
     //
     if( !createUnmergedCollection_ && !createMergedCollection_ )
         edm::LogError(messageCategory_) << "Both \"createUnmergedCollection\" and \"createMergedBremsstrahlung\" have been"
             << "set to false, which means no collections will be created";
 
     // Initialize selection for building TrackingParticles
     //
     if( config.exists( "select" ) )
     {
         edm::ParameterSet param=config.getParameter<edm::ParameterSet>("select");
         selector_=TrackingParticleSelector( param.getParameter<double>( "ptMinTP" ),
                 param.getParameter<double>( "ptMaxTP" ),
                 param.getParameter<double>( "minRapidityTP" ),
                 param.getParameter<double>( "maxRapidityTP" ),
                 param.getParameter<double>( "tipTP" ),
                 param.getParameter<double>( "lipTP" ),
                 param.getParameter<int>( "minHitTP" ),
                 param.getParameter<bool>( "signalOnlyTP" ),
                 param.getParameter<bool>( "intimeOnlyTP" ),
                 param.getParameter<bool>( "chargedOnlyTP" ),
                 param.getParameter<bool>( "stableOnlyTP" ),
                 param.getParameter<std::vector<int> >("pdgIdTP") );
         selectorFlag_=true;
 
         // Also set these two variables, which are used to drop out early if the SimTrack doesn't conform.
         // The selector_ requires a full TrackingParticle object, but these two variables can veto things early.
         chargedOnly_=param.getParameter<bool>( "chargedOnlyTP" );
         signalOnly_=param.getParameter<bool>( "signalOnlyTP" );
     }
     else
     {
         selectorFlag_=false;
         chargedOnly_=false;
         signalOnly_=false;
     }
 
     //
     // Need to state what collections are going to be added to the event. This
     // depends on which of the merged and unmerged collections have been configured
     // to be created.
     //
     if( createUnmergedCollection_ )
     {
         mixMod.produces<TrackingVertexCollection>();
         mixMod.produces<TrackingParticleCollection>();
     }
 
     if( createMergedCollection_ )
     {
         mixMod.produces<TrackingParticleCollection>("MergedTrackTruth");
         mixMod.produces<TrackingVertexCollection>("MergedTrackTruth");
     }
 
     if( createInitialVertexCollection_ )
     {
         mixMod.produces<TrackingVertexCollection>("InitialVertices");
     }
 
     iC.consumes<std::vector<SimTrack> >(simTrackLabel_);
     iC.consumes<std::vector<SimVertex> >(simVertexLabel_);
     iC.consumes<std::vector<reco::GenParticle> >(genParticleLabel_);
     iC.consumes<std::vector<int> >(genParticleLabel_);
     iC.consumes<std::vector<int> >(hepMCproductLabel_);
 
     // Fill the collection tags
         const edm::ParameterSet& simHitCollectionConfig=config.getParameterSet("simHitCollections");
     std::vector<std::string> parameterNames=simHitCollectionConfig.getParameterNames();
 
     for( const auto& parameterName : parameterNames )
     {
            std::vector<edm::InputTag> tags=simHitCollectionConfig.getParameter<std::vector<edm::InputTag> >(parameterName);
            collectionTags_.insert(collectionTags_.end(), tags.begin(), tags.end());
         }
 
     for( const auto& collectionTag : collectionTags_ ) {
       iC.consumes<std::vector<PSimHit> >(collectionTag);
         }
 
 }

Member Function Documentation

virtual void TrackingTruthAccumulator::accumulate	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

privatevirtual

Referenced by initializeEvent().

virtual void TrackingTruthAccumulator::accumulate	(	const PileUpEventPrincipal &	event,
		const edm::EventSetup &	setup,
		edm::StreamID const &
	)

privatevirtual

template<class T >

void TrackingTruthAccumulator::accumulateEvent	(	const T &	event,
		const edm::EventSetup &	setup,
		const edm::Handle< edm::HepMCProduct > &	hepMCproduct
	)

private

Both forms of accumulate() delegate to this templated method.

Definition at line 409 of file TrackingTruthAccumulator.cc.

References addAncestors_, allowDifferentProcessTypeForDifferentDetectors_, EncodedEventId::bunchCrossing(), CoreSimTrack::charge(), chargedOnly_, createInitialVertexCollection_, createMergedCollection_, createUnmergedCollection_, EncodedEventId::event(), CoreSimTrack::eventId(), cppFunctionSkipper::exception, fillSimHits(), genParticleLabel_, edm::EventSetup::get(), ignoreTracksOutsideVolume_, diffTreeTool::index, mergedOutput_, NULL, pInitialVertices_, CoreSimVertex::position(), edm::ESHandle< T >::product(), selector_, selectorFlag_, signalOnly_, simTrackMatching_cfi::simTrack, simTrackLabel_, ecalDetailedTimeRecHit_cfi::simVertex, simVertexLabel_, unmergedOutput_, vertexDistanceCut_, SimVertex::vertexId(), volumeRadius_, and volumeZ_.

Referenced by initializeEvent().

 {
     //
     // Get the collections
     //
     edm::Handle<std::vector<SimTrack> > hSimTracks;
     edm::Handle<std::vector<SimVertex> > hSimVertices;
     edm::Handle< std::vector<reco::GenParticle> > hGenParticles;
     edm::Handle< std::vector<int> > hGenParticleIndices;
 
     event.getByLabel( simTrackLabel_, hSimTracks );
     event.getByLabel( simVertexLabel_, hSimVertices );
 
     try
     {
         event.getByLabel( genParticleLabel_, hGenParticles );
         event.getByLabel( genParticleLabel_, hGenParticleIndices );
     }
     catch( cms::Exception& exception )
     {
         //
         // The Monte Carlo is not always available, e.g. for pileup events. The information
         // is only used if it's available, but for some reason the PileUpEventPrincipal
         // wrapper throws an exception here rather than waiting to see if the handle is
         // used (as is the case for edm::Event). So I just want to catch this exception
         // and use the normal handle checking later on.
         //
     }
 
     //Retrieve tracker topology from geometry
     edm::ESHandle<TrackerTopology> tTopoHandle;
     setup.get<TrackerTopologyRcd>().get(tTopoHandle);
     const TrackerTopology* const tTopo = tTopoHandle.product();
 
 
     // Run through the collections and work out the decay chain of each track/vertex. The
     // information in SimTrack and SimVertex only allows traversing upwards, but this will
     // allow traversal in both directions. This is required for things like grouping electrons
     // that bremsstrahlung as one TrackingParticle if "mergedBremsstrahlung" is set in the
     // config file.
     DecayChain decayChain( *hSimTracks, *hSimVertices );
 
     // I only want to create these collections if they're actually required
     std::unique_ptr< ::OutputCollectionWrapper> pUnmergedCollectionWrapper;
     std::unique_ptr< ::OutputCollectionWrapper> pMergedCollectionWrapper;
     if( createUnmergedCollection_ ) pUnmergedCollectionWrapper.reset( new ::OutputCollectionWrapper( decayChain, unmergedOutput_ ) );
     if( createMergedCollection_ ) pMergedCollectionWrapper.reset( new ::OutputCollectionWrapper( decayChain, mergedOutput_ ) );
 
     std::vector<const PSimHit*> simHitPointers;
     fillSimHits( simHitPointers, event, setup );
     TrackingParticleFactory objectFactory( decayChain, hGenParticles, hepMCproduct, hGenParticleIndices, simHitPointers, volumeRadius_, volumeZ_, vertexDistanceCut_, allowDifferentProcessTypeForDifferentDetectors_ );
 
 #if defined(DO_DEBUG_TESTING)
     // While I'm testing, perform some checks.
     // TODO - drop this call once I'm happy it works in all situations.
     decayChain.integrityCheck();
 #endif
 
     TrackingParticleSelector* pSelector=NULL;
     if( selectorFlag_ ) pSelector=&selector_;
 
     // Run over all of the SimTracks, but because I'm interested in the decay hierarchy
     // do it through the DecayChainTrack objects. These are looped over in sequence here
     // but they have the hierarchy information for the functions called to traverse the
     // decay chain.
 
     for( size_t index=0; index<decayChain.decayTracksSize; ++index )
     {
         ::DecayChainTrack* pDecayTrack=&decayChain.decayTracks[index];
         const SimTrack& simTrack=hSimTracks->at(pDecayTrack->simTrackIndex);
 
 
         // Perform some quick checks to see if we can drop out early. Note that these are
         // a subset of the cuts in the selector_ so the created TrackingParticle could still
         // fail. The selector_ requires the full TrackingParticle to be made however, which
         // can be computationally expensive.
         if( chargedOnly_ && simTrack.charge()==0 ) continue;
         if( signalOnly_ && (simTrack.eventId().bunchCrossing()!=0 || simTrack.eventId().event()!=0) ) continue;
 
         // Also perform a check to see if the production vertex is inside the tracker volume (if required).
         if( ignoreTracksOutsideVolume_ )
         {
             const SimVertex& simVertex=hSimVertices->at( pDecayTrack->pParentVertex->simVertexIndex );
             if( !objectFactory.vectorIsInsideVolume( simVertex.position() ) ) continue;
         }
 
 
         // This function creates the TrackinParticle and adds it to the collection if it
         // passes the selection criteria specified in the configuration. If the config
         // specifies adding ancestors, the function is called recursively to do that.
         ::addTrack( pDecayTrack, pSelector, pUnmergedCollectionWrapper.get(), pMergedCollectionWrapper.get(), objectFactory, addAncestors_, tTopo );
     }
 
     // If configured to create a collection of initial vertices, add them from this bunch
     // crossing. No selection is applied on this collection, but it also has no links to
     // the TrackingParticle decay products.
     // There are a lot of "initial vertices", I'm not entirely sure what they all are
     // (nuclear interactions in the detector maybe?), but the one for the main event is
     // the one with vertexId==0.
     if( createInitialVertexCollection_ )
     {
         // Pretty sure the one with vertexId==0 is always the first one, but doesn't hurt to check
         for( const auto& pRootVertex : decayChain.rootVertices )
         {
             const SimVertex& vertex=hSimVertices->at(decayChain.rootVertices[0]->simVertexIndex);
             if( vertex.vertexId()!=0 ) continue;
 
             pInitialVertices_->push_back( objectFactory.createTrackingVertex(pRootVertex) );
             break;
         }
     }
 }

template<class T >

void TrackingTruthAccumulator::fillSimHits	(	std::vector< const PSimHit * > &	returnValue,
		const T &	event,
		const edm::EventSetup &	setup
	)

private

Fills the supplied vector with pointers to the SimHits, checking for bad modules if required.

Definition at line 522 of file TrackingTruthAccumulator.cc.

Referenced by accumulateEvent().

 {
     // loop over the collections
     for( const auto& collectionTag : collectionTags_ )
     {
         edm::Handle< std::vector<PSimHit> > hSimHits;
         event.getByLabel( collectionTag, hSimHits );
 
         // TODO - implement removing the dead modules
         for( const auto& simHit : *hSimHits )
         {
             returnValue.push_back( &simHit );
         }
 
     } // end of loop over InputTags
 
         // sort the SimHits according to their time of flight,
         // necessary for looping over them "in order" in
         // TrackingParticleFactory::createTrackingParticle()
         std::sort(returnValue.begin(), returnValue.end(), [](const PSimHit *a, const PSimHit *b) {
             const auto atof = edm::isFinite(a->timeOfFlight()) ? a->timeOfFlight() : std::numeric_limits<decltype(a->timeOfFlight())>::max();
             const auto btof = edm::isFinite(b->timeOfFlight()) ? b->timeOfFlight() : std::numeric_limits<decltype(b->timeOfFlight())>::max();
             return atof < btof;
           });
 }

void TrackingTruthAccumulator::finalizeEvent	(	edm::Event &	event,
		const edm::EventSetup &	setup
	)

privatevirtual

Definition at line 380 of file TrackingTruthAccumulator.cc.

References createInitialVertexCollection_, createMergedCollection_, createUnmergedCollection_, mergedOutput_, eostools::move(), pInitialVertices_, TrackingTruthAccumulator::OutputCollections::pTrackingParticles, TrackingTruthAccumulator::OutputCollections::pTrackingVertices, and unmergedOutput_.

 {
 
     if( createUnmergedCollection_ )
     {
         edm::LogInfo("TrackingTruthAccumulator") << "Adding " << unmergedOutput_.pTrackingParticles->size() << " TrackingParticles and " << unmergedOutput_.pTrackingVertices->size()
                 << " TrackingVertexs to the event.";
 
         event.put(std::move(unmergedOutput_.pTrackingParticles));
         event.put(std::move(unmergedOutput_.pTrackingVertices));
     }
 
     if( createMergedCollection_ )
     {
         edm::LogInfo("TrackingTruthAccumulator") << "Adding " << mergedOutput_.pTrackingParticles->size() << " merged TrackingParticles and " << mergedOutput_.pTrackingVertices->size()
                 << " merged TrackingVertexs to the event.";
 
         event.put(std::move(mergedOutput_.pTrackingParticles), "MergedTrackTruth" );
         event.put(std::move(mergedOutput_.pTrackingVertices), "MergedTrackTruth" );
     }
 
     if( createInitialVertexCollection_ )
     {
         edm::LogInfo("TrackingTruthAccumulator") << "Adding " << pInitialVertices_->size() << " initial TrackingVertexs to the event.";
 
         event.put(std::move(pInitialVertices_), "InitialVertices" );
     }
 }

void TrackingTruthAccumulator::initializeEvent	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

privatevirtual

Definition at line 327 of file TrackingTruthAccumulator.cc.

References accumulate(), accumulateEvent(), PileUpEventPrincipal::bunchCrossing(), createInitialVertexCollection_, createMergedCollection_, createUnmergedCollection_, event(), hepMCproductLabel_, maximumPreviousBunchCrossing_, maximumSubsequentBunchCrossing_, mergedOutput_, messageCategory_, pInitialVertices_, TrackingTruthAccumulator::OutputCollections::pTrackingParticles, TrackingTruthAccumulator::OutputCollections::pTrackingVertices, TrackingTruthAccumulator::OutputCollections::refTrackingParticles, TrackingTruthAccumulator::OutputCollections::refTrackingVertexes, GeneralSetup::setup(), and unmergedOutput_.

 {
     if( createUnmergedCollection_ )
     {
         unmergedOutput_.pTrackingParticles.reset( new TrackingParticleCollection );
         unmergedOutput_.pTrackingVertices.reset( new TrackingVertexCollection );
         unmergedOutput_.refTrackingParticles=const_cast<edm::Event&>( event ).getRefBeforePut<TrackingParticleCollection>();
         unmergedOutput_.refTrackingVertexes=const_cast<edm::Event&>( event ).getRefBeforePut<TrackingVertexCollection>();
     }
 
     if( createMergedCollection_ )
     {
         mergedOutput_.pTrackingParticles.reset( new TrackingParticleCollection );
         mergedOutput_.pTrackingVertices.reset( new TrackingVertexCollection );
         mergedOutput_.refTrackingParticles=const_cast<edm::Event&>( event ).getRefBeforePut<TrackingParticleCollection>("MergedTrackTruth");
         mergedOutput_.refTrackingVertexes=const_cast<edm::Event&>( event ).getRefBeforePut<TrackingVertexCollection>("MergedTrackTruth");
     }
 
     if( createInitialVertexCollection_ )
     {
         pInitialVertices_.reset( new TrackingVertexCollection );
     }
 }

Member Data Documentation

const bool TrackingTruthAccumulator::addAncestors_

private

Whether or not to add the full parentage of any TrackingParticle that is inserted in the collection.

Definition at line 111 of file TrackingTruthAccumulator.h.

Referenced by accumulateEvent().

bool TrackingTruthAccumulator::allowDifferentProcessTypeForDifferentDetectors_

private

When counting hits, allows hits in different detectors to have a different process type.

Fast sim PSimHits seem to have a peculiarity where the process type (as reported by PSimHit::processType()) is different for the tracker than the muons. When counting how many hits there are, the code usually only counts the number of hits that have the same process type as the first hit. Setting this to true will also count hits that have the same process type as the first hit in the second detector.

Definition at line 136 of file TrackingTruthAccumulator.h.

Referenced by accumulateEvent(), and fillSimHits().

bool TrackingTruthAccumulator::chargedOnly_

private

Uses the same config as selector_, but can be used to drop out early since selector_ requires the TrackingParticle to be created first.

Definition at line 125 of file TrackingTruthAccumulator.h.

Referenced by accumulateEvent(), and TrackingTruthAccumulator().

std::vector<edm::InputTag> TrackingTruthAccumulator::collectionTags_

private

Definition at line 117 of file TrackingTruthAccumulator.h.

Referenced by fillSimHits(), and TrackingTruthAccumulator().

const bool TrackingTruthAccumulator::createInitialVertexCollection_

private

Whether or not to create a separate collection for just the initial interaction vertices.

Definition at line 109 of file TrackingTruthAccumulator.h.

Referenced by accumulateEvent(), finalizeEvent(), initializeEvent(), and TrackingTruthAccumulator().

const bool TrackingTruthAccumulator::createMergedCollection_

private

Definition at line 107 of file TrackingTruthAccumulator.h.

Referenced by accumulateEvent(), finalizeEvent(), initializeEvent(), and TrackingTruthAccumulator().

const bool TrackingTruthAccumulator::createUnmergedCollection_

private

If bremsstrahlung merging, whether to also add the unmerged collection to the event or not.

Definition at line 106 of file TrackingTruthAccumulator.h.

Referenced by accumulateEvent(), finalizeEvent(), initializeEvent(), and TrackingTruthAccumulator().

edm::InputTag TrackingTruthAccumulator::genParticleLabel_

private

Definition at line 118 of file TrackingTruthAccumulator.h.

Referenced by accumulateEvent(), and TrackingTruthAccumulator().

edm::InputTag TrackingTruthAccumulator::hepMCproductLabel_

private

Needed to add HepMC::GenVertex to SimVertex.

Definition at line 120 of file TrackingTruthAccumulator.h.

Referenced by initializeEvent(), and TrackingTruthAccumulator().

const bool TrackingTruthAccumulator::ignoreTracksOutsideVolume_

private

Definition at line 97 of file TrackingTruthAccumulator.h.

Referenced by accumulateEvent().

const unsigned int TrackingTruthAccumulator::maximumPreviousBunchCrossing_

private

The maximum bunch crossing BEFORE the signal crossing to create TrackinParticles for. Use positive values. If set to zero no previous bunches are added and only in-time, signal and after bunches (defined by maximumSubsequentBunchCrossing_) are used.

Definition at line 101 of file TrackingTruthAccumulator.h.

Referenced by initializeEvent().

const unsigned int TrackingTruthAccumulator::maximumSubsequentBunchCrossing_

private

The maximum bunch crossing AFTER the signal crossing to create TrackinParticles for. E.g. if set to zero only uses the signal and in time pileup (and previous bunches defined by the maximumPreviousBunchCrossing_ parameter).

Definition at line 104 of file TrackingTruthAccumulator.h.

Referenced by initializeEvent().

OutputCollections TrackingTruthAccumulator::mergedOutput_

private

Definition at line 149 of file TrackingTruthAccumulator.h.

Referenced by accumulateEvent(), finalizeEvent(), and initializeEvent().

const std::string TrackingTruthAccumulator::messageCategory_

private

The message category used to send messages to MessageLogger.

Definition at line 91 of file TrackingTruthAccumulator.h.

Referenced by initializeEvent(), and TrackingTruthAccumulator().

std::unique_ptr<TrackingVertexCollection> TrackingTruthAccumulator::pInitialVertices_