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

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

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_

int	geometryType_ = 0

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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 47 of file CaloParticleDebugger.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 88 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 108 of file CaloParticleDebugger.cc.

108 {}

Member Function Documentation

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

overrideprivate

Definition at line 115 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::iota;
   using std::sort;
 
   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 262 of file CaloParticleDebugger.cc.

262 {}

void CaloParticleDebugger::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 265 of file CaloParticleDebugger.cc.

265 {}

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 267 of file CaloParticleDebugger.cc.

References collectionTags_, collectionTagsToken_, HGCalTopology::dddConstants(), HcalTopology::dddConstants(), DetId::Forward, ForwardEmpty, relativeConstraints::geom, geometryType_, edm::EventSetup::get(), edm::Event::getByToken(), CaloGeometry::getSubdetectorGeometry(), DetId::Hcal, HcalEndcap, DetId::HGCalEE, DetId::HGCalHSc, DetId::HGCalHSi, 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 = nullptr, *fhgeom = nullptr, *bhgeomnew = nullptr;
   const HcalGeometry* bhgeom = nullptr;
   const HGCalDDDConstants* hgddd[3];
   const HGCalTopology* hgtopo[3];
   const HcalDDDRecConstants* hcddd = 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();
 
   // 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 (geometryType_ == 1) {
         //no test numbering in new geometry
         id = simId;
       } else if (isHcal) {
         assert(hcddd);
         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
 }