#include <TrackingTruthProducer.h>

Inheritance diagram for TrackingTruthProducer:

Public Member Functions
	TrackingTruthProducer (const edm::ParameterSet &)

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

boost::function< void(const BranchDescription &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Private Types
typedef std::map < EncodedEventId, unsigned int >	EncodedEventIdToIndex

typedef std::map < EncodedTruthId, unsigned int >	EncodedTruthIdToIndex

typedef std::multimap < EncodedTruthId, unsigned int >	EncodedTruthIdToIndexes

Private Member Functions
void	addCloseGenVertexes (TrackingVertex &)

void	associator (std::vector< PSimHit > const &, EncodedTruthIdToIndexes &)

void	associator (std::auto_ptr< MixCollection< SimTrack > > const &, EncodedTruthIdToIndex &)

void	associator (std::auto_ptr< MixCollection< SimVertex > > const &, EncodedTruthIdToIndex &)

void	createTrackingTruth ()

bool	isBremsstrahlungVertex (TrackingVertex const &vertex, std::auto_ptr< TrackingParticleCollection > &tPC)

int	LayerFromDetid (const unsigned int &)

void	mergeBremsstrahlung ()

void	produce (edm::Event &, const edm::EventSetup &)

bool	setTrackingParticle (SimTrack const &, TrackingParticle &)

int	setTrackingVertex (SimVertex const &, TrackingVertex &)

Private Attributes
edm::ParameterSet	conf_

std::vector< std::string >	dataLabels_

double	distanceCut_

EncodedEventIdToIndex	eventIdCounter_

std::vector< edm::Handle < edm::HepMCProduct > >	hepMCProducts_

std::vector< std::string >	hitLabelsVector_

bool	mergedBremsstrahlung_

std::auto_ptr < TrackingParticleCollection >	mergedTrackingParticles_

std::auto_ptr < TrackingVertexCollection >	mergedTrackingVertexes_

std::string	MessageCategory_

MuonPSimHitSelector	muonPSimHitSelector_

PixelPSimHitSelector	pixelPSimHitSelector_

PSimHitSelector::PSimHitCollection	pSimHits_

PSimHitSelector	pSimHitSelector_

TrackingParticleRefProd	refMergedTrackingParticles_

TrackingVertexRefProd	refMergedTrackingVertexes_

TrackingParticleRefProd	refTrackingParticles_

TrackingVertexRefProd	refTrackingVertexes_

bool	removeDeadModules_

TrackingParticleSelector	selector_

bool	selectorFlag_

std::string	simHitLabel_

std::auto_ptr< MixCollection < SimTrack > >	simTracks_

std::auto_ptr< MixCollection < SimVertex > >	simVertexes_

TrackerPSimHitSelector	trackerPSimHitSelector_

EncodedTruthIdToIndexes	trackIdToHits_

EncodedTruthIdToIndex	trackIdToIndex_

std::auto_ptr < TrackingParticleCollection >	trackingParticles_

std::auto_ptr < TrackingVertexCollection >	trackingVertexes_

bool	useMultipleHepMCLabels_

EncodedTruthIdToIndex	vertexIdToIndex_

double	volumeRadius_

double	volumeZ_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

typedef WorkerT< EDProducer >	WorkerType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDProducer
CurrentProcessingContext const *	currentContext () const

Protected Member Functions inherited from edm::ProducerBase
template<class TProducer , class TMethod >
void	callWhenNewProductsRegistered (TProducer *iProd, TMethod iMethod)

Detailed Description

Definition at line 35 of file TrackingTruthProducer.h.

Member Typedef Documentation

typedef std::map<EncodedEventId, unsigned int> TrackingTruthProducer::EncodedEventIdToIndex

private

Definition at line 87 of file TrackingTruthProducer.h.

typedef std::map<EncodedTruthId, unsigned int> TrackingTruthProducer::EncodedTruthIdToIndex

private

Definition at line 88 of file TrackingTruthProducer.h.

typedef std::multimap<EncodedTruthId, unsigned int> TrackingTruthProducer::EncodedTruthIdToIndexes

private

Definition at line 89 of file TrackingTruthProducer.h.

Constructor & Destructor Documentation

TrackingTruthProducer::TrackingTruthProducer ( const edm::ParameterSet & config )

explicit

Definition at line 26 of file TrackingTruthProducer.cc.

References dataLabels_, distanceCut_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), mergedBremsstrahlung_, MessageCategory_, removeDeadModules_, selector_, selectorFlag_, simHitLabel_, useMultipleHepMCLabels_, volumeRadius_, and volumeZ_.

                                                                            :
         pSimHitSelector_(config), pixelPSimHitSelector_(config), trackerPSimHitSelector_(config), muonPSimHitSelector_(config)
 {
     // Initialize global parameters
     dataLabels_             = config.getParameter<std::vector<std::string> >("HepMCDataLabels");
     useMultipleHepMCLabels_ = config.getParameter<bool>("useMultipleHepMCLabels");
 
     distanceCut_            = config.getParameter<double>("vertexDistanceCut");
     volumeRadius_           = config.getParameter<double>("volumeRadius");
     volumeZ_                = config.getParameter<double>("volumeZ");
     mergedBremsstrahlung_   = config.getParameter<bool>("mergedBremsstrahlung");
     removeDeadModules_      = config.getParameter<bool>("removeDeadModules");
     simHitLabel_            = config.getParameter<std::string>("simHitLabel");
 
     // 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>("minRapidityTP"),
                         param.getParameter<double>("maxRapidityTP"),
                         param.getParameter<double>("tipTP"),
                         param.getParameter<double>("lipTP"),
                         param.getParameter<int>("minHitTP"),
                         param.getParameter<bool>("signalOnlyTP"),
                         param.getParameter<bool>("chargedOnlyTP"),
                         param.getParameter<bool>("stableOnlyTP"),
                         param.getParameter<std::vector<int> >("pdgIdTP")
                     );
         selectorFlag_ = true;
     }
     else
         selectorFlag_ = false;
 
     MessageCategory_       = "TrackingTruthProducer";
 
     edm::LogInfo (MessageCategory_) << "Setting up TrackingTruthProducer";
     edm::LogInfo (MessageCategory_) << "Vertex distance cut set to " << distanceCut_  << " mm";
     edm::LogInfo (MessageCategory_) << "Volume radius set to "       << volumeRadius_ << " mm";
     edm::LogInfo (MessageCategory_) << "Volume Z      set to "       << volumeZ_      << " mm";
 
     if (useMultipleHepMCLabels_) edm::LogInfo (MessageCategory_) << "Collecting generator information from pileup.";
     if (mergedBremsstrahlung_) edm::LogInfo (MessageCategory_) << "Merging electrom bremsstralung";
     if (removeDeadModules_) edm::LogInfo (MessageCategory_) << "Removing psimhit from dead modules";
 
     if (!mergedBremsstrahlung_)
     {
         produces<TrackingVertexCollection>();
         produces<TrackingParticleCollection>();
     }
     else
     {
         produces<TrackingVertexCollection>();
         produces<TrackingParticleCollection>();
         produces<TrackingVertexCollection>("MergedTrackTruth");
         produces<TrackingParticleCollection>("MergedTrackTruth");
     }
 }

Member Function Documentation

void TrackingTruthProducer::addCloseGenVertexes ( TrackingVertex & trackingVertex )

private

Definition at line 802 of file TrackingTruthProducer.cc.

References TrackingVertex::addGenVertex(), distanceCut_, TrackingVertex::eventId(), MCTruth::genEvent, hepMCProducts_, mag2(), TrackingVertex::position(), EncodedEventId::rawId(), mathSSE::sqrt(), and useMultipleHepMCLabels_.

Referenced by setTrackingVertex().

 {
     // Get the generated particle
     edm::Handle<edm::HepMCProduct> hepmc = (useMultipleHepMCLabels_) ? hepMCProducts_.at(trackingVertex.eventId().rawId()) : hepMCProducts_.at(0);
     const HepMC::GenEvent * genEvent = hepmc->GetEvent();
 
     // Get the postion of the tv
     Vector tvPosition(trackingVertex.position().x(), trackingVertex.position().y(), trackingVertex.position().z());
 
     // Find HepMC vertices, put them in a close TrackingVertex (this could conceivably add the same GenVertex to multiple TrackingVertices)
     for (
         HepMC::GenEvent::vertex_const_iterator iGenVertex = genEvent->vertices_begin();
         iGenVertex != genEvent->vertices_end();
         ++iGenVertex
     )
     {
         // Get the position of the genVertex
         HepMC::ThreeVector rawPosition = (*iGenVertex)->position();
 
         // Convert to cm
         Vector genPosition(rawPosition.x()/10.0, rawPosition.y()/10.0, rawPosition.z()/10.0);
 
         // Calculate the dis
         double distance = sqrt( (tvPosition - genPosition).mag2() );
 
         if (distance <= distanceCut_)
             trackingVertex.addGenVertex( GenVertexRef(hepmc, (*iGenVertex)->barcode()) );
     }
 }

void TrackingTruthProducer::associator	(	std::vector< PSimHit > const &	pSimHits,
		EncodedTruthIdToIndexes &	association
	)

private

Definition at line 193 of file TrackingTruthProducer.cc.

References i.

Referenced by produce().

 {
     // Clear the association map
     association.clear();
 
     // Create a association from simtracks to overall index in the mix collection
     for (std::size_t i = 0; i < pSimHits.size(); ++i)
     {
         EncodedTruthIdToIndexes::key_type objectId = EncodedTruthIdToIndexes::key_type(pSimHits[i].eventId(), pSimHits[i].trackId());
         association.insert( std::make_pair(objectId, i) );
     }
 }

void TrackingTruthProducer::associator	(	std::auto_ptr< MixCollection< SimTrack > > const &	mixCollection,
		EncodedTruthIdToIndex &	association
	)

private

Definition at line 210 of file TrackingTruthProducer.cc.

References getHLTprescales::index.

 {
     int index = 0;
     // Clear the association map
     association.clear();
     // Create a association from simtracks to overall index in the mix collection
     for (MixCollection<SimTrack>::MixItr iterator = mixCollection->begin(); iterator != mixCollection->end(); ++iterator, ++index)
     {
         EncodedTruthId objectId = EncodedTruthId(iterator->eventId(), iterator->trackId());
         association.insert( std::make_pair(objectId, index) );
     }
 }

void TrackingTruthProducer::associator	(	std::auto_ptr< MixCollection< SimVertex > > const &	mixCollection,
		EncodedTruthIdToIndex &	association
	)

private

Definition at line 227 of file TrackingTruthProducer.cc.

References getHLTprescales::index, and MessageCategory_.

 {
     int index = 0;
 
     // Solution to the problem of not having vertexId
     bool useVertexId = true;
     EncodedEventIdToIndex vertexId;
     EncodedEventId oldEventId;
     unsigned int oldVertexId = 0;
 
     // Loop for finding repeated vertexId (vertexId problem hack)
     for (MixCollection<SimVertex>::MixItr iterator = mixCollection->begin(); iterator != mixCollection->end(); ++iterator, ++index)
     {
         if (!index || iterator->eventId() != oldEventId)
         {
             oldEventId = iterator->eventId();
             oldVertexId = iterator->vertexId();
             continue;
         }
 
         if ( iterator->vertexId() == oldVertexId )
         {
             edm::LogWarning(MessageCategory_) << "Multiple vertexId found, no using vertexId.";
             useVertexId = false;
             break;
         }
     }
 
     // Reset the index
     index = 0;
 
     // Clear the association map
     association.clear();
 
     // Create a association from simvertexes to overall index in the mix collection
     for (MixCollection<SimVertex>::MixItr iterator = mixCollection->begin(); iterator != mixCollection->end(); ++iterator, ++index)
     {
         EncodedTruthId objectId;
         if (useVertexId)
             objectId = EncodedTruthId(iterator->eventId(), iterator->vertexId());
         else
             objectId = EncodedTruthId(iterator->eventId(), vertexId[iterator->eventId()]++);
         association.insert( std::make_pair(objectId, index) );
     }
 }

void TrackingTruthProducer::createTrackingTruth ( )

private

Definition at line 474 of file TrackingTruthProducer.cc.

References CoreSimTrack::eventId(), eventIdCounter_, SimVertex::noParent(), SimTrack::noVertex(), SimVertex::parentIndex(), position, refTrackingParticles_, refTrackingVertexes_, setTrackingParticle(), setTrackingVertex(), simTracks_, simVertexes_, matplotRender::t, trackIdToIndex_, trackingParticles_, trackingVertexes_, vertexIdToIndex_, and SimTrack::vertIndex().

Referenced by produce().

 {
     // Reset the event counter (use for define vertexId)
     eventIdCounter_.clear();
 
     // Define a container of vetoed traks
     std::map<int,std::size_t> vetoedTracks;
 
     // Define map between parent simtrack and tv indexes
     std::map<int,std::size_t> vetoedSimVertexes;
 
     for (int simTrackIndex = 0; simTrackIndex != simTracks_->size(); ++simTrackIndex)
     {
         // Check if the simTrack is excluded (includes non traceable and recovered by history)
         if ( vetoedTracks.find(simTrackIndex) != vetoedTracks.end() ) continue;
 
         SimTrack const & simTrack = simTracks_->getObject(simTrackIndex);
 
         TrackingParticle trackingParticle;
 
         // Set a bare tp (only with the psimhit) with a given simtrack
         // the function return true if it is tracable
         if ( setTrackingParticle(simTrack, trackingParticle) )
         {
             // Follows the path upward recovering the history of the particle
             SimTrack const * currentSimTrack = & simTrack;
 
             // Initial condition for the tp and tv indexes
             int trackingParticleIndex = -1;
             int trackingVertexIndex = -1;
 
             do
             {
                 // Set a new tracking particle for the current simtrack
                 // and add it to the list of parent tracks of previous vertex
                 if (trackingParticleIndex >= 0)
                 {
                     setTrackingParticle(*currentSimTrack, trackingParticle);
 
                     // Set the tp index to its new value
                     trackingParticleIndex = trackingParticles_->size();
                     // Push the tp in to the collection
                     trackingParticles_->push_back(trackingParticle);
 
                     // Add the previous track to the list of decay vertexes of the new tp
                     trackingParticles_->at(trackingParticleIndex).addDecayVertex(
                         TrackingVertexRef(refTrackingVertexes_, trackingVertexIndex)
                     );
 
                     // Add the new tp to the list of parent tracks of the previous tv
                     trackingVertexes_->at(trackingVertexIndex).addParentTrack(
                         TrackingParticleRef(refTrackingParticles_, trackingParticleIndex)
                     );
                 }
                 else
                 {
                     // Set the tp index to its new value
                     trackingParticleIndex = trackingParticles_->size();
                     // Push the tp in to the collection
                     trackingParticles_->push_back(trackingParticle);
                     // Vetoed the simTrack
                     vetoedTracks.insert( std::make_pair(simTrackIndex, trackingParticleIndex) );
                 }
 
                 // Verify if the parent simVertex has a simTrack or if the source is a vetoSimVertex
                 if (currentSimTrack->noVertex()) break;
 
                 // Get the simTrack parent index (it is implicit should be in the same event as current)
                 unsigned int parentSimVertexIndex = vertexIdToIndex_[
                                                         EncodedTruthId(
                                                             currentSimTrack->eventId(),
                                                             currentSimTrack->vertIndex()
                                                         )
                                                     ];
                 // Create a new tv
                 TrackingVertex trackingVertex;
                 // Get the parent simVertex associated to the current simTrack
                 SimVertex const * parentSimVertex = & simVertexes_->getObject(parentSimVertexIndex);
 
                 bool vetoSimVertex = vetoedSimVertexes.find(parentSimVertexIndex) != vetoedSimVertexes.end();
 
                 // Check for a already visited parent simTrack
                 if ( !vetoSimVertex )
                 {
                     // Set the tv by using simvertex
                     trackingVertexIndex = setTrackingVertex(*parentSimVertex, trackingVertex);
 
                     // Check if a new vertex needs to be created
                     if (trackingVertexIndex < 0)
                     {
                         // Set the tv index ot its new value
                         trackingVertexIndex = trackingVertexes_->size();
                         // Push the new tv in to the collection
                         trackingVertexes_->push_back(trackingVertex);
                     }
                     else
                     {
                         // Get the postion and time of the vertex
                         const LorentzVector & position = trackingVertexes_->at(trackingVertexIndex).position();
                         Vector xyz = Vector(position.x(), position.y(), position.z());
                         double t = position.t();
                         // Set the vertex postion of the tp to the closest vertex
                         trackingParticles_->at(trackingParticleIndex).setVertex(xyz, t);
                     }
 
                     vetoedSimVertexes.insert( std::make_pair(parentSimVertexIndex, trackingVertexIndex) );
                 }
                 else
                     trackingVertexIndex = vetoedSimVertexes[parentSimVertexIndex];
 
                 // Set the newly created tv as parent vertex
                 trackingParticles_->at(trackingParticleIndex).setParentVertex(
                     TrackingVertexRef(refTrackingVertexes_, trackingVertexIndex)
                 );
 
                 // Add the newly created tp to the tv daughter list
                 trackingVertexes_->at(trackingVertexIndex).addDaughterTrack(
                     TrackingParticleRef(refTrackingParticles_, trackingParticleIndex)
                 );
 
                 // Verify if the parent simVertex has a simTrack or if the source is a vetoSimVertex
                 if (parentSimVertex->noParent() || vetoSimVertex) break;
 
                 // Get the next simTrack index (it is implicit should be in the same event as current).
                 unsigned int nextSimTrackIndex = trackIdToIndex_[
                                                      EncodedTruthId(
                                                          currentSimTrack->eventId(),
                                                          parentSimVertex->parentIndex()
                                                      )
                                                  ];
 
                 // Check if the next track exist
                 if ( vetoedTracks.find(nextSimTrackIndex) != vetoedTracks.end() )
                 {
                     // Add to the newly created tv the existent next simtrack in to parent list.
                     trackingVertexes_->at(trackingVertexIndex).addParentTrack(
                         TrackingParticleRef(refTrackingParticles_, vetoedTracks[nextSimTrackIndex])
                     );
                     // Add the vertex to list of decay vertexes of the new tp
                     trackingParticles_->at(vetoedTracks[nextSimTrackIndex]).addDecayVertex(
                         TrackingVertexRef(refTrackingVertexes_, trackingVertexIndex)
                     );
                     break;
                 }
 
                 // Vetoed the next simTrack
                 vetoedTracks.insert( std::make_pair(nextSimTrackIndex, trackingParticleIndex) );
 
                 // Set the current simTrack as the next simTrack
                 currentSimTrack = & simTracks_->getObject(nextSimTrackIndex);
             }
             while (!currentSimTrack->noVertex());
         }
     }
 }

bool TrackingTruthProducer::isBremsstrahlungVertex	(	TrackingVertex const &	vertex,
		std::auto_ptr< TrackingParticleCollection > &	tPC
	)

private

Definition at line 432 of file TrackingTruthProducer.cc.

References abs, TrackingVertex::daughterTracks_begin(), TrackingVertex::daughterTracks_end(), parents, benchmark_cfg::pdgId, and TrackingVertex::sourceTracks().

Referenced by mergeBremsstrahlung().

 {
     const TrackingParticleRefVector parents(vertex.sourceTracks());
 
     // Check for the basic parent conditions
     if ( parents.size() != 1)
         return false;
 
     // Check for the parent particle is a |electron| (electron or positron)
     if ( std::abs( tPC->at(parents.begin()->key()).pdgId() ) != 11 )
         return false;
 
     int nElectrons = 0;
     int nPhotons = 0;
     int nOthers = 0;
 
     // Loop over the daughter particles and counts the number of |electrons|, photons or others
     for ( TrackingVertex::tp_iterator it = vertex.daughterTracks_begin(); it != vertex.daughterTracks_end(); ++it )
     {
         // Stronger rejection for looping particles
         if ( parents[0] == *it )
             return false;
 
         if ( std::abs( tPC->at(it->key()).pdgId() ) == 11 )
             nElectrons++;
         else if ( tPC->at(it->key()).pdgId() == 22 )
             nPhotons++;
         else
             nOthers++;
     }
 
     // Condition to be a Bremsstrahlung Vertex
     if (nElectrons == 1 && nPhotons >= 0 && nOthers == 0)
         return true;
 
     return false;
 }

int TrackingTruthProducer::LayerFromDetid ( const unsigned int & detid )

private

Definition at line 833 of file TrackingTruthProducer.cc.

References DetId::det(), PXFDetId::disk(), PXBDetId::layer(), TOBDetId::layer(), TIBDetId::layer(), align::tib::layerNumber(), PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, DetId::rawId(), DetId::subdetId(), StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, StripSubdetector::TOB, DetId::Tracker, TIDDetId::wheel(), and TECDetId::wheel().

Referenced by setTrackingParticle().

 {
     DetId detId = DetId(detid);
 
     if ( detId.det() != DetId::Tracker ) return 0;
 
     int layerNumber=0;
     unsigned int subdetId = static_cast<unsigned int>(detId.subdetId());
 
     if ( subdetId == StripSubdetector::TIB)
     {
         TIBDetId tibid(detId.rawId());
         layerNumber = tibid.layer();
     }
     else if ( subdetId ==  StripSubdetector::TOB )
     {
         TOBDetId tobid(detId.rawId());
         layerNumber = tobid.layer();
     }
     else if ( subdetId ==  StripSubdetector::TID)
     {
         TIDDetId tidid(detId.rawId());
         layerNumber = tidid.wheel();
     }
     else if ( subdetId ==  StripSubdetector::TEC )
     {
         TECDetId tecid(detId.rawId());
         layerNumber = tecid.wheel();
     }
     else if ( subdetId ==  PixelSubdetector::PixelBarrel )
     {
         PXBDetId pxbid(detId.rawId());
         layerNumber = pxbid.layer();
     }
     else if ( subdetId ==  PixelSubdetector::PixelEndcap )
     {
         PXFDetId pxfid(detId.rawId());
         layerNumber = pxfid.disk();
     }
     else
         edm::LogVerbatim("TrackingTruthProducer") << "Unknown subdetid: " <<  subdetId;
 
     return layerNumber;
 }

void TrackingTruthProducer::mergeBremsstrahlung ( )

private

Definition at line 277 of file TrackingTruthProducer.cc.

Referenced by produce().

 {
     unsigned int index = 0;
 
     std::set<unsigned int> excludedTV, excludedTP;
 
     // Merge Bremsstrahlung vertexes
     for (TrackingVertexCollection::iterator iVC = trackingVertexes_->begin(); iVC != trackingVertexes_->end(); ++iVC, ++index)
     {
         // Check Bremsstrahlung vertex
         if ( isBremsstrahlungVertex(*iVC, trackingParticles_) )
         {
             // Get a pointer to the source track (A Ref<> cannot be use with a product!)
             TrackingParticle * track = &trackingParticles_->at(iVC->sourceTracks_begin()->key());
             // Get a Ref<> to the source track
             TrackingParticleRef trackRef = *iVC->sourceTracks_begin();
             // Pointer to electron daughter
             TrackingParticle * daughter = 0;
             // Ref<> to electron daughter
             TrackingParticleRef daughterRef;
 
             // Select the electron daughter and redirect the photon
             for (TrackingVertex::tp_iterator idaughter = iVC->daughterTracks_begin(); idaughter != iVC->daughterTracks_end(); ++idaughter)
             {
                 TrackingParticle * pointer = &trackingParticles_->at(idaughter->key());
                 if ( std::abs( pointer->pdgId() ) == 11 )
                 {
                     // Set pointer to the electron daughter
                     daughter = pointer;
                     // Set Ref<> to the electron daughter
                     daughterRef = *idaughter;
                 }
                 else if ( pointer->pdgId() == 22 )
                 {
                     // Delete the photon original parent vertex
                     pointer->clearParentVertex();
                     // Set the new parent vertex to the vertex of the source track
                     pointer->setParentVertex( track->parentVertex() );
                     // Get a non-const pointer to the parent vertex
                     TrackingVertex * vertex = &trackingVertexes_->at( track->parentVertex().key() );
                     // Add the photon to the doughter list of the parent vertex
                     vertex->addDaughterTrack( *idaughter );
                 }
             }
 
             // Add the electron segments from the electron daughter
             // track must not be the same particle as daughter
             // if (track != daughter)
             for (TrackingParticle::g4t_iterator isegment = daughter->g4Track_begin(); isegment != daughter->g4Track_end(); ++isegment)
                 track->addG4Track(*isegment);
 
             // Copy all the simhits to the new track
             for (std::vector<PSimHit>::const_iterator ihit = daughter->pSimHit_begin(); ihit != daughter->pSimHit_end(); ++ihit)
                 track->addPSimHit(*ihit);
 
             // Make a copy of the decay vertexes of the track
             TrackingVertexRefVector decayVertices( track->decayVertices() );
 
             // Clear the decay vertex list
             track->clearDecayVertices();
 
             // Add the remaining vertexes
             for (TrackingVertexRefVector::const_iterator idecay = decayVertices.begin(); idecay != decayVertices.end(); ++idecay)
                 if ( (*idecay).key() != index ) track->addDecayVertex(*idecay);
 
             // Redirect all the decay source vertexes to those in the electron daughter
             for (TrackingParticle::tv_iterator idecay = daughter->decayVertices_begin(); idecay != daughter->decayVertices_end(); ++idecay)
             {
                 // Add the vertexes to the decay list of the source particles
                 track->addDecayVertex(*idecay);
                 // Get a reference to decay vertex
                 TrackingVertex * vertex = &trackingVertexes_->at( idecay->key() );
                 // Copy all the source tracks from of the decay vertex
                 TrackingParticleRefVector sources( vertex->sourceTracks() );
                 // Clear the source track references
                 vertex->clearParentTracks();
                 // Add the new source tracks by excluding the one with the segment merged
                 for (TrackingVertex::tp_iterator isource = sources.begin(); isource != sources.end(); ++isource)
                     if (*isource != daughterRef)
                         vertex->addParentTrack(*isource);
                 // Add the track reference to the list of sources
                 vertex->addParentTrack(trackRef);
             }
 
             // Adding the vertex to the exlusion list
             excludedTV.insert(index);
 
             // Adding the electron segment tp into the exlusion list
             excludedTP.insert( daughterRef.key() );
         }
     }
 
     edm::LogInfo(MessageCategory_) << "Generating the merged collection." << std::endl;
 
     // Reserved the same amount of memory for the merged collections
     mergedTrackingParticles_->reserve(trackingParticles_->size());
     mergedTrackingVertexes_->reserve(trackingVertexes_->size());
 
     index = 0;
     std::map<unsigned int, unsigned int> vertexMap;
 
     // Copy non-excluded vertices discarding parent & child tracks
     for (TrackingVertexCollection::const_iterator iVC = trackingVertexes_->begin(); iVC != trackingVertexes_->end(); ++iVC, ++index)
     {
         if ( excludedTV.find(index) != excludedTV.end() ) continue;
         // Save the new location of the non excluded vertexes (take in consideration those were removed)
         vertexMap.insert( std::make_pair(index, mergedTrackingVertexes_->size()) );
         // Copy those vertexes are not excluded
         TrackingVertex newVertex = (*iVC);
         newVertex.clearDaughterTracks();
         newVertex.clearParentTracks();
         mergedTrackingVertexes_->push_back(newVertex);
     }
 
     index = 0;
 
     // Copy and cross reference the non-excluded tp to the merged collection
     for (TrackingParticleCollection::const_iterator iTP = trackingParticles_->begin(); iTP != trackingParticles_->end(); ++iTP, ++index)
     {
         if ( excludedTP.find(index) != excludedTP.end() ) continue;
 
         TrackingVertexRef       sourceV = iTP->parentVertex();
         TrackingVertexRefVector decayVs = iTP->decayVertices();
         TrackingParticle newTrack = *iTP;
 
         newTrack.clearParentVertex();
         newTrack.clearDecayVertices();
 
         // Set vertex indices for new vertex product and track references in those vertices
 
         // Index of parent vertex in vertex container
         unsigned int parentIndex = vertexMap[sourceV.key()];
         // Index of this track in track container
         unsigned int tIndex = mergedTrackingParticles_->size();
 
         // Add vertex to track
         newTrack.setParentVertex( TrackingVertexRef(refMergedTrackingVertexes_, parentIndex) );
         // Add track to vertex
         (mergedTrackingVertexes_->at(parentIndex)).addDaughterTrack(TrackingParticleRef(refMergedTrackingParticles_, tIndex));
 
         for (TrackingVertexRefVector::const_iterator iDecayV = decayVs.begin(); iDecayV != decayVs.end(); ++iDecayV)
         {
             // Index of decay vertex in vertex container
             unsigned int daughterIndex = vertexMap[iDecayV->key()];
             // Add vertex to track
             newTrack.addDecayVertex( TrackingVertexRef(refMergedTrackingVertexes_, daughterIndex) );
             // Add track to vertex
             (mergedTrackingVertexes_->at(daughterIndex)).addParentTrack( TrackingParticleRef(refMergedTrackingParticles_, tIndex) );
         }
 
         mergedTrackingParticles_->push_back(newTrack);
     }
 }

void TrackingTruthProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	setup
	)

privatevirtual

Implements edm::EDProducer.

Definition at line 87 of file TrackingTruthProducer.cc.

References associator(), createTrackingTruth(), dataLabels_, edm::Event::getByLabel(), hepMCProducts_, mergeBremsstrahlung(), mergedBremsstrahlung_, mergedTrackingParticles_, mergedTrackingVertexes_, MessageCategory_, muonPSimHitSelector_, pixelPSimHitSelector_, edm::Handle< T >::product(), pSimHits_, pSimHitSelector_, refMergedTrackingParticles_, refMergedTrackingVertexes_, refTrackingParticles_, refTrackingVertexes_, removeDeadModules_, PixelPSimHitSelector::select(), TrackerPSimHitSelector::select(), MuonPSimHitSelector::select(), PSimHitSelector::select(), simHitLabel_, simTracks_, simVertexes_, LaserTracksInput_cfi::source, trackerPSimHitSelector_, trackIdToHits_, trackIdToIndex_, trackingParticles_, trackingVertexes_, useMultipleHepMCLabels_, and vertexIdToIndex_.

 {
     // Clean the list of hepmc products
     hepMCProducts_.clear();
 
     // Collect all the HepMCProducts
     edm::Handle<edm::HepMCProduct> hepMCHandle;
 
     for (std::vector<std::string>::const_iterator source = dataLabels_.begin(); source != dataLabels_.end(); ++source)
     {
         if ( event.getByLabel(*source, hepMCHandle) )
         {
             hepMCProducts_.push_back(hepMCHandle);
             edm::LogInfo (MessageCategory_) << "Using HepMC source " << *source;
             if (!useMultipleHepMCLabels_) break;
         }
     }
 
     if ( hepMCProducts_.empty() )
     {
         edm::LogWarning (MessageCategory_) << "No HepMC source found";
         return;
     }
     else if (hepMCProducts_.size() > 1 || useMultipleHepMCLabels_)
     {
         edm::LogInfo (MessageCategory_) << "You are using more than one HepMC source.";
         edm::LogInfo (MessageCategory_) << "If the labels are not in the same order as the events in the crossing frame (i.e. signal, pileup(s) ) ";
         edm::LogInfo (MessageCategory_) << "or there are fewer labels than events in the crossing frame";
         edm::LogInfo (MessageCategory_) << MessageCategory_ << " may try to access data in the wrong HepMCProduct and crash.";
     }
 
     // Collect all the simtracks from the crossing frame
     edm::Handle<CrossingFrame<SimTrack> > cfSimTracks;
     event.getByLabel("mix", simHitLabel_, cfSimTracks);
 
     // Create a mix collection from one simtrack collection
     simTracks_ = std::auto_ptr<MixCollection<SimTrack> >( new MixCollection<SimTrack>(cfSimTracks.product()) );
 
     // Collect all the simvertex from the crossing frame
     edm::Handle<CrossingFrame<SimVertex> > cfSimVertexes;
     event.getByLabel("mix", simHitLabel_, cfSimVertexes);
 
     // Create a mix collection from one simvertex collection
     simVertexes_ = std::auto_ptr<MixCollection<SimVertex> >( new MixCollection<SimVertex>(cfSimVertexes.product()) );
 
     // Create collections of things we will put in event
     trackingParticles_ = std::auto_ptr<TrackingParticleCollection>( new TrackingParticleCollection );
     trackingVertexes_ = std::auto_ptr<TrackingVertexCollection>( new TrackingVertexCollection );
 
     // Get references before put so we can cross reference
     refTrackingParticles_ = event.getRefBeforePut<TrackingParticleCollection>();
     refTrackingVertexes_ = event.getRefBeforePut<TrackingVertexCollection>();
 
     // Create a list of psimhits
     if (removeDeadModules_)
     {
         pSimHits_.clear();
         pixelPSimHitSelector_.select(pSimHits_, event, setup);
         trackerPSimHitSelector_.select(pSimHits_, event, setup);
         muonPSimHitSelector_.select(pSimHits_, event, setup);
     }
     else
     {
         pSimHits_.clear();
         pSimHitSelector_.select(pSimHits_, event, setup);
     }
 
     // Create a multimap between trackId and hit indices
     associator(pSimHits_, trackIdToHits_);
 
     // Create a map between trackId and track index
     associator(simTracks_, trackIdToIndex_);
 
     // Create a map between vertexId and vertex index
     associator(simVertexes_, vertexIdToIndex_);
 
     createTrackingTruth();
 
     if (mergedBremsstrahlung_)
     {
         // Create collections of things we will put in event,
         mergedTrackingParticles_ = std::auto_ptr<TrackingParticleCollection>( new TrackingParticleCollection );
         mergedTrackingVertexes_ = std::auto_ptr<TrackingVertexCollection>( new TrackingVertexCollection );
 
         // Get references before put so we can cross reference
         refMergedTrackingParticles_ = event.getRefBeforePut<TrackingParticleCollection>("MergedTrackTruth");
         refMergedTrackingVertexes_ = event.getRefBeforePut<TrackingVertexCollection>("MergedTrackTruth");
 
         // Merged brem electrons
         mergeBremsstrahlung();
 
         // Put TrackingParticles and TrackingVertices in event
         event.put(mergedTrackingParticles_, "MergedTrackTruth");
         event.put(mergedTrackingVertexes_, "MergedTrackTruth");
         event.put(trackingParticles_);
         event.put(trackingVertexes_);
     }
     else
     {
         // Put TrackingParticles and TrackingVertices in event
         event.put(trackingParticles_);
         event.put(trackingVertexes_);
     }
 }

bool TrackingTruthProducer::setTrackingParticle	(	SimTrack const &	simTrack,
		TrackingParticle &	trackingParticle
	)

private

Definition at line 631 of file TrackingTruthProducer.cc.

References TrackingParticle::addG4Track(), TrackingParticle::addGenParticle(), TrackingParticle::addPSimHit(), EncodedEventId::bunchCrossing(), CoreSimTrack::charge(), PSimHit::detUnitId(), EncodedEventId::event(), CoreSimTrack::eventId(), configurableAnalysis::GenParticle, SimTrack::genpartIndex(), hepMCProducts_, init, LayerFromDetid(), CoreSimTrack::momentum(), SimTrack::noVertex(), PSimHit::particleType(), benchmark_cfg::pdgId, position, PSimHit::processType(), pSimHits_, EncodedEventId::rawId(), selector_, selectorFlag_, TrackingParticle::setMatchedHit(), simVertexes_, ntuplemaker::status, DetId::subdetId(), CoreSimTrack::trackId(), trackIdToHits_, CoreSimTrack::type(), useMultipleHepMCLabels_, and SimTrack::vertIndex().

Referenced by createTrackingTruth().

 {
     // Get the eventid associated to the track
     EncodedEventId trackEventId = simTrack.eventId();
     // Get the simtrack id
     EncodedTruthId simTrackId = EncodedTruthId( trackEventId, simTrack.trackId() );
 
     // Location of the parent vertex
     LorentzVector position;
     // If not parent then location is (0,0,0,0)
     if (simTrack.noVertex())
         position = LorentzVector(0, 0, 0, 0);
     else
         position = simVertexes_->getObject(simTrack.vertIndex()). position();
 
     // Define the default status and pdgid
     int status = -99;
     int pdgId = simTrack.type();
 
     int genParticleIndex = simTrack.genpartIndex();
     bool signalEvent = (trackEventId.event() == 0 && trackEventId.bunchCrossing() == 0);
 
     // In the case of a existing generated particle and track
     // event is signal redefine status a pdgId
 
     edm::Handle<edm::HepMCProduct> hepmc;
 
     if (genParticleIndex >= 0 && (signalEvent || useMultipleHepMCLabels_) )
     {
         // Get the generated particle
         hepmc = (useMultipleHepMCLabels_) ? hepMCProducts_.at(trackEventId.rawId()) : hepmc = hepMCProducts_.at(0);
 
         const HepMC::GenParticle * genParticle = hepmc->GetEvent()->barcode_to_particle(genParticleIndex);
 
         if (genParticle)
         {
             status = genParticle->status();
             pdgId  = genParticle->pdg_id();
         }
     }
 
     // Create a tp from the simtrack
     trackingParticle = TrackingParticle(
                            (char) simTrack.charge(),
                            simTrack.momentum(),
                            Vector(position.x(), position.y(), position.z()),
                            position.t(),
                            pdgId,
                            status,
                            trackEventId
                        );
 
     bool init = true;
 
     int processType = 0;
     int particleType = 0;
 
     // Counting the TP hits using the layers (as in ORCA).
     // Does seem to find less hits. maybe b/c layer is a number now, not a pointer
     int totalSimHits = 0;
     int oldLayer = 0;
     int newLayer = 0;
     int oldDetector = 0;
     int newDetector = 0;
 
     // Loop over the associated hits per track
     for (
         EncodedTruthIdToIndexes::const_iterator iEntry = trackIdToHits_.lower_bound(simTrackId);
         iEntry != trackIdToHits_.upper_bound(simTrackId);
         ++iEntry
     )
     {
         // Get a constant reference to the simhit
         PSimHit const & pSimHit = pSimHits_.at(iEntry->second);
 
         // Initial condition for consistent simhit selection
         if (init)
         {
             processType = pSimHit.processType();
             particleType = pSimHit.particleType();
             init = false;
         }
 
         // Check for delta and interaction products discards
         if (processType == pSimHit.processType() && particleType == pSimHit.particleType() && pdgId == pSimHit.particleType() )
         {
             trackingParticle.addPSimHit(pSimHit);
 
             unsigned int detectorIdIndex = pSimHit.detUnitId();
             DetId detectorId = DetId(detectorIdIndex);
             oldLayer = newLayer;
             oldDetector = newDetector;
             newLayer = LayerFromDetid(detectorIdIndex);
             newDetector = detectorId.subdetId();
 
             // Count hits using layers for glued detectors
             // newlayer !=0 excludes Muon layers set to 0 by LayerFromDetid
             if ( ( oldLayer != newLayer || (oldLayer==newLayer && oldDetector!=newDetector ) ) && newLayer != 0 ) totalSimHits++;
         }
     }
 
     // Set the number of matched simhits
     trackingParticle.setMatchedHit(totalSimHits);
 
     // Add the simtrack associated to the tp
     trackingParticle.addG4Track(simTrack);
 
     // Add the generator information
     if ( genParticleIndex >= 0 && (signalEvent || useMultipleHepMCLabels_) )
         trackingParticle.addGenParticle( GenParticleRef(hepmc, genParticleIndex) );
 
     if (selectorFlag_) return selector_(trackingParticle);
 
     return true;
 }

int TrackingTruthProducer::setTrackingVertex	(	SimVertex const &	simVertex,
		TrackingVertex &	trackingVertex
	)

private

Definition at line 751 of file TrackingTruthProducer.cc.

References abs, addCloseGenVertexes(), TrackingVertex::addG4Vertex(), distanceCut_, CoreSimVertex::eventId(), eventIdCounter_, P, CoreSimVertex::position(), position, trackingVertexes_, volumeRadius_, and volumeZ_.

Referenced by createTrackingTruth().

 {
     LorentzVector const & position = simVertex.position();
 
     // Look for close by vertexes
     for (std::size_t trackingVertexIndex = 0; trackingVertexIndex < trackingVertexes_->size(); ++trackingVertexIndex)
     {
         // Calculate the distance
         double distance = (position - trackingVertexes_->at(trackingVertexIndex).position()).P();
         // If the distance is under a given cut return the trackingVertex index (vertex merging)
         if (distance <= distanceCut_)
         {
             // Add simvertex to the pre existent tv
             trackingVertexes_->at(trackingVertexIndex).addG4Vertex(simVertex);
             // return tv index
             return trackingVertexIndex;
         }
     }
 
     // Get the event if from the simvertex
     EncodedEventId simVertexEventId = simVertex.eventId();
 
     // Initialize the event counter
     if (eventIdCounter_.find(simVertexEventId) == eventIdCounter_.end())
         eventIdCounter_[simVertexEventId] = 0;
 
     // Get the simVertex id
     EncodedTruthId simVertexId = EncodedTruthId(simVertexEventId, eventIdCounter_[simVertexEventId]);
 
     // Calculate if the vertex is in the tracker volume (it needs to be review for other detectors)
     bool inVolume = (position.Pt() < volumeRadius_ && std::abs(position.z()) < volumeZ_); // In or out of Tracker
 
     // Initialize the new vertex
     trackingVertex = TrackingVertex(position, inVolume, simVertexId);
 
     // Find the the closest GenVertexes to the created tv
     addCloseGenVertexes(trackingVertex);
 
     // Add the g4 vertex to the tv
     trackingVertex.addG4Vertex(simVertex);
 
     // Initialize the event counter
     eventIdCounter_[simVertexEventId]++;
 
     return -1;
 }