CaloTruthAccumulator Class Reference

Inheritance diagram for CaloTruthAccumulator:

Classes
struct	calo_particles
struct	OutputCollections

Public Member Functions
	CaloTruthAccumulator (const edm::ParameterSet &config, edm::ProducesCollector, edm::ConsumesCollector &iC)
Public Member Functions inherited from DigiAccumulatorMixMod
virtual void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup)
virtual void	beginRun (edm::Run const &run, edm::EventSetup const &setup)
	DigiAccumulatorMixMod ()
virtual void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup)
virtual void	endRun (edm::Run const &run, edm::EventSetup const &setup)
virtual void	finalizeBunchCrossing (edm::Event &event, edm::EventSetup const &setup, int bunchCrossing)
virtual PileupMixingContent *	getEventPileupInfo ()
virtual void	initializeBunchCrossing (edm::Event const &event, edm::EventSetup const &setup, int bunchCrossing)
virtual void	StorePileupInformation (std::vector< int > &numInteractionList, std::vector< int > &bunchCrossingList, std::vector< float > &TrueInteractionList, std::vector< edm::EventID > &eventList, int bunchSpace)
virtual	~DigiAccumulatorMixMod ()

Private Member Functions
void	accumulate (const edm::Event &event, const edm::EventSetup &setup) override
void	accumulate (const PileUpEventPrincipal &event, const edm::EventSetup &setup, edm::StreamID const &) override
template<class T >
void	accumulateEvent (const T &event, const edm::EventSetup &setup, const edm::Handle< edm::HepMCProduct > &hepMCproduct)
	Both forms of accumulate() delegate to this templated method. More...
template<class T >
void	fillSimHits (std::vector< 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_
bool	doHGCAL
edm::InputTag	genParticleLabel_
int	geometryType_
const edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geomToken_
edm::ESWatcher< CaloGeometryRecord >	geomWatcher_
const HcalDDDRecConstants *	hcddd_ = nullptr
edm::InputTag	hepMCproductLabel_
	Needed to add HepMC::GenVertex to SimVertex. More...
const HGCalDDDConstants *	hgddd_ [3] = {nullptr, nullptr, nullptr}
const HGCalTopology *	hgtopo_ [3] = {nullptr, nullptr, nullptr}
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 126 of file CaloTruthAccumulator.cc.

Constructor & Destructor Documentation

CaloTruthAccumulator()

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

explicit

Definition at line 361 of file CaloTruthAccumulator.cc.

    : 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")),
      geomToken_(iC.esConsumes()),
      minEnergy_(config.getParameter<double>("MinEnergy")),
      maxPseudoRapidity_(config.getParameter<double>("MaxPseudoRapidity")),
      premixStage1_(config.getParameter<bool>("premixStage1")),
      geometryType_(-1),
      doHGCAL(config.getParameter<bool>("doHGCAL")) {
  producesCollector.produces<SimClusterCollection>("MergedCaloTruth");
  producesCollector.produces<CaloParticleCollection>("MergedCaloTruth");
  if (premixStage1_) {
    producesCollector.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);
  }
}

References collectionTags_, edm::ConsumesCollector::consumes(), genParticleLabel_, hepMCproductLabel_, premixStage1_, edm::ProducesCollector::produces(), simTrackLabel_, simVertexLabel_, and triggerMatcherToHLTDebug_cfi::tags.

Member Function Documentation

accumulate() [1/2]

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

overrideprivatevirtual

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

Implements DigiAccumulatorMixMod.

Definition at line 456 of file CaloTruthAccumulator.cc.

                                                                                       {
  edm::Handle<edm::HepMCProduct> hepmc;
  event.getByLabel(hepMCproductLabel_, hepmc);
 
  edm::LogInfo(messageCategory_) << " CaloTruthAccumulator::accumulate (signal)";
  accumulateEvent(event, setup, hepmc);
}

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

accumulate() [2/2]

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

overrideprivatevirtual

Implements DigiAccumulatorMixMod.

Definition at line 464 of file CaloTruthAccumulator.cc.

                                                           {
  if (event.bunchCrossing() >= -static_cast<int>(maximumPreviousBunchCrossing_) &&
      event.bunchCrossing() <= static_cast<int>(maximumSubsequentBunchCrossing_)) {
    // simply create empty handle as we do not have a HepMCProduct in PU anyway
    edm::Handle<edm::HepMCProduct> hepmc;
    edm::LogInfo(messageCategory_) << " CaloTruthAccumulator::accumulate (pileup) bunchCrossing="
                                   << event.bunchCrossing();
    accumulateEvent(event, setup, hepmc);
  } else {
    edm::LogInfo(messageCategory_) << "Skipping pileup event for bunch crossing " << event.bunchCrossing();
  }
}

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

accumulateEvent()

template<class T >

void 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:

1. 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.
2. 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 534 of file CaloTruthAccumulator.cc.

                                                                                           {
  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
}

References funct::abs(), gather_cfg::cout, EdgeProperty::cumulative_simHits, DEBUG, PA_ZEESkim_cff::decay, fillSimHits(), genParticleLabel_, get, hSimTracks, hSimVertices, mps_fire::i, heavyIonCSV_trainingSettings::idx, IfLogDebug, m_caloParticles, m_simHitBarcodeToIndex, maxPseudoRapidity_, messageCategory_, minEnergy_, CoreSimTrack::momentum(), SimTrack::noGenpart(), hltrates_dqm_sourceclient-live_cfg::offset, output_, put(), edm::second(), singleTopDQM_cfi::setup, EdgeProperty::simTrack, simTrackLabel_, simVertexLabel_, findQualityFiles::size, submitPVValidationJobs::t, tracks, findQualityFiles::v, AlignmentTracksFromVertexSelector_cfi::vertices, and runTauDisplay::vis.

Referenced by accumulate().

fillSimHits()

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

                                                                   {
  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);
 
      //Relabel as necessary for HGCAL
      if (doHGCAL) {
        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);
        }
      } else {
        id = simHit.id();
        //Relabel all HCAL hits
        if (isHcal) {
          HcalDetId hid = HcalHitRelabeller::relabel(simHit.id(), hcddd_);
          id = hid;
        }
      }
 
      if (id == DetId(0)) {
        continue;
      }
      if (simHit.geantTrackId() == 0) {
        continue;
      }
 
      returnValue.emplace_back(id, &simHit);
      simTrackDetIdEnergyMap[simHit.geantTrackId()][id.rawId()] += simHit.energy();
      m_detIdToTotalSimEnergy[id.rawId()] += simHit.energy();
    }
  }  // end of loop over InputTags
}

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

Referenced by accumulateEvent().

finalizeEvent()

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

overrideprivatevirtual

Implements DigiAccumulatorMixMod.

Definition at line 479 of file CaloTruthAccumulator.cc.

                                                                                    {
  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();
      sc.clearHitsEnergy();
      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);
        sc.addHitEnergy(hAndE.second);
      }
    }
  }
 
  // 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);
}

References filterCSVwithJSON::copy, HLT_FULL_cff::fraction, mps_fire::i, dqmiolumiharvest::j, m_caloParticles, m_detIdToTotalSimEnergy, m_simHitBarcodeToIndex, messageCategory_, eostools::move(), output_, CaloTruthAccumulator::OutputCollections::pCaloParticles, premixStage1_, CaloTruthAccumulator::OutputCollections::pSimClusters, CaloTruthAccumulator::calo_particles::sc_start_, CaloTruthAccumulator::calo_particles::sc_stop_, jetUpdater_cfi::sort, and CaloTruthAccumulator::calo_particles::swap().

initializeEvent()

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

overrideprivatevirtual

Implements DigiAccumulatorMixMod.

Definition at line 404 of file CaloTruthAccumulator.cc.

                                                                                            {
  output_.pSimClusters = std::make_unique<SimClusterCollection>();
  output_.pCaloParticles = std::make_unique<CaloParticleCollection>();
 
  m_detIdToTotalSimEnergy.clear();
 
  if (geomWatcher_.check(setup)) {
    auto const &geom = setup.getData(geomToken_);
    const HGCalGeometry *eegeom = nullptr, *fhgeom = nullptr, *bhgeomnew = nullptr;
    const HcalGeometry *bhgeom = nullptr;
    bhgeom = static_cast<const HcalGeometry *>(geom.getSubdetectorGeometry(DetId::Hcal, HcalEndcap));
 
    if (doHGCAL) {
      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();
    }
  }
}

References edm::ESWatcher< T >::check(), HGCalTopology::dddConstants(), HcalTopology::dddConstants(), doHGCAL, EcalMappingRecord_cfi::eegeom, DetId::Forward, ForwardEmpty, relativeConstraints::geom, geometryType_, geomToken_, geomWatcher_, DetId::Hcal, HcalEndcap, hcddd_, DetId::HGCalEE, DetId::HGCalHSc, DetId::HGCalHSi, HGCEE, HGCHEF, hgddd_, hgtopo_, mps_fire::i, m_detIdToTotalSimEnergy, output_, CaloTruthAccumulator::OutputCollections::pCaloParticles, CaloTruthAccumulator::OutputCollections::pSimClusters, singleTopDQM_cfi::setup, and HcalGeometry::topology().

Member Data Documentation

collectionTags_

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

private

Definition at line 173 of file CaloTruthAccumulator.cc.

Referenced by CaloTruthAccumulator(), and fillSimHits().

doHGCAL

bool CaloTruthAccumulator::doHGCAL

private

Definition at line 212 of file CaloTruthAccumulator.cc.

Referenced by fillSimHits(), and initializeEvent().

genParticleLabel_

edm::InputTag CaloTruthAccumulator::genParticleLabel_

private

Definition at line 174 of file CaloTruthAccumulator.cc.

Referenced by accumulateEvent(), and CaloTruthAccumulator().

geometryType_

int CaloTruthAccumulator::geometryType_

private

Definition at line 211 of file CaloTruthAccumulator.cc.

Referenced by fillSimHits(), and initializeEvent().

geomToken_

const edm::ESGetToken<CaloGeometry, CaloGeometryRecord> CaloTruthAccumulator::geomToken_

private

Definition at line 177 of file CaloTruthAccumulator.cc.

Referenced by initializeEvent().

geomWatcher_

edm::ESWatcher<CaloGeometryRecord> CaloTruthAccumulator::geomWatcher_

private

Definition at line 178 of file CaloTruthAccumulator.cc.

Referenced by initializeEvent().

hcddd_

const HcalDDDRecConstants* CaloTruthAccumulator::hcddd_ = nullptr

private

Definition at line 207 of file CaloTruthAccumulator.cc.

Referenced by fillSimHits(), and initializeEvent().

hepMCproductLabel_

edm::InputTag CaloTruthAccumulator::hepMCproductLabel_

private

Needed to add HepMC::GenVertex to SimVertex.

Definition at line 176 of file CaloTruthAccumulator.cc.

Referenced by accumulate(), and CaloTruthAccumulator().

hgddd_

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

private

Definition at line 206 of file CaloTruthAccumulator.cc.

Referenced by fillSimHits(), and initializeEvent().

hgtopo_

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

private

Definition at line 205 of file CaloTruthAccumulator.cc.

Referenced by fillSimHits(), and initializeEvent().

hSimTracks

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

private

Definition at line 170 of file CaloTruthAccumulator.cc.

Referenced by accumulateEvent().

hSimVertices

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

private

Definition at line 171 of file CaloTruthAccumulator.cc.

Referenced by accumulateEvent().

m_caloParticles

calo_particles CaloTruthAccumulator::m_caloParticles

private

Definition at line 209 of file CaloTruthAccumulator.cc.

Referenced by accumulateEvent(), and finalizeEvent().

m_detIdToTotalSimEnergy

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

private

Definition at line 152 of file CaloTruthAccumulator.cc.

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

m_simHitBarcodeToIndex

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

private

Definition at line 153 of file CaloTruthAccumulator.cc.

Referenced by accumulateEvent(), and finalizeEvent().

maximumPreviousBunchCrossing_

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

Referenced by accumulate().

maximumSubsequentBunchCrossing_

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

Referenced by accumulate().

maxPseudoRapidity_

const double CaloTruthAccumulator::maxPseudoRapidity_

private

Definition at line 180 of file CaloTruthAccumulator.cc.

Referenced by accumulateEvent().

messageCategory_

const std::string CaloTruthAccumulator::messageCategory_

private

Definition at line 150 of file CaloTruthAccumulator.cc.

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

minEnergy_

const double CaloTruthAccumulator::minEnergy_

private

Definition at line 180 of file CaloTruthAccumulator.cc.

Referenced by accumulateEvent().

output_

OutputCollections CaloTruthAccumulator::output_

private

Definition at line 208 of file CaloTruthAccumulator.cc.

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

premixStage1_

const bool CaloTruthAccumulator::premixStage1_

private

Definition at line 181 of file CaloTruthAccumulator.cc.

Referenced by CaloTruthAccumulator(), and finalizeEvent().

simTrackLabel_

const edm::InputTag CaloTruthAccumulator::simTrackLabel_

private

Definition at line 168 of file CaloTruthAccumulator.cc.

Referenced by accumulateEvent(), and CaloTruthAccumulator().

simVertexLabel_

const edm::InputTag CaloTruthAccumulator::simVertexLabel_

private

Definition at line 169 of file CaloTruthAccumulator.cc.

Referenced by accumulateEvent(), and CaloTruthAccumulator().