CaloTruthAccumulator Class Reference

#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 39 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 188 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 413 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 350 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 77 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 406 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 287 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 269 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 419 of file CaloTruthAccumulator.cc.

References collectionTags_, DEFINE_DIGI_ACCUMULATOR, HcalDDDRecConstants::HcalID::depth, HcalDDDRecConstants::HcalID::eta, HcalDDDRecConstants::getHCID(), HcalEndcap, hcddd_, hgddd_, hgtopo_, hcalTTPDigis_cfi::id, m_detIdToTotalSimEnergy, HcalDDDRecConstants::HcalID::phi, Validation_hcalonly_cfi::sign, rpcPointValidation_cfi::simHit, HGCalDDDConstants::simToReco(), HcalTestNumbering::unpackHcalIndex(), HGCalTestNumbering::unpackHexagonIndex(), and z.

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 ) {
    int subdet, z, depth0, eta0, phi0, lay;
    HcalTestNumbering::unpackHcalIndex(simId, subdet, z, depth0, eta0, phi0, lay);
    int sign = (z==0) ? (-1):(1);
    HcalDDDRecConstants::HcalID tempid = hcddd_->getHCID(subdet, sign*eta0, phi0, lay, depth0);
    if (subdet==int(HcalEndcap)) {
      id = HcalDetId(HcalEndcap,sign*tempid.eta,tempid.phi,tempid.depth);    
    }
      } 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 137 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 fraction = hAndE.second/m_detIdToTotalSimEnergy[hAndE.first];
      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 99 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().

{ m_simTracksConsideredForSimClusters.insert( barcode ); }

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