Inheritance diagram for CaloTruthAccumulator:

Classes
struct	calo_particles

struct	OutputCollections

Public Member Functions
	CaloTruthAccumulator (const edm::ParameterSet &config, edm::ProducerBase &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
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...

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

template<class T >
void	fillSimHits (std::vector< std::pair< DetId, const PCaloHit * > > &returnValue, std::unordered_map< int, std::map< int, float > > &simTrackDetIdEnergyMap, 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
std::vector< edm::InputTag >	collectionTags_

edm::InputTag	genParticleLabel_

int	geometryType_

const HcalDDDRecConstants *	hcddd_ = 0

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

const HGCalDDDConstants *	hgddd_ [3] = { 0 , 0 , 0 }

const HGCalTopology *	hgtopo_ [3] = { 0 , 0 , 0 }

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

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

calo_particles	m_caloParticles

std::unordered_map< Index_t, float >	m_detIdToTotalSimEnergy

std::unordered_multimap< Barcode_t, Index_t >	m_simHitBarcodeToIndex

const unsigned int	maximumPreviousBunchCrossing_

const unsigned int	maximumSubsequentBunchCrossing_

const double	maxPseudoRapidity_

const std::string	messageCategory_

const double	minEnergy_

OutputCollections	output_

const bool	premixStage1_

const edm::InputTag	simTrackLabel_

const edm::InputTag	simVertexLabel_

Detailed Description

Definition at line 124 of file CaloTruthAccumulator.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 366 of file CaloTruthAccumulator.cc.

References collectionTags_, edm::ConsumesCollector::consumes(), genParticleLabel_, edm::ParameterSet::getParameterNames(), edm::ParameterSet::getParameterSet(), hepMCproductLabel_, premixStage1_, edm::ProductRegistryHelper::produces(), 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")),
       premixStage1_(config.getParameter<bool>("premixStage1")),
       geometryType_(-1)
 {
   mixMod.produces<SimClusterCollection>("MergedCaloTruth");
   mixMod.produces<CaloParticleCollection>("MergedCaloTruth");
   if(premixStage1_) {
     mixMod.produces<std::vector<std::pair<unsigned int, float> > >("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 (auto const& parameterName : parameterNames) {
     std::vector<edm::InputTag> tags =
         simHitCollectionConfig.getParameter<std::vector<edm::InputTag> >(parameterName);
     collectionTags_.insert(collectionTags_.end(), tags.begin(), tags.end());
   }
 
   for (auto const& collectionTag : collectionTags_) {
     iC.consumes<std::vector<PCaloHit> >(collectionTag);
   }
 }

Member Function Documentation

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

overrideprivate

Referenced by initializeEvent().

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

overrideprivate

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.

Build the main decay graph and assign the SimTrack to each edge. The graph built here will only contain the particles that have a decay vertex associated to them. In order to recover also the particles that will not decay, we need to keep track of the SimTrack used here and add, a-posteriori, the ones not used, associating a ghost vertex (starting from the highest simulated vertex number), in order to build the edge and identify them immediately as stable (i.e. not decayed).

To take into account the multi-bremsstrahlung effects in which a single particle is emitting photons in different vertices keeping the same track index, we also collapsed those vertices into 1 unique vertex. The other approach of fully representing the decay chain keeping the same track index would have the problem of over-counting the contributions of that track, especially in terms of hits.

The 2 auxiliary vectors are structured as follow:

used_sim_tracks is a vector that has the same size as the overall number of simulated tracks. The associated integer is the vertexId of the decaying vertex for that track.
collapsed_vertices is a vector that has the same size as the overall number of simulated vertices. The vector's index is the vertexId itself, the associated value is the vertexId of the vertex on which this should collapse.

Definition at line 536 of file CaloTruthAccumulator.cc.

References funct::abs(), gather_cfg::cout, EdgeProperty::cumulative_simHits, DEBUG, SelectingProcedure_cff::decay, fillSimHits(), genParticleLabel_, hSimTracks, hSimVertices, mps_fire::i, training_settings::idx, IfLogDebug, m_caloParticles, m_simHitBarcodeToIndex, maxPseudoRapidity_, messageCategory_, minEnergy_, CoreSimTrack::momentum(), SimTrack::noGenpart(), PFRecoTauDiscriminationByIsolation_cfi::offset, output_, put(), edm::second(), EdgeProperty::simTrack, simTrackLabel_, simVertexLabel_, findQualityFiles::size, lumiQTWidget::t, l1t::tracks, findQualityFiles::v, electrons_cff::vertices, and runTauDisplay::vis.

Referenced by initializeEvent().

                                                     {
 
   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;
   std::unordered_map<int, std::map<int, float> > simTrackDetIdEnergyMap;
   fillSimHits(simHitPointers, simTrackDetIdEnergyMap, event, setup);
 
   // Clear maps from previous event fill them for this one
   m_simHitBarcodeToIndex.clear();
   for (unsigned int i = 0; i < simHitPointers.size(); ++i) {
     m_simHitBarcodeToIndex.emplace(simHitPointers[i].second->geantTrackId(), i);
   }
 
   auto const& tracks = *hSimTracks;
   auto const& vertices = *hSimVertices;
   std::unordered_map<int, int> trackid_to_track_index;
   DecayChain decay;
   int idx = 0;
 
   IfLogDebug(DEBUG, messageCategory_) << " TRACKS" << std::endl;
   for (auto const& t : tracks) {
     IfLogDebug(DEBUG, messageCategory_)
         << " " << idx << "\t" << t.trackId() << "\t" << t << std::endl;
     trackid_to_track_index[t.trackId()] = idx;
     idx++;
   }
 
   idx = 0;
   std::vector<int> used_sim_tracks(tracks.size(), 0);
   std::vector<int> collapsed_vertices(vertices.size(), 0);
   IfLogDebug(DEBUG, messageCategory_) << " VERTICES" << std::endl;
   for (auto const& v : vertices) {
     IfLogDebug(DEBUG, messageCategory_) << " " << idx++ << "\t" << v << std::endl;
     if (v.parentIndex() != -1) {
       auto trk_idx = trackid_to_track_index[v.parentIndex()];
       auto origin_vtx = tracks[trk_idx].vertIndex();
       if (used_sim_tracks[trk_idx]) {
         // collapse the vertex into the original first vertex we saw associated
         // to this track. Omit adding the edge in order to avoid double
         // counting of the very same particles  and its associated hits.
         collapsed_vertices[v.vertexId()] = used_sim_tracks[trk_idx];
         continue;
       }
       // Perform the actual vertex collapsing, if needed.
       if (collapsed_vertices[origin_vtx]) origin_vtx = collapsed_vertices[origin_vtx];
       add_edge(origin_vtx, v.vertexId(),
                EdgeProperty(&tracks[trk_idx], simTrackDetIdEnergyMap[v.parentIndex()].size(), 0),
                decay);
       used_sim_tracks[trk_idx] = v.vertexId();
     }
   }
   // Build the motherParticle property to each vertex
   auto const& vertexMothersProp = get(vertex_name, decay);
   // Now recover the particles that did not decay. Append them with an index
   // bigger than the size of the generated vertices.
   int offset = vertices.size();
   for (size_t i = 0; i < tracks.size(); ++i) {
     if (!used_sim_tracks[i]) {
       auto origin_vtx = tracks[i].vertIndex();
       // Perform the actual vertex collapsing, if needed.
       if (collapsed_vertices[origin_vtx]) origin_vtx = collapsed_vertices[origin_vtx];
       add_edge(origin_vtx, offset,
                EdgeProperty(&tracks[i], simTrackDetIdEnergyMap[tracks[i].trackId()].size(), 0),
                decay);
       // The properties for "fake" vertices associated to stable particles have
       // to be set inside this loop, since they do not belong to the vertices
       // collection and would be skipped by that loop (coming next)
       put(vertexMothersProp, offset, VertexProperty(&tracks[i], 0));
       offset++;
     }
   }
   for (auto const& v : vertices) {
     if (v.parentIndex() != -1) {
       // Skip collapsed_vertices
       if (collapsed_vertices[v.vertexId()]) continue;
       put(vertexMothersProp, v.vertexId(),
           VertexProperty(&tracks[trackid_to_track_index[v.parentIndex()]], 0));
     }
   }
   SimHitsAccumulator_dfs_visitor vis;
   depth_first_search(decay, visitor(vis));
   CaloParticle_dfs_visitor caloParticleCreator(
       output_, m_caloParticles, m_simHitBarcodeToIndex, simTrackDetIdEnergyMap,
       [&](EdgeProperty& edge_property) -> bool {
         // Apply selection on SimTracks in order to promote them to be CaloParticles.
         // The function returns TRUE if the particle satisfies the selection, FALSE otherwise.
         // Therefore the correct logic to select the particle is to ask for TRUE as return value.
         return (edge_property.cumulative_simHits != 0 and !edge_property.simTrack->noGenpart() and
                 edge_property.simTrack->momentum().E() > minEnergy_ and
                 std::abs(edge_property.simTrack->momentum().Eta()) < maxPseudoRapidity_);
       });
   depth_first_search(decay, visitor(caloParticleCreator));
 
 #if DEBUG
   boost::write_graphviz(std::cout, decay, make_label_writer(make_transform_value_property_map(
                                               &graphviz_vertex, get(vertex_name, decay))),
                         make_label_writer(make_transform_value_property_map(
                             &graphviz_edge, get(edge_weight, decay))));
 #endif
 }

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

overrideprivatevirtual

Reimplemented from DigiAccumulatorMixMod.

Definition at line 411 of file CaloTruthAccumulator.cc.

References HGCalTopology::dddConstants(), HcalTopology::dddConstants(), DetId::Forward, ForwardEmpty, relativeConstraints::geom, geometryType_, edm::EventSetup::get(), CaloGeometry::getSubdetectorGeometry(), DetId::Hcal, HcalEndcap, hcddd_, DetId::HGCalEE, DetId::HGCalHSc, DetId::HGCalHSi, HGCEE, HGCHEF, hgddd_, hgtopo_, mps_fire::i, HGCalGeometry::topology(), and HcalGeometry::topology().

                                                                                       {
   edm::ESHandle<CaloGeometry> geom;
   iSetup.get<CaloGeometryRecord>().get(geom);
   const HGCalGeometry *eegeom = nullptr, *fhgeom = nullptr, *bhgeomnew = nullptr;
   const HcalGeometry* bhgeom = nullptr;
 
   eegeom = static_cast<const HGCalGeometry*>(geom->getSubdetectorGeometry(DetId::HGCalEE,ForwardSubdetector::ForwardEmpty));
   //check if it's the new geometry
   if(eegeom){
     geometryType_ = 1;
     fhgeom = static_cast<const HGCalGeometry*>(geom->getSubdetectorGeometry(DetId::HGCalHSi,ForwardSubdetector::ForwardEmpty));
     bhgeomnew = static_cast<const HGCalGeometry*>(geom->getSubdetectorGeometry(DetId::HGCalHSc,ForwardSubdetector::ForwardEmpty));
   }
   else {
     geometryType_ = 0;
     eegeom = static_cast<const HGCalGeometry*>(geom->getSubdetectorGeometry(DetId::Forward, HGCEE));
     fhgeom = static_cast<const HGCalGeometry*>(geom->getSubdetectorGeometry(DetId::Forward, HGCHEF));
     bhgeom = static_cast<const HcalGeometry*>(geom->getSubdetectorGeometry(DetId::Hcal, HcalEndcap));
   }
   hgtopo_[0] = &(eegeom->topology());
   hgtopo_[1] = &(fhgeom->topology());
   if(bhgeomnew) hgtopo_[2] = &(bhgeomnew->topology());
 
   for (unsigned i = 0; i < 3; ++i) {
     if(hgtopo_[i]) hgddd_[i] = &(hgtopo_[i]->dddConstants());
   }
 
   if(bhgeom) hcddd_ = bhgeom->topology().dddConstants();
 }

template<class T >

void CaloTruthAccumulator::fillSimHits	(	std::vector< std::pair< DetId, const PCaloHit * > > &	returnValue,
		std::unordered_map< int, std::map< int, float > > &	simTrackDetIdEnergyMap,
		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 674 of file CaloTruthAccumulator.cc.

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

Referenced by accumulateEvent().

                                 {
   for (auto const& collectionTag : collectionTags_) {
     edm::Handle<std::vector<PCaloHit> > hSimHits;
     const bool isHcal = (collectionTag.instance().find("HcalHits") != std::string::npos);
     event.getByLabel(collectionTag, hSimHits);
     for (auto const& simHit : *hSimHits) {
       DetId id(0);
       const uint32_t simId = simHit.id();
       if (geometryType_==1) {
         //no test numbering in new geometry
         id = simId;
       }
       else 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);
       simTrackDetIdEnergyMap[simHit.geantTrackId()][id.rawId()] += simHit.energy();
 
       m_detIdToTotalSimEnergy[detId] += simHit.energy();
     }
   }  // end of loop over InputTags
 }

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

overrideprivate

Definition at line 482 of file CaloTruthAccumulator.cc.

References SimCluster::addRecHitAndFraction(), CaloParticle::addSimCluster(), SimCluster::clearHitsAndFractions(), popcon2dropbox::copy(), SimDataFormats::CaloAnalysis::cp, dedxEstimators_cff::fraction, SimCluster::hits_and_fractions(), mps_fire::i, m_caloParticles, m_detIdToTotalSimEnergy, m_simHitBarcodeToIndex, messageCategory_, eostools::move(), output_, CaloTruthAccumulator::OutputCollections::pCaloParticles, premixStage1_, CaloTruthAccumulator::OutputCollections::pSimClusters, SimDataFormats::CaloAnalysis::sc, CaloTruthAccumulator::calo_particles::sc_start_, CaloTruthAccumulator::calo_particles::sc_stop_, edm::swap(), and CaloTruthAccumulator::calo_particles::swap().

                                                                                     {
   edm::LogInfo(messageCategory_) << "Adding " << output_.pSimClusters->size()
                                  << " SimParticles and " << output_.pCaloParticles->size()
                                  << " CaloParticles to the event.";
 
   // We need to normalize the hits and energies into hits and fractions (since
   // we have looped over all pileup events)
   // For premixing stage1 we keep the energies, they will be normalized to fractions in stage2
 
   if(premixStage1_) {
     auto totalEnergies = std::make_unique<std::vector<std::pair<unsigned int, float> > >();
     totalEnergies->reserve(m_detIdToTotalSimEnergy.size());
     std::copy(m_detIdToTotalSimEnergy.begin(), m_detIdToTotalSimEnergy.end(), std::back_inserter(*totalEnergies));
     std::sort(totalEnergies->begin(), totalEnergies->end());
     event.put(std::move(totalEnergies), "MergedCaloTruth");
   }
   else {
     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(messageCategory_) << "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_multimap<Barcode_t, Index_t>().swap(m_simHitBarcodeToIndex);
 }

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

overrideprivate

Definition at line 442 of file CaloTruthAccumulator.cc.

References accumulate(), accumulateEvent(), PileUpEventPrincipal::bunchCrossing(), hepMCproductLabel_, 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_detIdToTotalSimEnergy.clear();
 }

Member Data Documentation

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

private

Definition at line 174 of file CaloTruthAccumulator.cc.

Referenced by CaloTruthAccumulator(), and fillSimHits().

edm::InputTag CaloTruthAccumulator::genParticleLabel_

private

Definition at line 175 of file CaloTruthAccumulator.cc.

Referenced by accumulateEvent(), and CaloTruthAccumulator().

int CaloTruthAccumulator::geometryType_

private

Definition at line 210 of file CaloTruthAccumulator.cc.

Referenced by beginLuminosityBlock(), and fillSimHits().

const HcalDDDRecConstants* CaloTruthAccumulator::hcddd_ = 0

private

Definition at line 206 of file CaloTruthAccumulator.cc.

Referenced by beginLuminosityBlock(), and fillSimHits().

edm::InputTag CaloTruthAccumulator::hepMCproductLabel_

private

Needed to add HepMC::GenVertex to SimVertex.

Definition at line 177 of file CaloTruthAccumulator.cc.

Referenced by CaloTruthAccumulator(), and initializeEvent().

const HGCalDDDConstants* CaloTruthAccumulator::hgddd_[3] = { 0 , 0 , 0 }

private

Definition at line 205 of file CaloTruthAccumulator.cc.

Referenced by beginLuminosityBlock(), and fillSimHits().

const HGCalTopology* CaloTruthAccumulator::hgtopo_[3] = { 0 , 0 , 0 }

private

Definition at line 204 of file CaloTruthAccumulator.cc.

Referenced by beginLuminosityBlock(), and fillSimHits().

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

private

Definition at line 171 of file CaloTruthAccumulator.cc.

Referenced by accumulateEvent().

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

private

Definition at line 172 of file CaloTruthAccumulator.cc.

Referenced by accumulateEvent().

calo_particles CaloTruthAccumulator::m_caloParticles

private

Definition at line 208 of file CaloTruthAccumulator.cc.

Referenced by accumulateEvent(), and finalizeEvent().

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

private

Definition at line 153 of file CaloTruthAccumulator.cc.

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

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

private

Definition at line 154 of file CaloTruthAccumulator.cc.

Referenced by accumulateEvent(), and finalizeEvent().

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

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 167 of file CaloTruthAccumulator.cc.

Referenced by initializeEvent().

const double CaloTruthAccumulator::maxPseudoRapidity_

private

Definition at line 179 of file CaloTruthAccumulator.cc.

Referenced by accumulateEvent().

const std::string CaloTruthAccumulator::messageCategory_

private

Definition at line 151 of file CaloTruthAccumulator.cc.

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

const double CaloTruthAccumulator::minEnergy_

private