Inheritance diagram for CaloParticleDebugger:

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

	~CaloParticleDebugger () override

Public Member Functions inherited from edm::one::EDAnalyzer<>
	EDAnalyzer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override

void	endJob () override

void	fillSimHits (std::map< int, float > &, const edm::Event &, const edm::EventSetup &)

Private Attributes
edm::InputTag	caloParticles_

edm::EDGetTokenT< std::vector< CaloParticle > >	caloParticlesToken_

std::vector< edm::InputTag >	collectionTags_

std::vector< edm::EDGetTokenT< std::vector< PCaloHit > > >	collectionTagsToken_

edm::InputTag	genParticles_

edm::EDGetTokenT< std::vector< reco::GenParticle > >	genParticlesToken_

edm::InputTag	simClusters_

edm::EDGetTokenT< std::vector< SimCluster > >	simClustersToken_

edm::InputTag	simTracks_

edm::EDGetTokenT< std::vector< SimTrack > >	simTracksToken_

edm::InputTag	simVertices_

edm::EDGetTokenT< std::vector< SimVertex > >	simVerticesToken_

edm::InputTag	trackingParticles_

edm::EDGetTokenT< std::vector< TrackingParticle > >	trackingParticlesToken_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 48 of file CaloParticleDebugger.cc.

Constructor & Destructor Documentation

CaloParticleDebugger::CaloParticleDebugger ( const edm::ParameterSet & iConfig )

explicit

Definition at line 90 of file CaloParticleDebugger.cc.

References caloParticles_, caloParticlesToken_, collectionTags_, collectionTagsToken_, edm::ConsumesCollector::consumes(), edm::EDConsumerBase::consumesCollector(), genParticles_, genParticlesToken_, simClusters_, simClustersToken_, simTracks_, simTracksToken_, simVertices_, simVerticesToken_, trackingParticles_, and trackingParticlesToken_.

   : simTracks_(iConfig.getParameter<edm::InputTag>("simTracks")),
   genParticles_(iConfig.getParameter<edm::InputTag>("genParticles")),
   simVertices_(iConfig.getParameter<edm::InputTag>("simVertices")),
   trackingParticles_(iConfig.getParameter<edm::InputTag>("trackingParticles")),
   caloParticles_(iConfig.getParameter<edm::InputTag>("caloParticles")),
   simClusters_(iConfig.getParameter<edm::InputTag>("simClusters")),
   collectionTags_(iConfig.getParameter<std::vector<edm::InputTag> >("collectionTags")) {
   edm::ConsumesCollector&& iC = consumesCollector();
   simTracksToken_ = iC.consumes<std::vector<SimTrack> >(simTracks_);
   genParticlesToken_ = iC.consumes<std::vector<reco::GenParticle> > (genParticles_);
   simVerticesToken_ = iC.consumes<std::vector<SimVertex> >(simVertices_);
   trackingParticlesToken_ = iC.consumes<std::vector<TrackingParticle> >(trackingParticles_);
   caloParticlesToken_ = iC.consumes<std::vector<CaloParticle> >(caloParticles_);
   simClustersToken_ = iC.consumes<std::vector<SimCluster> >(simClusters_);
   for (auto const & collectionTag : collectionTags_) {
     collectionTagsToken_.push_back(iC.consumes<std::vector<PCaloHit> >(collectionTag));
   }
 }

CaloParticleDebugger::~CaloParticleDebugger ( )

override

Definition at line 110 of file CaloParticleDebugger.cc.

110 {}

Member Function Documentation

void CaloParticleDebugger::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 119 of file CaloParticleDebugger.cc.

References funct::abs(), begin, caloParticlesToken_, GetRecoTauVFromDQM_MC_cff::cl, gather_cfg::cout, SimDataFormats::CaloAnalysis::cp, end, CaloParticle::energy(), fillSimHits(), CaloParticle::g4Tracks(), GenHFHadronMatcher_cfi::genParticles, runTauDisplay::genParticlesH, genParticlesToken_, edm::Event::getByToken(), runTauDisplay::gp, SimCluster::hits_and_fractions(), mps_fire::i, training_settings::idx, CaloParticle::momentum(), CaloParticle::pdgId(), edm::Handle< T >::product(), SimDataFormats::CaloAnalysis::sc, CaloParticle::simClusters(), simClustersToken_, simTracksToken_, simVerticesToken_, edm::RefVector< C, T, F >::size(), lumiQTWidget::t, trackingParticlesToken_, l1t::tracks, findQualityFiles::v, and electrons_cff::vertices.

                                                                                  {
   using namespace edm;
   using std::begin;
   using std::end;
   using std::sort;
   using std::iota;
 
   edm::Handle<std::vector<SimTrack> > simTracksH;
   edm::Handle<std::vector<reco::GenParticle> > genParticlesH;
   edm::Handle<std::vector<SimVertex> > simVerticesH;
   edm::Handle<std::vector<TrackingParticle> > trackingParticlesH;
   edm::Handle<std::vector<CaloParticle> > caloParticlesH;
   edm::Handle<std::vector<SimCluster> > simClustersH;
 
   iEvent.getByToken(simTracksToken_, simTracksH);
   auto const & tracks = *simTracksH.product();
   std::vector<int> sorted_tracks_idx(tracks.size());
   iota(begin(sorted_tracks_idx), end(sorted_tracks_idx), 0);
   sort(begin(sorted_tracks_idx),
        end(sorted_tracks_idx),
        [&tracks] (int i, int j) {
         return tracks[i].momentum().eta() < tracks[j].momentum().eta();
         });
 
   iEvent.getByToken(genParticlesToken_, genParticlesH);
   auto const & genParticles = *genParticlesH.product();
   std::vector<int> sorted_genParticles_idx(genParticles.size());
   iota(begin(sorted_genParticles_idx), end(sorted_genParticles_idx), 0);
   sort(begin(sorted_genParticles_idx),
        end(sorted_genParticles_idx), [&genParticles](int i, int j) {
        return genParticles[i].momentum().eta() < genParticles[j].momentum().eta();});
 
   iEvent.getByToken(simVerticesToken_, simVerticesH);
   auto const & vertices = *simVerticesH.product();
   std::vector<int> sorted_vertices_idx(vertices.size());
   iota(begin(sorted_vertices_idx), end(sorted_vertices_idx), 0);
   sort(begin(sorted_vertices_idx),
        end(sorted_vertices_idx), [&vertices](int i, int j){
         return vertices[i].vertexId() < vertices[j].vertexId();
       });
 
   iEvent.getByToken(trackingParticlesToken_, trackingParticlesH);
   auto const & trackingpart = *trackingParticlesH.product();
   std::vector<int> sorted_tp_idx(trackingpart.size());
   iota(begin(sorted_tp_idx), end(sorted_tp_idx), 0);
   sort(begin(sorted_tp_idx),
        end(sorted_tp_idx), [&trackingpart] (int i, int j){
         return trackingpart[i].eta() < trackingpart[j].eta();
        });
 
   iEvent.getByToken(caloParticlesToken_, caloParticlesH);
   auto const & calopart = *caloParticlesH.product();
   std::vector<int> sorted_cp_idx(calopart.size());
   iota(begin(sorted_cp_idx),
        end(sorted_cp_idx), 0);
   sort(begin(sorted_cp_idx),
        end(sorted_cp_idx), [&calopart](int i, int j){
        return calopart[i].eta() < calopart[j].eta();});
 
   iEvent.getByToken(simClustersToken_, simClustersH);
   auto const & simclusters = *simClustersH.product();
   std::vector<int> sorted_simcl_idx(simclusters.size());
   iota(begin(sorted_simcl_idx),
        end(sorted_simcl_idx), 0);
   sort(begin(sorted_simcl_idx),
        end(sorted_simcl_idx), [&simclusters](int i, int j){
        return simclusters[i].eta() < simclusters[j].eta();});
 
   // Let's first fill in hits information
   std::map<int, float> detIdToTotalSimEnergy;
   fillSimHits(detIdToTotalSimEnergy, iEvent, iSetup);
 
   int idx = 0;
 
   std::map<int, int> trackid_to_track_index;
   std::cout << "Printing SimTracks information" << std::endl;
   std::cout << "IDX\tTrackId\tPDGID\tMOMENTUM(x,y,z,E)\tVertexIdx\tGenPartIdx" << std::endl;
   for (auto i : sorted_tracks_idx) {
     auto const & t = tracks[i];
     std::cout << idx << "\t" << t.trackId() << "\t" << t << std::endl;
     trackid_to_track_index[t.trackId()] = idx;
     idx++;
   }
 
   std::cout << "Printing GenParticles information" << std::endl;
   std::cout << "IDX\tPDGID\tMOMENTUM(x,y,z)\tVertex(x,y,z)" << std::endl;
   for (auto i : sorted_genParticles_idx) {
     auto const & gp = genParticles[i];
     std::cout << i
       << "\t" << gp.pdgId()
       << "\t" << gp.momentum()
       << "\t" << gp.vertex() << std::endl;
   }
 
   std::cout << "Printing SimVertex information" << std::endl;
   std::cout << "IDX\tPOSITION(x,y,z)\tPARENT_INDEX\tVERTEX_ID" << std::endl;
   for (auto i : sorted_vertices_idx) {
     auto const & v = vertices[i];
       std::cout << i << "\t" << v << std::endl;
   }
   std::cout << "Printing TrackingParticles information" << std::endl;
   for (auto i : sorted_tp_idx) {
     auto const & tp = trackingpart[i];
     std::cout << i << "\t" << tp << std::endl;
   }
 
   std::cout << "Printing CaloParticles information" << std::endl;
   idx = 0;
   for (auto i : sorted_cp_idx) {
     auto const & cp = calopart[i];
     std::cout << "\n\n" << idx++ << " |Eta|: " << std::abs(cp.momentum().eta())
               << "\tType: " << cp.pdgId()
               << "\tEnergy: " << cp.energy()
               << "\tIdx: " << cp.g4Tracks()[0].trackId() << std::endl; // << cp << std::endl;
     double total_sim_energy = 0.;
     double total_cp_energy = 0.;
     std::cout << "--> Overall simclusters's size: " << cp.simClusters().size() << std::endl;
     // All the next mess just to print the simClusters ordered
     auto const & simcs = cp.simClusters();
     std::vector<int> sorted_sc_idx(simcs.size());
     iota(begin(sorted_sc_idx), end(sorted_sc_idx), 0);
     sort(begin(sorted_sc_idx),
         end(sorted_sc_idx),
         [&simcs] (int i, int j) {
         return simcs[i]->momentum().eta() < simcs[j]->momentum().eta();
         });
     for (auto i : sorted_sc_idx) {
       std::cout <<  *(simcs[i]);
     }
 
     for (auto const & sc : cp.simClusters()) {
       for (auto const & cl : sc->hits_and_fractions()) {
         total_sim_energy += detIdToTotalSimEnergy[cl.first]*cl.second;
         total_cp_energy += cp.energy()*cl.second;
       }
     }
     std::cout << "--> Overall SC energy (sum using sim energies): " << total_sim_energy << std::endl;
     std::cout << "--> Overall SC energy (sum using CaloP energies): " << total_cp_energy << std::endl;
   }
 
   idx = 0;
   std::cout << "Printing SimClusters information" << std::endl;
   for (auto i : sorted_simcl_idx) {
     auto const & simcl = simclusters[i];
     std::cout << "\n\n" << idx++ << " |Eta|: " << std::abs(simcl.momentum().eta())
               << "\tType: " << simcl.pdgId()
               << "\tEnergy: " << simcl.energy()
               << "\tKey: " << i << std::endl; // << simcl << std::endl;
     double total_sim_energy = 0.;
     std::cout << "--> Overall simclusters's size: " << simcl.numberOfRecHits() << std::endl;
     for (auto const & cl : simcl.hits_and_fractions()) {
       total_sim_energy += detIdToTotalSimEnergy[cl.first]*cl.second;
     }
     std::cout << simcl << std::endl;
     std::cout << "--> Overall SimCluster energy (sum using sim energies): " << total_sim_energy << std::endl;
   }
 }

void CaloParticleDebugger::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 280 of file CaloParticleDebugger.cc.

280 {}

void CaloParticleDebugger::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 284 of file CaloParticleDebugger.cc.

284 {}

void CaloParticleDebugger::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 345 of file CaloParticleDebugger.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and DEFINE_FWK_MODULE.

                                                                                  {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("simTracks", edm::InputTag("g4SimHits"));
   desc.add<edm::InputTag>("genParticles", edm::InputTag("genParticles"));
   desc.add<edm::InputTag>("simVertices", edm::InputTag("g4SimHits"));
   desc.add<edm::InputTag>("trackingParticles", edm::InputTag("mix", "MergedTrackTruth"));
   desc.add<edm::InputTag>("caloParticles", edm::InputTag("mix", "MergedCaloTruth"));
   desc.add<edm::InputTag>("simClusters", edm::InputTag("mix", "MergedCaloTruth"));
   desc.add<std::vector<edm::InputTag> >("collectionTags",
       { edm::InputTag("g4SimHits", "HGCHitsEE"),
         edm::InputTag("g4SimHits", "HGCHitsHEfront"),
         edm::InputTag("g4SimHits", "HcalHits")});
   descriptions.add("caloParticleDebugger", desc);
 }

void CaloParticleDebugger::fillSimHits	(	std::map< int, float > &	detIdToTotalSimEnergy,
		const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

private

Definition at line 286 of file CaloParticleDebugger.cc.

References collectionTags_, collectionTagsToken_, HGCalTopology::dddConstants(), HcalTopology::dddConstants(), DetId::Forward, relativeConstraints::geom, edm::EventSetup::get(), edm::Event::getByToken(), CaloGeometry::getSubdetectorGeometry(), DetId::Hcal, HcalEndcap, HGCEE, HGCHEF, mps_fire::i, triggerObjects_cff::id, HcalHitRelabeller::relabel(), rpcPointValidation_cfi::simHit, HGCalDDDConstants::simToReco(), HcalDetId::subdet(), HGCalGeometry::topology(), HcalGeometry::topology(), and HGCalTestNumbering::unpackHexagonIndex().

Referenced by analyze().

                                                           {
   // Taken needed quantities from the EventSetup
   edm::ESHandle<CaloGeometry> geom;
   iSetup.get<CaloGeometryRecord>().get(geom);
   const HGCalGeometry *eegeom, *fhgeom;
   const HcalGeometry *bhgeom;
   const HGCalDDDConstants* hgddd[2];
   const HGCalTopology*     hgtopo[2];
   const HcalDDDRecConstants* hcddd;
 
   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());
 
   for (unsigned i = 0; i < 2; ++i) {
     hgddd[i] = &(hgtopo[i]->dddConstants());
   }
 
   hcddd = bhgeom->topology().dddConstants();
 
   // loop over the collections
   int token = 0;
   for (auto const& collectionTag : collectionTags_) {
     edm::Handle< std::vector<PCaloHit> > hSimHits;
     const bool isHcal = ( collectionTag.instance().find("HcalHits") != std::string::npos );
     iEvent.getByToken(collectionTagsToken_[token++], hSimHits);
     for (auto const& simHit : *hSimHits) {
       DetId id(0);
       const uint32_t simId = simHit.id();
       if (isHcal) {
         HcalDetId hid = HcalHitRelabeller::relabel(simId, hcddd);
         if (hid.subdet() == HcalEndcap) id = hid;
       } else {
         int subdet, layer, cell, sec, subsec, zp;
         HGCalTestNumbering::unpackHexagonIndex(simId, subdet, zp, layer, sec, subsec, cell);
         const HGCalDDDConstants* ddd = hgddd[subdet-3];
         std::pair<int, int> recoLayerCell = ddd->simToReco(cell, layer, sec,
             hgtopo[subdet-3]->detectorType());
         cell  = recoLayerCell.first;
         layer = recoLayerCell.second;
         // skip simhits with bad barcodes or non-existant layers
         if (layer == -1 || simHit.geantTrackId() == 0) continue;
         id = HGCalDetId((ForwardSubdetector)subdet, zp, layer, subsec, sec, cell);
       }
 
       if (DetId(0) == id) continue;
 
       detIdToTotalSimEnergy[id.rawId()] += simHit.energy();
     }
   } // end of loop over InputTags
 }