Inheritance diagram for CaloParticleValidation:

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

	~CaloParticleValidation () override

Public Member Functions inherited from edm::global::EDAnalyzer< edm::RunCache< Histograms_CaloParticleValidation >, Args... >
	EDAnalyzer ()=default

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsStreamLuminosityBlocks () const final

bool	wantsStreamRuns () const final

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () 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::global::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	bookHistograms (DQMStore::ConcurrentBooker &, edm::Run const &, edm::EventSetup const &, Histograms_CaloParticleValidation &) const override

void	dqmAnalyze (edm::Event const &, edm::EventSetup const &, Histograms_CaloParticleValidation const &) const override

Private Attributes
edm::EDGetTokenT< std::vector< CaloParticle > >	caloParticles_

std::string	folder_

std::vector< int >	particles_to_monitor_

edm::EDGetTokenT< HGCRecHitCollection >	recHitsBH_

edm::EDGetTokenT< HGCRecHitCollection >	recHitsEE_

edm::EDGetTokenT< HGCRecHitCollection >	recHitsFH_

edm::EDGetTokenT< reco::PFCandidateCollection >	simPFCandidates_

edm::EDGetTokenT< std::vector< reco::SuperCluster > >	simPFClusters_

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

Additional Inherited Members
Public Types inherited from edm::global::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 56 of file CaloParticleValidation.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 98 of file CaloParticleValidation.cc.

   : folder_(iConfig.getParameter<std::string>("folder")),
   particles_to_monitor_(iConfig.getParameter<std::vector<int> >("particles_to_monitor")),
   simVertices_(consumes<std::vector<SimVertex>>(iConfig.getParameter<edm::InputTag>("simVertices"))),
   caloParticles_(consumes<std::vector<CaloParticle> >(iConfig.getParameter<edm::InputTag>("caloParticles"))),
   simPFClusters_(consumes<std::vector<reco::SuperCluster>>(iConfig.getParameter<edm::InputTag>("simPFClusters"))),
   simPFCandidates_(consumes<reco::PFCandidateCollection>(iConfig.getParameter<edm::InputTag>("simPFCandidates"))),
   recHitsEE_(consumes<HGCRecHitCollection>(iConfig.getParameter<edm::InputTag>("recHitsEE"))),
   recHitsFH_(consumes<HGCRecHitCollection>(iConfig.getParameter<edm::InputTag>("recHitsFH"))),
   recHitsBH_(consumes<HGCRecHitCollection>(iConfig.getParameter<edm::InputTag>("recHitsBH")))
 {
    //now do what ever initialization is needed
 }

CaloParticleValidation::~CaloParticleValidation ( )

override

Definition at line 113 of file CaloParticleValidation.cc.

 {
    // do anything here that needs to be done at desctruction time
    // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

void CaloParticleValidation::bookHistograms	(	DQMStore::ConcurrentBooker &	ibook,
		edm::Run const &	run,
		edm::EventSetup const &	iSetup,
		Histograms_CaloParticleValidation &	histos
	)		const

overrideprivatevirtual

Implements DQMGlobalEDAnalyzer< Histograms_CaloParticleValidation >.

Definition at line 230 of file CaloParticleValidation.cc.

References DQMStore::ConcurrentBooker::book1D(), DQMStore::ConcurrentBooker::book2D(), reco::PFCandidate::egamma_HF, folder_, reco::PFCandidate::h, trackerHits::histo, PFRecoTauDiscriminationByIsolation_cfi::offset, particles_to_monitor_, and DQMStore::IBooker::setCurrentFolder().

 {
   for (auto const particle : particles_to_monitor_) {
     ibook.setCurrentFolder(folder_ + "CaloParticles/" + std::to_string(particle));
     auto & histo = histos[particle];
     histo.eta_ = ibook.book1D("Eta", "Eta", 80, -4., 4.);
     histo.energy_ = ibook.book1D("Energy", "Energy", 250, 0., 500.);
     histo.pt_ = ibook.book1D("Pt", "Pt", 100, 0., 100.);
     histo.nSimClusters_ = ibook.book1D("NSimClusters", "NSimClusters", 100, 0., 100.);
     histo.nHitInSimClusters_ = ibook.book1D("NHitInSimClusters", "NHitInSimClusters", 100, 0., 100.);
     histo.selfEnergy_ = ibook.book1D("SelfEnergy", "SelfEnergy", 250, 0., 500.);
     histo.energyDifference_ = ibook.book1D("EnergyDifference", "(Energy-SelfEnergy)/Energy", 300, -5., 1.);
     histo.eta_Zorigin_map_ = ibook.book2D("Eta vs Zorigin", "Eta vs Zorigin", 80, -4., 4., 1100, -550., 550.);
   }
   int offset = 100000;
   ibook.setCurrentFolder(folder_ + "PFCandidates");
   histos[offset].pfcandidateType_ = ibook.book1D("PFCandidateType", "PFCandidateType", 10, 0, 10);
   histos[offset].pfcandidate_vect_sum_pt_ = ibook.book1D("PFCandidatePtVectSum", "PFCandidatePtVectSum", 200, 0., 200.);
   for (size_t type = reco::PFCandidate::h; type <= reco::PFCandidate::egamma_HF; type++) {
     ibook.setCurrentFolder(folder_ + "PFCandidates/" + std::to_string(type));
     auto & histo = histos[offset + type];
     histo.pfcandidateEnergy_ = ibook.book1D("PFCandidateEnergy", "PFCandidateEnergy", 250, 0., 250.);
     histo.pfcandidatePt_ = ibook.book1D("PFCandidatePt", "PFCandidatePt", 250, 0., 250.);
     histo.pfcandidateEta_ = ibook.book1D("PFCandidateEta", "PFCandidateEta", 100, -5., 5.);
     histo.pfcandidatePhi_ = ibook.book1D("PFCandidatePhi", "PFCandidatePhi", 100, -4., 4.);
     histo.pfcandidateElementsInBlocks_ = ibook.book1D("PFCandidateElements", "PFCandidateElements", 20, 0., 20.);
   }
   // Folder '0' is meant to be cumulative, with no connection to pdgId
   ibook.setCurrentFolder(folder_ + std::to_string(0));
   histos[0].simPFSuperClusterSize_ = ibook.book1D("SimPFSuperClusterSize", "SimPFSuperClusterSize", 40, 0., 40.);
   histos[0].simPFSuperClusterEnergy_ = ibook.book1D("SimPFSuperClusterEnergy", "SimPFSuperClusterEnergy", 250, 0., 500.);
 }

void CaloParticleValidation::dqmAnalyze	(	edm::Event const &	iEvent,
		edm::EventSetup const &	iSetup,
		Histograms_CaloParticleValidation const &	histos
	)		const

overrideprivate

Definition at line 127 of file CaloParticleValidation.cc.

References caloTruthProducer_cfi::caloParticles, caloParticles_, edm::Event::getByToken(), trackerHits::histo, SimCluster::hits_and_fractions(), mps_fire::i, LogDebug, PFRecoTauDiscriminationByIsolation_cfi::offset, or, position, recHitsBH_, recHitsEE_, recHitsFH_, SimDataFormats::CaloAnalysis::sc, trackerHits::simHits, simPFCandidates_, simPFClusters_, HGCalValidator_cfi::simVertices, simVertices_, and mathSSE::sqrt().

 {
   using namespace edm;
 
   Handle<HGCRecHitCollection> recHitHandleEE;
   Handle<HGCRecHitCollection> recHitHandleFH;
   Handle<HGCRecHitCollection> recHitHandleBH;
   // make a map detid-rechit
 
   iEvent.getByToken(recHitsEE_, recHitHandleEE);
   iEvent.getByToken(recHitsFH_, recHitHandleFH);
   iEvent.getByToken(recHitsBH_, recHitHandleBH);
   const auto& rechitsEE = *recHitHandleEE;
   const auto& rechitsFH = *recHitHandleFH;
   const auto& rechitsBH = *recHitHandleBH;
   std::map<DetId, const HGCRecHit*> hitmap;
   for (unsigned int i = 0; i < rechitsEE.size(); ++i) {
     hitmap[rechitsEE[i].detid()] = &rechitsEE[i];
   }
   for (unsigned int i = 0; i < rechitsFH.size(); ++i) {
     hitmap[rechitsFH[i].detid()] = &rechitsFH[i];
   }
   for (unsigned int i = 0; i < rechitsBH.size(); ++i) {
     hitmap[rechitsBH[i].detid()] = &rechitsBH[i];
   }
 
   Handle<std::vector<SimVertex>> simVerticesHandle;
   iEvent.getByToken(simVertices_, simVerticesHandle);
   std::vector<SimVertex> const & simVertices = *simVerticesHandle;
 
   Handle<std::vector<CaloParticle> > caloParticleHandle;
   iEvent.getByToken(caloParticles_, caloParticleHandle);
   std::vector<CaloParticle> const & caloParticles = *caloParticleHandle;
 
   Handle<std::vector<reco::SuperCluster>> simPFClustersHandle;
   iEvent.getByToken(simPFClusters_, simPFClustersHandle);
   std::vector<reco::SuperCluster> const & simPFClusters = *simPFClustersHandle;
 
   Handle<reco::PFCandidateCollection> simPFCandidatesHandle;
   iEvent.getByToken(simPFCandidates_, simPFCandidatesHandle);
   reco::PFCandidateCollection const & simPFCandidates = *simPFCandidatesHandle;
 
   for (auto const caloParticle : caloParticles) {
     if (caloParticle.g4Tracks()[0].eventId().event() != 0 or caloParticle.g4Tracks()[0].eventId().bunchCrossing() != 0) {
       LogDebug("CaloParticleValidation") << "Excluding CaloParticles from event: "
         << caloParticle.g4Tracks()[0].eventId().event()
         << " with BX: " << caloParticle.g4Tracks()[0].eventId().bunchCrossing() << std::endl;
       continue;
     }
     int id = caloParticle.pdgId();
     if (histos.count(id)) {
       auto & histo = histos.at(id);
       histo.eta_.fill(caloParticle.eta());
       histo.pt_.fill(caloParticle.pt());
       histo.energy_.fill(caloParticle.energy());
       histo.nSimClusters_.fill(caloParticle.simClusters().size());
       // Find the corresponding vertex.
       histo.eta_Zorigin_map_.fill(
           simVertices.at(caloParticle.g4Tracks()[0].vertIndex()).position().z(), caloParticle.eta());
       int simHits = 0;
       float energy = 0.;
       for (auto const sc : caloParticle.simClusters()) {
         simHits += sc->hits_and_fractions().size();
         for (auto const h_and_f : sc->hits_and_fractions()) {
           if (hitmap.count(h_and_f.first))
             energy += hitmap[h_and_f.first]->energy() * h_and_f.second;
         }
       }
       histo.nHitInSimClusters_.fill((float)simHits);
       histo.selfEnergy_.fill(energy);
       histo.energyDifference_.fill(1.- energy/caloParticle.energy());
     }
   }
 
   // simPFSuperClusters
   for (auto const sc : simPFClusters) {
     histos.at(0).simPFSuperClusterSize_.fill((float)sc.clustersSize());
     histos.at(0).simPFSuperClusterEnergy_.fill(sc.rawEnergy());
   }
 
   // simPFCandidates
   int offset = 100000;
   double ptx_tot = 0.;
   double pty_tot = 0.;
   for (auto const pfc : simPFCandidates) {
     size_t type = offset + pfc.particleId();
     ptx_tot += pfc.px();
     pty_tot += pfc.py();
     histos.at(offset).pfcandidateType_.fill(type - offset);
     auto & histo = histos.at(type);
     histo.pfcandidateEnergy_.fill(pfc.energy());
     histo.pfcandidatePt_.fill(pfc.pt());
     histo.pfcandidateEta_.fill(pfc.eta());
     histo.pfcandidatePhi_.fill(pfc.phi());
     histo.pfcandidateElementsInBlocks_.fill(pfc.elementsInBlocks().size());
   }
   auto & histo = histos.at(offset);
   histo.pfcandidate_vect_sum_pt_.fill(std::sqrt(ptx_tot*ptx_tot+pty_tot*pty_tot));
 }

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

static

Definition at line 268 of file CaloParticleValidation.cc.

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

                                                                                    {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.add<std::string>("folder", "HGCAL/"); // Please keep the trailing '/'
   desc.add<std::vector<int> > ("particles_to_monitor", {11, -11, 13, -13, 22, 111, 211, -211, 321, -321});
   desc.add<edm::InputTag>("simVertices", edm::InputTag("g4SimHits"));
   desc.add<edm::InputTag>("caloParticles", edm::InputTag("mix", "MergedCaloTruth"));
   desc.add<edm::InputTag>("simPFClusters", edm::InputTag("simPFProducer", "perfect"));
   desc.add<edm::InputTag>("simPFCandidates", edm::InputTag("simPFProducer"));
   desc.add<edm::InputTag>("recHitsEE", edm::InputTag("HGCalRecHit","HGCEERecHits"));
   desc.add<edm::InputTag>("recHitsFH", edm::InputTag("HGCalRecHit","HGCHEFRecHits"));
   desc.add<edm::InputTag>("recHitsBH", edm::InputTag("HGCalRecHit","HGCHEBRecHits"));
   descriptions.add("caloparticlevalidationDefault", desc);
 }

Member Data Documentation

edm::EDGetTokenT<std::vector<CaloParticle> > CaloParticleValidation::caloParticles_

private

Definition at line 79 of file CaloParticleValidation.cc.

Referenced by dqmAnalyze().

std::string CaloParticleValidation::folder_

private

Definition at line 75 of file CaloParticleValidation.cc.

Referenced by bookHistograms().

std::vector<int> CaloParticleValidation::particles_to_monitor_

private

Definition at line 76 of file CaloParticleValidation.cc.

Referenced by bookHistograms().

edm::EDGetTokenT<HGCRecHitCollection> CaloParticleValidation::recHitsBH_

private

Definition at line 84 of file CaloParticleValidation.cc.

Referenced by dqmAnalyze().

edm::EDGetTokenT<HGCRecHitCollection> CaloParticleValidation::recHitsEE_

private

Definition at line 82 of file CaloParticleValidation.cc.

Referenced by dqmAnalyze().

edm::EDGetTokenT<HGCRecHitCollection> CaloParticleValidation::recHitsFH_

private

Definition at line 83 of file CaloParticleValidation.cc.

Referenced by dqmAnalyze().

edm::EDGetTokenT<reco::PFCandidateCollection> CaloParticleValidation::simPFCandidates_

private

Definition at line 81 of file CaloParticleValidation.cc.

Referenced by dqmAnalyze().

edm::EDGetTokenT<std::vector<reco::SuperCluster> > CaloParticleValidation::simPFClusters_

private

Definition at line 80 of file CaloParticleValidation.cc.

Referenced by dqmAnalyze().

edm::EDGetTokenT<std::vector<SimVertex> > CaloParticleValidation::simVertices_

private

Definition at line 78 of file CaloParticleValidation.cc.

Referenced by dqmAnalyze().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation