#include <CaloTruthAccumulator.h>

Inheritance diagram for CaloTruthAccumulator:

Classes
struct	calo_particles

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

Public Member Functions
	CaloTruthAccumulator (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	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) override

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

std::unique_ptr< SimHitInfoPerSimTrack_t >	allAttachedSimHitInfo (Barcode_t st, const std::vector< std::pair< DetId, const PCaloHit * > > &hits, bool markUsed=false)

std::unique_ptr< SimHitInfoPerSimTrack_t >	attachedSimHitInfo (Barcode_t st, const std::vector< std::pair< DetId, const PCaloHit * > > &hits, bool includeOwn=true, bool includeOther=false, bool markUsed=false)

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

bool	consideredBarcode (Barcode_t barcode)

std::unique_ptr< SimHitInfoPerSimTrack_t >	descendantOnlySimHitInfo (Barcode_t st, const std::vector< std::pair< DetId, const PCaloHit * > > &hits, bool markUsed=false)

SimClusterCollection	descendantSimClusters (Barcode_t barcode, const std::vector< std::pair< DetId, const PCaloHit * > > &hits)

std::vector< Barcode_t >	descendantTrackBarcodes (Barcode_t barcode)

template<class T >
void	fillSimHits (std::vector< std::pair< DetId, const PCaloHit * > > &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) override

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

void	setConsideredBarcode (Barcode_t barcode)

Private Attributes
bool	barcodeLogicWarningAlready_

double	caloStartZ

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_

edm::InputTag	genParticleLabel_

const HcalDDDRecConstants *	hcddd_

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

const HGCalDDDConstants *	hgddd_ [2]

const HGCalTopology *	hgtopo_ [2]

edm::Handle< std::vector< SimTrack > >	hSimTracks

edm::Handle< std::vector< SimVertex > >	hSimVertices

calo_particles	m_caloParticles

std::unordered_multimap< Index_t, Index_t >	m_detIdToCluster

std::unordered_map< Index_t, float >	m_detIdToTotalSimEnergy

std::unordered_map< Barcode_t, Index_t >	m_genBarcodeToSimTrackIndex

std::unordered_map< Barcode_t, Index_t >	m_genParticleBarcodeToIndex

std::unordered_multimap< Barcode_t, Index_t >	m_simHitBarcodeToIndex

std::unordered_map< Barcode_t, Index_t >	m_simTrackBarcodeToIndex

std::unordered_map< Barcode_t, Barcode_t >	m_simTrackBarcodeToSimVertexParentBarcode

std::set< Barcode_t >	m_simTracksConsideredForSimClusters

std::unordered_multimap< Barcode_t, Index_t >	m_simTrackToSimVertex

std::vector< Barcode_t >	m_simVertexBarcodes

std::unordered_map< Barcode_t, Index_t >	m_simVertexBarcodeToIndex

std::unordered_multimap< Barcode_t, Barcode_t >	m_simVertexBarcodeToSimTrackBarcode

std::unordered_multimap< Barcode_t, Index_t >	m_simVertexToSimTrackParent

const unsigned int	maximumPreviousBunchCrossing_
	maximum distance for HepMC::GenVertex to be added to SimVertex More...

const unsigned int	maximumSubsequentBunchCrossing_

const double	maxPseudoRapidity_

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

const double	minEnergy_

OutputCollections	output_

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_
	If bremsstrahlung merging, whether to also add the unmerged collection to the event or not. More...

const edm::InputTag	simVertexLabel_

Detailed Description

Definition at line 44 of file CaloTruthAccumulator.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 41 of file CaloTruthAccumulator.cc.

References barcodeLogicWarningAlready_, collectionTags_, edm::ConsumesCollector::consumes(), genParticleLabel_, edm::ParameterSet::getParameterNames(), edm::ParameterSet::getParameterSet(), hepMCproductLabel_, simTrackLabel_, and simVertexLabel_.

                                                                                                                                      :
         messageCategory_("CaloTruthAccumulator"),
         maximumPreviousBunchCrossing_( config.getParameter<unsigned int>("maximumPreviousBunchCrossing") ),
         maximumSubsequentBunchCrossing_( config.getParameter<unsigned int>("maximumSubsequentBunchCrossing") ),
         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") ),
         minEnergy_( config.getParameter<double>("MinEnergy") ),
         maxPseudoRapidity_( config.getParameter<double>("MaxPseudoRapidity") )
 {
   barcodeLogicWarningAlready_ = false;
 
   mixMod.produces<SimClusterCollection>("MergedCaloTruth");
   mixMod.produces<CaloParticleCollection>("MergedCaloTruth");
   
   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<PCaloHit> >(collectionTag);
   }
 }

Member Function Documentation

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

overrideprivatevirtual

Referenced by initializeEvent().

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

overrideprivatevirtual

template<class T >

void CaloTruthAccumulator::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 193 of file CaloTruthAccumulator.cc.

References funct::abs(), descendantSimClusters(), reco::tau::disc::Eta(), fillSimHits(), genParticleLabel_, hSimTracks, hSimVertices, mps_fire::i, edm::HandleBase::isValid(), m_caloParticles, m_genBarcodeToSimTrackIndex, m_genParticleBarcodeToIndex, m_simHitBarcodeToIndex, m_simTrackBarcodeToIndex, m_simTrackBarcodeToSimVertexParentBarcode, m_simTracksConsideredForSimClusters, m_simTrackToSimVertex, m_simVertexBarcodes, m_simVertexBarcodeToIndex, m_simVertexBarcodeToSimTrackBarcode, m_simVertexToSimTrackParent, maxPseudoRapidity_, minEnergy_, output_, CaloTruthAccumulator::OutputCollections::pCaloParticles, CaloTruthAccumulator::OutputCollections::pSimClusters, CaloTruthAccumulator::calo_particles::sc_start_, CaloTruthAccumulator::calo_particles::sc_stop_, edm::second(), simTrackLabel_, tkConvValidator_cfi::simTracks, simVertexLabel_, and groupFilesInBlocks::temp.

Referenced by initializeEvent().

                                                                           {
   //
   // Get the collections
   //
   
   edm::Handle< std::vector<reco::GenParticle> > hGenParticles;
   edm::Handle< std::vector<int> > hGenParticleIndices;
   
   event.getByLabel( simTrackLabel_, hSimTracks );
   event.getByLabel( simVertexLabel_, hSimVertices );
   
   event.getByLabel( genParticleLabel_, hGenParticles );
   event.getByLabel( genParticleLabel_, hGenParticleIndices );
     
   std::vector<std::pair<DetId,const PCaloHit*> > simHitPointers;
   fillSimHits( simHitPointers, event, setup ); 
   
   // Clear maps from previous event fill them for this one
   m_simHitBarcodeToIndex.clear();
   m_simTracksConsideredForSimClusters.clear();
   for (unsigned int i = 0 ; i < simHitPointers.size(); ++i) {
     m_simHitBarcodeToIndex.emplace(simHitPointers[i].second->geantTrackId(),i);
   }
   m_genParticleBarcodeToIndex.clear();
   if( hGenParticles.isValid() && hGenParticleIndices.isValid() ) {
     for (unsigned int i = 0 ; i < hGenParticles->size() ; ++i) {
       m_genParticleBarcodeToIndex.emplace(hGenParticleIndices->at(i),i);
     }
   }
   m_genBarcodeToSimTrackIndex.clear();
   m_simVertexBarcodeToSimTrackBarcode.clear();
   m_simTrackBarcodeToSimVertexParentBarcode.clear();
   m_simTrackBarcodeToIndex.clear();
   for (unsigned int i = 0 ; i < hSimTracks->size() ; i++) {
     if( !hSimTracks->at(i).noGenpart() ) {
       m_genBarcodeToSimTrackIndex.emplace(hSimTracks->at(i).genpartIndex(), i);
     }
     if( !hSimTracks->at(i).noVertex() ) {
       m_simVertexBarcodeToSimTrackBarcode.emplace(hSimTracks->at(i).vertIndex(), hSimTracks->at(i).trackId());
       m_simTrackBarcodeToSimVertexParentBarcode.emplace(hSimTracks->at(i).trackId(), hSimTracks->at(i).vertIndex());
     }
     m_simTrackBarcodeToIndex.emplace(hSimTracks->at(i).trackId(), i);
   }
   m_simVertexBarcodes.clear();
   m_simVertexBarcodeToIndex.clear();
   m_simTrackToSimVertex.clear();
   m_simVertexToSimTrackParent.clear();
   for (unsigned int i = 0 ; i < hSimVertices->size() ; i++) {
     m_simVertexBarcodes.push_back(i);
     m_simVertexBarcodeToIndex.emplace(hSimVertices->at(i).vertexId(), i);
     if (!hSimVertices->at(i).noParent()) {
       m_simTrackToSimVertex.emplace(hSimVertices->at(i).parentIndex(), i);
       m_simVertexToSimTrackParent.emplace( hSimVertices->at(i).vertexId(), hSimVertices->at(i).parentIndex() );
     }
   }
   
   std::vector<Index_t> tracksToBecomeClustersInitial;
   std::vector<Barcode_t> descendantTracks;
   SimClusterCollection simClustersForGenParts;
   std::vector<std::unique_ptr<SimHitInfoPerSimTrack_t> > hitInfoList;
   std::vector<std::vector<uint32_t> > simClusterPrimitives;
   std::unordered_multimap<Index_t,Index_t> genPartsToSimClusters;
   const auto& simTracks = *hSimTracks;
   // loop over 
   for (unsigned int i = 0 ; i < simTracks.size() ; ++i) {
     if ( simTracks[i].momentum().E() < minEnergy_ || std::abs(simTracks[i].momentum().Eta()) >= maxPseudoRapidity_ ) continue;
     if ( simTracks[i].noGenpart() ) continue;
     auto temp = CaloTruthAccumulator::descendantSimClusters( simTracks[i].trackId(),simHitPointers );
     if( temp.size() ) {
       output_.pCaloParticles->emplace_back(simTracks[i]);
       m_caloParticles.sc_start_.push_back(output_.pSimClusters->size());
       auto mbegin = std::make_move_iterator(temp.begin());
       auto mend = std::make_move_iterator(temp.end());
       output_.pSimClusters->insert(output_.pSimClusters->end(), mbegin, mend);
       m_caloParticles.sc_stop_.push_back(output_.pSimClusters->size());
     }    
   }  
 }

std::unique_ptr< SimHitInfoPerSimTrack_t > CaloTruthAccumulator::allAttachedSimHitInfo	(	Barcode_t	st,
		const std::vector< std::pair< DetId, const PCaloHit * > > &	hits,
		bool	markUsed = `false`
	)

private

Definition at line 418 of file CaloTruthAccumulator.cc.

References attachedSimHitInfo(), and hfClusterShapes_cfi::hits.

Referenced by attachedSimHitInfo(), and descendantSimClusters().

                                          {
   return CaloTruthAccumulator::attachedSimHitInfo(barcode,hits,true,true,markUsed);
 }

std::unique_ptr< SimHitInfoPerSimTrack_t > CaloTruthAccumulator::attachedSimHitInfo	(	Barcode_t	st,
		const std::vector< std::pair< DetId, const PCaloHit * > > &	hits,
		bool	includeOwn = `true`,
		bool	includeOther = `false`,
		bool	markUsed = `false`
	)

private

Definition at line 355 of file CaloTruthAccumulator.cc.

References funct::abs(), allAttachedSimHitInfo(), barcodeLogicWarningAlready_, caloStartZ, consideredBarcode(), hfClusterShapes_cfi::hits, hSimTracks, m_simHitBarcodeToIndex, m_simTrackBarcodeToIndex, m_simTrackToSimVertex, m_simVertexBarcodes, m_simVertexBarcodeToSimTrackBarcode, messageCategory_, eostools::move(), gen::n, mps_fire::result, setConsideredBarcode(), simTrackMatching_cfi::simTrack, and tkConvValidator_cfi::simTracks.

Referenced by allAttachedSimHitInfo(), descendantOnlySimHitInfo(), and descendantSimClusters().

                                                                                                 {
   const auto& simTracks = *hSimTracks;
   std::unique_ptr<SimHitInfoPerSimTrack_t> result(new SimHitInfoPerSimTrack_t);
   
   const auto& simTrack = simTracks[m_simTrackBarcodeToIndex[barcode]];
 
   if ( markUsed ) {
     if ( CaloTruthAccumulator::consideredBarcode( barcode ) ) {
       return result;
     }
     CaloTruthAccumulator::setConsideredBarcode( barcode );
   }
   if (includeOwn) {
     auto range = m_simHitBarcodeToIndex.equal_range( barcode );
     unsigned n = 0;
     for ( auto iter = range.first ; iter != range.second ; iter++ ) {      
       const auto& the_hit = hits[iter->second];
       result->emplace_back(the_hit.first,the_hit.second->energy());      
       ++n;
     }    
   }
   
   // need to sim to the next sim track if we explicitly ask or 
   // if we are in the calorimeter next (no interaction)
   // or if this is a continuation of the same particle
   if (m_simTrackToSimVertex.count(barcode)) {
     auto vertex_range = m_simTrackToSimVertex.equal_range(barcode);
     for ( auto vertex_iter = vertex_range.first ; vertex_iter != vertex_range.second ; vertex_iter++ ) {
       Index_t decayVertexIndex = vertex_iter->second;
       const auto& nextVtx = (*hSimVertices)[decayVertexIndex];
       const bool nextInCalo = (std::abs(nextVtx.position().z()) > caloStartZ*0.1 - 20.0);  // add a buffer region in front of the calo face
 
       Barcode_t decayVertexBarcode = m_simVertexBarcodes[decayVertexIndex];      
     auto track_range = m_simVertexBarcodeToSimTrackBarcode.equal_range( decayVertexBarcode );
     for ( auto track_iter = track_range.first ; track_iter != track_range.second ; track_iter++ ) {
       if( !barcodeLogicWarningAlready_ && track_iter->second < barcode ) {
         barcodeLogicWarningAlready_ = true;
         edm::LogWarning(messageCategory_) << " Daughter particle has a lower barcode than parent. This may screw up the logic!" << std::endl;
       }
       const auto& daughter = simTracks[m_simTrackBarcodeToIndex[track_iter->second]];
 
       if( includeOther || nextInCalo ) {
         std::unique_ptr<SimHitInfoPerSimTrack_t> daughter_result = std::move(CaloTruthAccumulator::allAttachedSimHitInfo(track_iter->second,hits,markUsed));
         result->insert(result->end(),daughter_result->begin(),daughter_result->end());
       } else if ( daughter.type() == simTrack.type() ) {
         std::unique_ptr<SimHitInfoPerSimTrack_t> daughter_result = std::move(CaloTruthAccumulator::attachedSimHitInfo(track_iter->second,hits,includeOwn, includeOther, markUsed));
          result->insert(result->end(),daughter_result->begin(),daughter_result->end());
       }
     }
       }
     }
   return result;
 }

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

overrideprivatevirtual

Reimplemented from DigiAccumulatorMixMod.

Definition at line 79 of file CaloTruthAccumulator.cc.

References caloStartZ, HGCalTopology::dddConstants(), HcalTopology::dddConstants(), DetId::Forward, relativeConstraints::geom, edm::EventSetup::get(), CaloGeometry::getSubdetectorGeometry(), DetId::Hcal, HcalEndcap, hcddd_, HGCEE, HGCHEF, hgddd_, hgtopo_, mps_fire::i, HGCalGeometry::topology(), HcalGeometry::topology(), and HGCalDDDConstants::waferZ().

                                                                                                                    {
   edm::ESHandle<CaloGeometry> geom;
   iSetup.get<CaloGeometryRecord>().get(geom);
   const HGCalGeometry *eegeom, *fhgeom;
   const HcalGeometry *bhgeom;
 
   eegeom = dynamic_cast<const HGCalGeometry*>(geom->getSubdetectorGeometry(DetId::Forward,HGCEE));
   fhgeom = dynamic_cast<const HGCalGeometry*>(geom->getSubdetectorGeometry(DetId::Forward,HGCHEF));  
   bhgeom = dynamic_cast<const HcalGeometry*>(geom->getSubdetectorGeometry(DetId::Hcal,HcalEndcap));
 
   hgtopo_[0] = &(eegeom->topology());
   hgtopo_[1] = &(fhgeom->topology());
 
   for( unsigned i = 0; i < 2; ++i ) {
     hgddd_[i] = &(hgtopo_[i]->dddConstants());
   }
   
   hcddd_    = bhgeom->topology().dddConstants();
 
   caloStartZ = hgddd_[0]->waferZ(1,false)*10.0; // get the location of the first plane of silicon, put in mm
 }

bool CaloTruthAccumulator::consideredBarcode ( Barcode_t barcode )

inlineprivate

Definition at line 69 of file CaloTruthAccumulator.h.

Referenced by attachedSimHitInfo(), and descendantSimClusters().

                                               { 
     //    return (std::find(m_simTracksConsideredForSimClusters.begin(), m_simTracksConsideredForSimClusters.end(), barcode) != m_simTracksConsideredForSimClusters.end());
     return m_simTracksConsideredForSimClusters.count( barcode );
   }

std::unique_ptr< SimHitInfoPerSimTrack_t > CaloTruthAccumulator::descendantOnlySimHitInfo	(	Barcode_t	st,
		const std::vector< std::pair< DetId, const PCaloHit * > > &	hits,
		bool	markUsed = `false`
	)

private

Definition at line 411 of file CaloTruthAccumulator.cc.

References attachedSimHitInfo(), and hfClusterShapes_cfi::hits.

                                        {
   return CaloTruthAccumulator::attachedSimHitInfo(barcode,hits,false,true,markUsed);
 }

SimClusterCollection CaloTruthAccumulator::descendantSimClusters	(	Barcode_t	barcode,
		const std::vector< std::pair< DetId, const PCaloHit * > > &	hits
	)

private

Definition at line 292 of file CaloTruthAccumulator.cc.

References funct::abs(), allAttachedSimHitInfo(), attachedSimHitInfo(), caloStartZ, consideredBarcode(), hfClusterShapes_cfi::hits, hSimTracks, hSimVertices, LogDebug, m_simTrackBarcodeToIndex, m_simTrackBarcodeToSimVertexParentBarcode, m_simTrackToSimVertex, m_simVertexBarcodes, m_simVertexBarcodeToIndex, m_simVertexBarcodeToSimTrackBarcode, eostools::move(), mps_fire::result, simTrackMatching_cfi::simTrack, tkConvValidator_cfi::simTracks, and badGlobalMuonTaggersAOD_cff::vtx.

Referenced by accumulateEvent().

                                                                                                                                             {
   SimClusterCollection result;
   const auto& simTracks = *hSimTracks;
   if ( CaloTruthAccumulator::consideredBarcode( barcode ) ) {
     LogDebug("CaloParticles") << "SCZ DEBUG Ignoring descendantSimClusters call because this particle is already marked used: " << barcode << std::endl;
     //return result;
   }
 
   std::unique_ptr<SimHitInfoPerSimTrack_t> hit_info = std::move(CaloTruthAccumulator::attachedSimHitInfo(barcode,hits, true, false, false));
   //std::unique_ptr<SimHitInfoPerSimTrack_t> inclusive_hit_info = std::move(CaloTruthAccumulator::allAttachedSimHitInfo(barcode,hits, false) );
 
   const auto& simTrack = simTracks[m_simTrackBarcodeToIndex[barcode]];
   Barcode_t vtxBarcode = m_simTrackBarcodeToSimVertexParentBarcode[barcode];
   const auto& vtx = hSimVertices->at(m_simVertexBarcodeToIndex[vtxBarcode]);
   const bool isInCalo = (std::abs(vtx.position().z()) > caloStartZ - 30.0); // add a buffer region in front of the calo face
 
   if (hit_info->size() > 0) {
     // define the sim cluster starting from the earliest particle that has hits in the calorimeter
     // grab everything that descends from it
     std::unique_ptr<SimHitInfoPerSimTrack_t> marked_hit_info;
     
     
     if( isInCalo  ) {
       marked_hit_info = std::move( CaloTruthAccumulator::allAttachedSimHitInfo(barcode,hits,true) );
     } else {    
       marked_hit_info = std::move( CaloTruthAccumulator::attachedSimHitInfo(barcode,hits,true,false,true) );
     }   
     
     if( marked_hit_info->size() != 0 ) {
       result.emplace_back(simTrack);
       auto& simcluster = result.back();
       
       std::unordered_map<uint32_t,float> acc_energy;
       
       for( const auto& hit_and_energy : *marked_hit_info ) {
     const uint32_t id = hit_and_energy.first.rawId();      
     if( acc_energy.count(id) ) acc_energy[id] += hit_and_energy.second;
     else acc_energy[id] = hit_and_energy.second;
       }    
       
       for( const auto& hit_and_energy : acc_energy ) {
     simcluster.addRecHitAndFraction(hit_and_energy.first,hit_and_energy.second);
       }
     }
   } 
   
   if ( m_simTrackToSimVertex.count(barcode) ) {
     auto vertex_range = m_simTrackToSimVertex.equal_range(barcode);
     for ( auto vertex_iter = vertex_range.first ; vertex_iter != vertex_range.second ; vertex_iter++ ) {
       Index_t decayVertexIndex = vertex_iter->second;
       Barcode_t decayVertexBarcode = m_simVertexBarcodes[decayVertexIndex];
       auto track_range = m_simVertexBarcodeToSimTrackBarcode.equal_range( decayVertexBarcode );
       for ( auto track_iter = track_range.first ; track_iter != track_range.second ; track_iter++ ) {
     
     auto daughter_result = CaloTruthAccumulator::descendantSimClusters(track_iter->second,hits);
     result.insert(result.end(),daughter_result.begin(),daughter_result.end());
       }
     }
   }
   
   return result;
 }  

std::vector< Barcode_t > CaloTruthAccumulator::descendantTrackBarcodes ( Barcode_t barcode )

private

Definition at line 274 of file CaloTruthAccumulator.cc.

References m_simTrackToSimVertex, m_simVertexBarcodes, m_simVertexBarcodeToSimTrackBarcode, and mps_fire::result.

                                                                                       {
   std::vector<Barcode_t> result;
   if (m_simTrackToSimVertex.count(barcode)) {
     auto vertex_range = m_simTrackToSimVertex.equal_range(barcode);
     for ( auto vertex_iter = vertex_range.first ; vertex_iter != vertex_range.second ; vertex_iter++ ) {
       Index_t decayVertexIndex = vertex_iter->second;
       Barcode_t decayVertexBarcode = m_simVertexBarcodes[decayVertexIndex];
       auto track_range = m_simVertexBarcodeToSimTrackBarcode.equal_range( decayVertexBarcode );
       for ( auto track_iter = track_range.first ; track_iter != track_range.second ; track_iter++ ) {
     result.push_back( track_iter->second );
     std::vector<Barcode_t> daughter_result = CaloTruthAccumulator::descendantTrackBarcodes( track_iter->second );
     result.insert(result.end(),daughter_result.begin(),daughter_result.end());
       }
     }
   }
   return result;
 }

template<class T >

void CaloTruthAccumulator::fillSimHits	(	std::vector< std::pair< DetId, const PCaloHit * > > &	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 424 of file CaloTruthAccumulator.cc.

References collectionTags_, DEFINE_DIGI_ACCUMULATOR, HcalEndcap, hcddd_, hgddd_, hgtopo_, hcalTTPDigis_cfi::id, m_detIdToTotalSimEnergy, HcalHitRelabeller::relabel(), rpcPointValidation_cfi::simHit, HGCalDDDConstants::simToReco(), HcalDetId::subdet(), and HGCalTestNumbering::unpackHexagonIndex().

Referenced by accumulateEvent().

                                                                                                                                                                {
   // loop over the collections
   for( const auto& collectionTag : collectionTags_ ) {
     edm::Handle< std::vector<PCaloHit> > hSimHits;
     const bool isHcal = ( collectionTag.instance().find("HcalHits") != std::string::npos );
     event.getByLabel( collectionTag, hSimHits );
     for( const auto& simHit : *hSimHits ) {
       DetId id(0);
       const uint32_t simId = simHit.id();
       if( isHcal ) {
         HcalDetId hid = HcalHitRelabeller::relabel(simId, hcddd_);
         if(hid.subdet()==HcalEndcap) id = hid;
       } else {
     int subdet, layer, cell, sec, subsec, zp;
     HGCalTestNumbering::unpackHexagonIndex(simId, subdet, zp, layer, sec, subsec, cell); 
     const HGCalDDDConstants* ddd = hgddd_[subdet-3];
     std::pair<int,int> recoLayerCell = ddd->simToReco(cell,layer,sec,
                               hgtopo_[subdet-3]->detectorType());
     cell  = recoLayerCell.first;
     layer = recoLayerCell.second;
     // skip simhits with bad barcodes or non-existant layers
     if( layer == -1  || simHit.geantTrackId() == 0 ) continue;
     id = HGCalDetId((ForwardSubdetector)subdet,zp,layer,subsec,sec,cell);
       }
 
       if( DetId(0) == id ) continue;
       
       uint32_t detId = id.rawId();
       returnValue.emplace_back(id, &simHit);
       
       if( m_detIdToTotalSimEnergy.count(detId) ) m_detIdToTotalSimEnergy[detId] += simHit.energy();
       else m_detIdToTotalSimEnergy[detId] = simHit.energy();
     }
   } // end of loop over InputTags
 }

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

overrideprivatevirtual

Definition at line 139 of file CaloTruthAccumulator.cc.

References SimCluster::addRecHitAndFraction(), CaloParticle::addSimCluster(), SimCluster::clearHitsAndFractions(), SimDataFormats::CaloAnalysis::cp, dedxEstimators_cff::fraction, SimCluster::hits_and_fractions(), mps_fire::i, m_caloParticles, m_detIdToCluster, m_detIdToTotalSimEnergy, m_genBarcodeToSimTrackIndex, m_genParticleBarcodeToIndex, m_simHitBarcodeToIndex, m_simTrackBarcodeToIndex, m_simTrackBarcodeToSimVertexParentBarcode, m_simTrackToSimVertex, m_simVertexBarcodes, m_simVertexBarcodeToIndex, m_simVertexBarcodeToSimTrackBarcode, m_simVertexToSimTrackParent, eostools::move(), output_, CaloTruthAccumulator::OutputCollections::pCaloParticles, CaloTruthAccumulator::OutputCollections::pSimClusters, SimDataFormats::CaloAnalysis::sc, CaloTruthAccumulator::calo_particles::sc_start_, CaloTruthAccumulator::calo_particles::sc_stop_, CaloTruthAccumulator::calo_particles::swap(), and edm::swap().

                                                                                       {
   edm::LogInfo("CaloTruthAccumulator") << "Adding " << output_.pSimClusters->size() 
                        << " SimParticles and " << output_.pCaloParticles->size()
                        << " CaloParticles to the event.";
 
   // now we need to normalize the hits and energies into hits and fractions
   // (since we have looped over all pileup events)
 
   for( auto& sc : *(output_.pSimClusters) ) {
     auto hitsAndEnergies = sc.hits_and_fractions();
     sc.clearHitsAndFractions();
     for( auto& hAndE : hitsAndEnergies ) {
       const float totalenergy = m_detIdToTotalSimEnergy[hAndE.first];
       float fraction = 0.;
       if(totalenergy>0) fraction = hAndE.second/totalenergy;
       else edm::LogWarning("CaloTruthAccumulator") << "TotalSimEnergy for hit " << hAndE.first << " is 0! The fraction for this hit cannot be computed.";
       sc.addRecHitAndFraction(hAndE.first,fraction);
     }
   }
   
   // save the SimCluster orphan handle so we can fill the calo particles
   auto scHandle = event.put( std::move(output_.pSimClusters), "MergedCaloTruth" );
   
   // now fill the calo particles
   for( unsigned i = 0; i < output_.pCaloParticles->size(); ++i ) {
     auto& cp = (*output_.pCaloParticles)[i];
     for( unsigned j = m_caloParticles.sc_start_[i]; j < m_caloParticles.sc_stop_[i]; ++j ) {
       edm::Ref<SimClusterCollection> ref(scHandle,j);
       cp.addSimCluster(ref);
     }
   }  
 
   event.put( std::move(output_.pCaloParticles), "MergedCaloTruth" );
 
   calo_particles().swap(m_caloParticles);
 
   std::unordered_map<Index_t,float>().swap(m_detIdToTotalSimEnergy);
 
   std::unordered_map<Barcode_t,Index_t>().swap(m_genParticleBarcodeToIndex);
   std::unordered_map<Barcode_t,Index_t>().swap(m_simTrackBarcodeToIndex);
   std::unordered_map<Barcode_t,Index_t>().swap(m_genBarcodeToSimTrackIndex);
   std::unordered_map<Barcode_t,Index_t>().swap(m_simVertexBarcodeToIndex);
 
   std::unordered_multimap<Index_t,Index_t>().swap(m_detIdToCluster);
   std::unordered_multimap<Barcode_t,Index_t>().swap(m_simHitBarcodeToIndex);
   std::unordered_multimap<Barcode_t,Barcode_t>().swap(m_simVertexBarcodeToSimTrackBarcode);
   std::unordered_map<Barcode_t,Barcode_t>().swap(m_simTrackBarcodeToSimVertexParentBarcode);
   std::unordered_multimap<Barcode_t,Index_t>().swap(m_simTrackToSimVertex);
   std::unordered_multimap<Barcode_t,Index_t>().swap(m_simVertexToSimTrackParent); 
   std::vector<Barcode_t>().swap(m_simVertexBarcodes);
   std::unordered_map<Index_t,float>().swap(m_detIdToTotalSimEnergy);
 }

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

overrideprivatevirtual

Definition at line 101 of file CaloTruthAccumulator.cc.

References accumulate(), accumulateEvent(), PileUpEventPrincipal::bunchCrossing(), hepMCproductLabel_, m_detIdToCluster, m_detIdToTotalSimEnergy, maximumPreviousBunchCrossing_, maximumSubsequentBunchCrossing_, messageCategory_, output_, CaloTruthAccumulator::OutputCollections::pCaloParticles, CaloTruthAccumulator::OutputCollections::pSimClusters, and GeneralSetup::setup().

 {
   output_.pSimClusters.reset( new SimClusterCollection() );
   output_.pCaloParticles.reset( new CaloParticleCollection() );
 
   m_detIdToCluster.clear();
   m_detIdToTotalSimEnergy.clear();
 }

void CaloTruthAccumulator::setConsideredBarcode ( Barcode_t barcode )

inlineprivate

Definition at line 68 of file CaloTruthAccumulator.h.

Referenced by attachedSimHitInfo().

68 { m_simTracksConsideredForSimClusters.insert( barcode ); }

CaloTruthAccumulator::m_simTracksConsideredForSimClusters

std::set< Barcode_t > m_simTracksConsideredForSimClusters

Definition: CaloTruthAccumulator.h:67

Member Data Documentation

bool CaloTruthAccumulator::barcodeLogicWarningAlready_

private

Definition at line 147 of file CaloTruthAccumulator.h.

Referenced by attachedSimHitInfo(), and CaloTruthAccumulator().

double CaloTruthAccumulator::caloStartZ

private

Definition at line 92 of file CaloTruthAccumulator.h.

Referenced by attachedSimHitInfo(), beginLuminosityBlock(), and descendantSimClusters().

bool CaloTruthAccumulator::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 143 of file CaloTruthAccumulator.h.

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

private

Definition at line 134 of file CaloTruthAccumulator.h.

Referenced by CaloTruthAccumulator(), and fillSimHits().

edm::InputTag CaloTruthAccumulator::genParticleLabel_

private

Definition at line 135 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent(), and CaloTruthAccumulator().

const HcalDDDRecConstants* CaloTruthAccumulator::hcddd_

private

Definition at line 171 of file CaloTruthAccumulator.h.

Referenced by beginLuminosityBlock(), and fillSimHits().

edm::InputTag CaloTruthAccumulator::hepMCproductLabel_

private

Needed to add HepMC::GenVertex to SimVertex.

Definition at line 137 of file CaloTruthAccumulator.h.

Referenced by CaloTruthAccumulator(), and initializeEvent().

const HGCalDDDConstants* CaloTruthAccumulator::hgddd_[2]

private

Definition at line 170 of file CaloTruthAccumulator.h.

Referenced by beginLuminosityBlock(), and fillSimHits().

const HGCalTopology* CaloTruthAccumulator::hgtopo_[2]

private

Definition at line 169 of file CaloTruthAccumulator.h.

Referenced by beginLuminosityBlock(), and fillSimHits().

edm::Handle<std::vector<SimTrack> > CaloTruthAccumulator::hSimTracks

private

Definition at line 131 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent(), attachedSimHitInfo(), and descendantSimClusters().

edm::Handle<std::vector<SimVertex> > CaloTruthAccumulator::hSimVertices

private

Definition at line 132 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent(), and descendantSimClusters().

calo_particles CaloTruthAccumulator::m_caloParticles

private

Definition at line 91 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent(), and finalizeEvent().

std::unordered_multimap<Index_t,Index_t> CaloTruthAccumulator::m_detIdToCluster

private

Definition at line 99 of file CaloTruthAccumulator.h.

Referenced by finalizeEvent(), and initializeEvent().

std::unordered_map<Index_t,float> CaloTruthAccumulator::m_detIdToTotalSimEnergy

private

Definition at line 94 of file CaloTruthAccumulator.h.

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

std::unordered_map<Barcode_t,Index_t> CaloTruthAccumulator::m_genBarcodeToSimTrackIndex

private

Definition at line 97 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent(), and finalizeEvent().

std::unordered_map<Barcode_t,Index_t> CaloTruthAccumulator::m_genParticleBarcodeToIndex

private

Definition at line 95 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent(), and finalizeEvent().

std::unordered_multimap<Barcode_t,Index_t> CaloTruthAccumulator::m_simHitBarcodeToIndex

private

Definition at line 100 of file CaloTruthAccumulator.h.

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

std::unordered_map<Barcode_t,Index_t> CaloTruthAccumulator::m_simTrackBarcodeToIndex

private

Definition at line 96 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent(), attachedSimHitInfo(), descendantSimClusters(), and finalizeEvent().

std::unordered_map<Barcode_t,Barcode_t> CaloTruthAccumulator::m_simTrackBarcodeToSimVertexParentBarcode

private

Definition at line 102 of file CaloTruthAccumulator.h.

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

std::set<Barcode_t> CaloTruthAccumulator::m_simTracksConsideredForSimClusters

private

Definition at line 67 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent().

std::unordered_multimap<Barcode_t,Index_t> CaloTruthAccumulator::m_simTrackToSimVertex

private

Definition at line 103 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent(), attachedSimHitInfo(), descendantSimClusters(), descendantTrackBarcodes(), and finalizeEvent().

std::vector<Barcode_t> CaloTruthAccumulator::m_simVertexBarcodes

private

Definition at line 107 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent(), attachedSimHitInfo(), descendantSimClusters(), descendantTrackBarcodes(), and finalizeEvent().

std::unordered_map<Barcode_t,Index_t> CaloTruthAccumulator::m_simVertexBarcodeToIndex

private

Definition at line 98 of file CaloTruthAccumulator.h.

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

std::unordered_multimap<Barcode_t,Barcode_t> CaloTruthAccumulator::m_simVertexBarcodeToSimTrackBarcode

private

Definition at line 101 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent(), attachedSimHitInfo(), descendantSimClusters(), descendantTrackBarcodes(), and finalizeEvent().

std::unordered_multimap<Barcode_t,Index_t> CaloTruthAccumulator::m_simVertexToSimTrackParent

private

Definition at line 104 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent(), and finalizeEvent().

const unsigned int CaloTruthAccumulator::maximumPreviousBunchCrossing_

private

maximum distance for HepMC::GenVertex to be added to SimVertex

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 117 of file CaloTruthAccumulator.h.

Referenced by initializeEvent().

const unsigned int CaloTruthAccumulator::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 120 of file CaloTruthAccumulator.h.

Referenced by initializeEvent().

const double CaloTruthAccumulator::maxPseudoRapidity_

private

Definition at line 139 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent().

const std::string CaloTruthAccumulator::messageCategory_

private

The message category used to send messages to MessageLogger.

Definition at line 74 of file CaloTruthAccumulator.h.

Referenced by attachedSimHitInfo(), and initializeEvent().

const double CaloTruthAccumulator::minEnergy_

private

Definition at line 139 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent().

OutputCollections CaloTruthAccumulator::output_

private

Definition at line 172 of file CaloTruthAccumulator.h.

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

bool CaloTruthAccumulator::selectorFlag_

private

Definition at line 141 of file CaloTruthAccumulator.h.

bool CaloTruthAccumulator::signalOnly_

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 145 of file CaloTruthAccumulator.h.

const edm::InputTag CaloTruthAccumulator::simTrackLabel_

private

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

Whether or not to create a separate collection for just the initial interaction vertices Whether or not to add the full parentage of any TrackingParticle that is inserted in the collection.

Definition at line 129 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent(), and CaloTruthAccumulator().

const edm::InputTag CaloTruthAccumulator::simVertexLabel_

private

Definition at line 130 of file CaloTruthAccumulator.h.

Referenced by accumulateEvent(), and CaloTruthAccumulator().

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation