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::ProducesCollector, edm::ConsumesCollector &iC)

Public Member Functions inherited from DigiAccumulatorMixMod
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 PileupMixingContent *	getEventPileupInfo ()

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

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
void	accumulate (const edm::Event &event, const edm::EventSetup &setup) override

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

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

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

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

Private Attributes
const bool	addAncestors_

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

bool	chargedOnly_

std::vector< edm::InputTag >	collectionTags_

const bool	createInitialVertexCollection_

const bool	createMergedCollection_

const bool	createUnmergedCollection_

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_

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_

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 89 of file TrackingTruthAccumulator.h.

Constructor & Destructor Documentation

◆ TrackingTruthAccumulator()

TrackingTruthAccumulator::TrackingTruthAccumulator	(	const edm::ParameterSet &	config,
		edm::ProducesCollector	producesCollector,
		edm::ConsumesCollector &	iC
	)

explicit

Definition at line 260 of file TrackingTruthAccumulator.cc.

     : 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_) {
     producesCollector.produces<TrackingVertexCollection>();
     producesCollector.produces<TrackingParticleCollection>();
   }
  
   if (createMergedCollection_) {
     producesCollector.produces<TrackingParticleCollection>("MergedTrackTruth");
     producesCollector.produces<TrackingVertexCollection>("MergedTrackTruth");
   }
  
   if (createInitialVertexCollection_) {
     producesCollector.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);
   }
 }

References chargedOnly_, collectionTags_, edm::ConsumesCollector::consumes(), createInitialVertexCollection_, createMergedCollection_, createUnmergedCollection_, genParticleLabel_, edm::ParameterSet::getParameter(), hepMCproductLabel_, messageCategory_, edm::ProducesCollector::produces(), selector_, selectorFlag_, signalOnly_, simTrackLabel_, simVertexLabel_, and triggerMatcherToHLTDebug_cfi::tags.

Member Function Documentation

◆ accumulate() [1/2]

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

overrideprivatevirtual

create handle to edm::HepMCProduct here because event.getByLabel with edm::HepMCProduct only works for edm::Event but not for PileUpEventPrincipal; PileUpEventPrincipal::getByLabel tries to call T::value_type and T::iterator (where T is the type of the object one wants to get a handle to) which is only implemented for container-like objects like std::vector but not for edm::HepMCProduct!

Implements DigiAccumulatorMixMod.

Definition at line 388 of file TrackingTruthAccumulator.cc.

                                                                                            {
   // Call the templated version that does the same for both signal and pileup
   // events
  
   edm::Handle<edm::HepMCProduct> hepmc;
   event.getByLabel(hepMCproductLabel_, hepmc);
  
   accumulateEvent(event, setup, hepmc);
 }

References accumulateEvent(), hepMCproductLabel_, and singleTopDQM_cfi::setup.

◆ accumulate() [2/2]

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

overrideprivatevirtual

Implements DigiAccumulatorMixMod.

Definition at line 398 of file TrackingTruthAccumulator.cc.

                                                                {
   // If this bunch crossing is outside the user configured limit, don't do
   // anything.
   if (event.bunchCrossing() >= -static_cast<int>(maximumPreviousBunchCrossing_) &&
       event.bunchCrossing() <= static_cast<int>(maximumSubsequentBunchCrossing_)) {
     // edm::LogInfo(messageCategory_) << "Analysing pileup event for bunch
     // crossing " << event.bunchCrossing();
  
     // simply create empty handle as we do not have a HepMCProduct in PU anyway
     edm::Handle<edm::HepMCProduct> hepmc;
     accumulateEvent(event, setup, hepmc);
   } else
     edm::LogInfo(messageCategory_) << "Skipping pileup event for bunch crossing " << event.bunchCrossing();
 }

References accumulateEvent(), maximumPreviousBunchCrossing_, maximumSubsequentBunchCrossing_, messageCategory_, and singleTopDQM_cfi::setup.

◆ accumulateEvent()

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 443 of file TrackingTruthAccumulator.cc.

                                                                                                {
   //
   // 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 = std::make_unique<::OutputCollectionWrapper>(decayChain, unmergedOutput_);
   if (createMergedCollection_)
     pMergedCollectionWrapper = std::make_unique<::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 = nullptr;
   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;
     }
   }
 }

References addAncestors_, allowDifferentProcessTypeForDifferentDetectors_, chargedOnly_, createInitialVertexCollection_, createMergedCollection_, createUnmergedCollection_, cppFunctionSkipper::exception, fillSimHits(), genParticleLabel_, get, ignoreTracksOutsideVolume_, mergedOutput_, pInitialVertices_, edm::ESHandle< T >::product(), selector_, selectorFlag_, singleTopDQM_cfi::setup, signalOnly_, muonSimHitMatcherPSet::simTrack, simTrackLabel_, HLTEgPhaseIITestSequence_cff::simVertex, simVertexLabel_, unmergedOutput_, bphysicsOniaDQM_cfi::vertex, vertexDistanceCut_, volumeRadius_, and volumeZ_.

Referenced by accumulate().

◆ fillSimHits()

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 573 of file TrackingTruthAccumulator.cc.

                                                                        {
   // 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;
   });
 }

References a, b, collectionTags_, edm::isFinite(), SiStripPI::max, and rpcPointValidation_cfi::simHit.

Referenced by accumulateEvent().

◆ finalizeEvent()

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

overrideprivatevirtual

Implements DigiAccumulatorMixMod.

Definition at line 415 of file TrackingTruthAccumulator.cc.

                                                                                         {
   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");
   }
 }

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

◆ initializeEvent()

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

overrideprivatevirtual

Implements DigiAccumulatorMixMod.

Definition at line 358 of file TrackingTruthAccumulator.cc.

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

References createInitialVertexCollection_, createMergedCollection_, createUnmergedCollection_, mergedOutput_, pInitialVertices_, TrackingTruthAccumulator::OutputCollections::pTrackingParticles, TrackingTruthAccumulator::OutputCollections::pTrackingVertices, TrackingTruthAccumulator::OutputCollections::refTrackingParticles, TrackingTruthAccumulator::OutputCollections::refTrackingVertexes, and unmergedOutput_.

Member Data Documentation

◆ addAncestors_

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 140 of file TrackingTruthAccumulator.h.

Referenced by accumulateEvent().

◆ allowDifferentProcessTypeForDifferentDetectors_

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 170 of file TrackingTruthAccumulator.h.

Referenced by accumulateEvent().

◆ chargedOnly_

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 155 of file TrackingTruthAccumulator.h.

Referenced by accumulateEvent(), and TrackingTruthAccumulator().

◆ collectionTags_

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

private

Definition at line 146 of file TrackingTruthAccumulator.h.

Referenced by fillSimHits(), and TrackingTruthAccumulator().

◆ createInitialVertexCollection_

const bool TrackingTruthAccumulator::createInitialVertexCollection_

private

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

Definition at line 137 of file TrackingTruthAccumulator.h.

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

◆ createMergedCollection_

const bool TrackingTruthAccumulator::createMergedCollection_

private

Definition at line 134 of file TrackingTruthAccumulator.h.

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

◆ createUnmergedCollection_

const bool TrackingTruthAccumulator::createUnmergedCollection_

private

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

Definition at line 133 of file TrackingTruthAccumulator.h.

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

◆ genParticleLabel_

edm::InputTag TrackingTruthAccumulator::genParticleLabel_

private

Definition at line 147 of file TrackingTruthAccumulator.h.

Referenced by accumulateEvent(), and TrackingTruthAccumulator().

◆ hepMCproductLabel_

edm::InputTag TrackingTruthAccumulator::hepMCproductLabel_

private

Needed to add HepMC::GenVertex to SimVertex.

Definition at line 149 of file TrackingTruthAccumulator.h.

Referenced by accumulate(), and TrackingTruthAccumulator().

◆ ignoreTracksOutsideVolume_

const bool TrackingTruthAccumulator::ignoreTracksOutsideVolume_

private

Definition at line 119 of file TrackingTruthAccumulator.h.

Referenced by accumulateEvent().

◆ maximumPreviousBunchCrossing_

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 125 of file TrackingTruthAccumulator.h.

Referenced by accumulate().

◆ maximumSubsequentBunchCrossing_

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 130 of file TrackingTruthAccumulator.h.

Referenced by accumulate().