#include <QcdPhotonsDQM.h>

Inheritance diagram for QcdPhotonsDQM:

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override
	Get the analysis. More...

void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

	QcdPhotonsDQM (const edm::ParameterSet &)
	Constructor. More...

	~QcdPhotonsDQM () override
	Destructor. More...

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

virtual void	analyze (edm::Event const &, edm::EventSetup const &)

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

virtual void	dqmBeginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)

	DQMEDAnalyzer ()

virtual void	dqmEndLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

virtual void	dqmEndRun (edm::Run const &, edm::EventSetup const &)

void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) final

void	endLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup) final

void	endRun (edm::Run const &, edm::EventSetup const &) final

void	endRunProduce (edm::Run &run, edm::EventSetup const &setup) final

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::one::EDProducer< edm::EndRunProducer, edm::one::WatchRuns, edm::EndLuminosityBlockProducer, edm::one::WatchLuminosityBlocks, edm::Accumulator >
	EDProducer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) 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)

Private Attributes
MonitorElement *	h_deltaEt_photon_jet

MonitorElement *	h_deltaPhi_jet_jet2

MonitorElement *	h_deltaPhi_photon_jet

MonitorElement *	h_deltaPhi_photon_jet2

MonitorElement *	h_deltaR_jet_jet2

MonitorElement *	h_deltaR_photon_jet2

MonitorElement *	h_jet2_eta

MonitorElement *	h_jet2_pt

MonitorElement *	h_jet2_ptOverPhotonEt

MonitorElement *	h_jet_count

MonitorElement *	h_jet_eta

MonitorElement *	h_jet_pt

MonitorElement *	h_photon_count_bar

MonitorElement *	h_photon_count_end

MonitorElement *	h_photon_et

MonitorElement *	h_photon_et_beforeCuts

MonitorElement *	h_photon_et_jetco

MonitorElement *	h_photon_et_jetcs

MonitorElement *	h_photon_et_jetfo

MonitorElement *	h_photon_et_jetfs

MonitorElement *	h_photon_eta

MonitorElement *	h_triggers_passed

std::string	logTraceName

edm::InputTag	theBarrelRecHitTag_

edm::EDGetTokenT< EcalRecHitCollection >	theBarrelRecHitToken_

edm::InputTag	theEndcapRecHitTag_

edm::EDGetTokenT< EcalRecHitCollection >	theEndcapRecHitToken_

edm::InputTag	theJetCollectionLabel_

edm::EDGetTokenT< edm::View< reco::Jet > >	theJetCollectionToken_

double	theMinJetPt_

double	theMinPhotonEt_

edm::EDGetTokenT< reco::PhotonCollection >	thePhotonCollectionToken_

double	thePlotJetMaxEta_

double	thePlotPhotonMaxEt_

double	thePlotPhotonMaxEta_

std::vector< std::string >	thePlotTheseTriggersToo_

bool	theRequirePhotonFound_

std::string	theTriggerPathToPass_

edm::EDGetTokenT< reco::VertexCollection >	theVertexCollectionToken_

edm::EDGetTokenT< edm::TriggerResults >	trigTagToken_

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()

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)

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

DQM offline for QCD-Photons

Author: Michael B. Anderson, University of Wisconsin Madison

Definition at line 26 of file QcdPhotonsDQM.h.

Constructor & Destructor Documentation

QcdPhotonsDQM::QcdPhotonsDQM ( const edm::ParameterSet & parameters )

Constructor.

Definition at line 57 of file QcdPhotonsDQM.cc.

References edm::ParameterSet::getParameter(), and edm::ParameterSet::getUntrackedParameter().

                                                            {
   // Get parameters from configuration file
   theTriggerPathToPass_ = parameters.getParameter<string>("triggerPathToPass");
   thePlotTheseTriggersToo_ = parameters.getParameter<vector<string> >("plotTheseTriggersToo");
   theJetCollectionLabel_ = parameters.getParameter<InputTag>("jetCollection");
   trigTagToken_ = consumes<edm::TriggerResults>(parameters.getUntrackedParameter<edm::InputTag>("trigTag"));
   thePhotonCollectionToken_ = consumes<reco::PhotonCollection>(parameters.getParameter<InputTag>("photonCollection"));
   theJetCollectionToken_ = consumes<edm::View<reco::Jet> >(parameters.getParameter<InputTag>("jetCollection"));
   theVertexCollectionToken_ = consumes<reco::VertexCollection>(parameters.getParameter<InputTag>("vertexCollection"));
   theMinJetPt_ = parameters.getParameter<double>("minJetPt");
   theMinPhotonEt_ = parameters.getParameter<double>("minPhotonEt");
   theRequirePhotonFound_ = parameters.getParameter<bool>("requirePhotonFound");
   thePlotPhotonMaxEt_ = parameters.getParameter<double>("plotPhotonMaxEt");
   thePlotPhotonMaxEta_ = parameters.getParameter<double>("plotPhotonMaxEta");
   thePlotJetMaxEta_ = parameters.getParameter<double>("plotJetMaxEta");
   theBarrelRecHitTag_ = parameters.getParameter<InputTag>("barrelRecHitTag");
   theEndcapRecHitTag_ = parameters.getParameter<InputTag>("endcapRecHitTag");
   theBarrelRecHitToken_ = consumes<EcalRecHitCollection>(parameters.getParameter<InputTag>("barrelRecHitTag"));
   theEndcapRecHitToken_ = consumes<EcalRecHitCollection>(parameters.getParameter<InputTag>("endcapRecHitTag"));
 
   // coverity says...
   h_deltaEt_photon_jet = nullptr;
   h_deltaPhi_jet_jet2 = nullptr;
   h_deltaPhi_photon_jet = nullptr;
   h_deltaPhi_photon_jet2 = nullptr;
   h_deltaR_jet_jet2 = nullptr;
   h_deltaR_photon_jet2 = nullptr;
   h_jet2_eta = nullptr;
   h_jet2_pt = nullptr;
   h_jet2_ptOverPhotonEt = nullptr;
   h_jet_count = nullptr;
   h_jet_eta = nullptr;
   h_jet_pt = nullptr;
   h_photon_count_bar = nullptr;
   h_photon_count_end = nullptr;
   h_photon_et = nullptr;
   h_photon_et_beforeCuts = nullptr;
   h_photon_et_jetco = nullptr;
   h_photon_et_jetcs = nullptr;
   h_photon_et_jetfo = nullptr;
   h_photon_et_jetfs = nullptr;
   h_photon_eta = nullptr;
   h_triggers_passed = nullptr;
 }

QcdPhotonsDQM::~QcdPhotonsDQM ( )

override

Destructor.

Definition at line 102 of file QcdPhotonsDQM.cc.

102 {}

Member Function Documentation

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

override

Get the analysis.

Definition at line 235 of file QcdPhotonsDQM.cc.

References a, funct::abs(), edm::HLTGlobalStatus::accept(), b, SiPixelRawToDigiRegional_cfi::deltaPhi, PbPb_ZMuSkimMuonDPG_cff::deltaR, reco::LeafCandidate::eta(), edm::Event::getByToken(), mps_fire::i, edm::HandleBase::isValid(), metsig::jet, jetfilter_cfi::jetCollection, LogTrace, reco::LeafCandidate::phi(), ExoticaDQM_cfi::photonCollection, edm::Handle< T >::product(), reco::LeafCandidate::pt(), edm::TriggerNames::size(), edm::TriggerNames::triggerName(), edm::Event::triggerNames(), trigNames, and spclusmultinvestigator_cfi::vertexCollection.

                                                                          {
   LogTrace(logTraceName) << "Analysis of event # ";
 
   // Did event pass HLT paths?
   Handle<TriggerResults> HLTresults;
   iEvent.getByToken(trigTagToken_, HLTresults);
   if (!HLTresults.isValid()) {
     // LogWarning("") << ">>> TRIGGER collection does not exist !!!";
     return;
   }
   const edm::TriggerNames& trigNames = iEvent.triggerNames(*HLTresults);
 
   bool passed_HLT = false;
 
   // See if event passed trigger paths
   //  increment that bin in the trigger plot
   for (unsigned int i = 0; i < thePlotTheseTriggersToo_.size(); i++) {
     passed_HLT = false;
     for (unsigned int ti = 0; (ti < trigNames.size()) && !passed_HLT; ++ti) {
       size_t pos = trigNames.triggerName(ti).find(thePlotTheseTriggersToo_[i]);
       if (pos == 0)
         passed_HLT = HLTresults->accept(ti);
     }
     if (passed_HLT)
       h_triggers_passed->Fill(i);
   }
 
   // grab photons
   Handle<PhotonCollection> photonCollection;
   iEvent.getByToken(thePhotonCollectionToken_, photonCollection);
 
   // If photon collection is empty, exit
   if (!photonCollection.isValid())
     return;
 
   // Quit if the event did not pass the HLT path we care about
   passed_HLT = false;
   {
     // bool found=false;
     for (unsigned int ti = 0; ti < trigNames.size(); ++ti) {
       size_t pos = trigNames.triggerName(ti).find(theTriggerPathToPass_);
       if (pos == 0) {
         passed_HLT = HLTresults->accept(ti);
         // found=true;
         break;
       }
     }
 
     // Assumption: reco photons are ordered by Et
     for (PhotonCollection::const_iterator recoPhoton = photonCollection->begin(); recoPhoton != photonCollection->end();
          recoPhoton++) {
       // stop looping over photons once we get to too low Et
       if (recoPhoton->et() < theMinPhotonEt_)
         break;
 
       h_photon_et_beforeCuts->Fill(recoPhoton->et());
       break;  // leading photon only
     }
 
     if (!passed_HLT) {
       return;
     }
   }
 
 
   // std::cout << "\tpassed main trigger (" << theTriggerPathToPass_ << ")" <<
   // std::endl;
 
   // Does event have valid vertex?
   // Get the primary event vertex
   Handle<VertexCollection> vertexHandle;
   iEvent.getByToken(theVertexCollectionToken_, vertexHandle);
   VertexCollection vertexCollection = *(vertexHandle.product());
   // double vtx_ndof = -1.0;
   // double vtx_z    = 0.0;
   // bool   vtx_isFake = true;
   // if (vertexCollection.size()>0) {
   //  vtx_ndof = vertexCollection.begin()->ndof();
   //  vtx_z    = vertexCollection.begin()->z();
   //  vtx_isFake = false;
   //}
   // if (vtx_isFake || fabs(vtx_z)>15 || vtx_ndof<4) return;
 
   int nvvertex = 0;
   for (unsigned int i = 0; i < vertexCollection.size(); ++i) {
     if (vertexCollection[i].isValid())
       nvvertex++;
   }
   if (nvvertex == 0)
     return;
 
 
   // std::cout << "\tpassed vertex selection" << std::endl;
 
   // Did the event pass certain L1 Technical Trigger bits?
   // It's probably beam halo
   //  TODO: ADD code
 
   // For finding spikes
   Handle<EcalRecHitCollection> EBReducedRecHits;
   iEvent.getByToken(theBarrelRecHitToken_, EBReducedRecHits);
   Handle<EcalRecHitCollection> EEReducedRecHits;
   iEvent.getByToken(theEndcapRecHitToken_, EEReducedRecHits);
   EcalClusterLazyTools lazyTool(iEvent, iSetup, theBarrelRecHitToken_, theEndcapRecHitToken_);
 
   // Find the highest et "decent" photon
   float photon_et = -9.0;
   float photon_eta = -9.0;
   float photon_phi = -9.0;
   bool photon_passPhotonID = false;
   bool found_lead_pho = false;
   int photon_count_bar = 0;
   int photon_count_end = 0;
   // False Assumption: reco photons are ordered by Et
   // find the photon with highest et
   auto pho_maxet = std::max_element(
       photonCollection->begin(),
       photonCollection->end(),
       [](const PhotonCollection::value_type& a, const PhotonCollection::value_type& b) { return a.et() < b.et(); });
   if (pho_maxet != photonCollection->end() && pho_maxet->et() >= theMinPhotonEt_) {
     /*
     //  Ignore ECAL Spikes
     const reco::CaloClusterPtr  seed = pho_maxet->superCluster()->seed();
     DetId id = lazyTool.getMaximum(*seed).first; // Cluster shape variables
     //    float time  = -999., outOfTimeChi2 = -999., chi2 = -999.;  // UNUSED
     int   flags=-1, severity = -1;
     const EcalRecHitCollection & rechits = ( pho_maxet->isEB() ?
     *EBReducedRecHits : *EEReducedRecHits);
     EcalRecHitCollection::const_iterator it = rechits.find( id );
     if( it != rechits.end() ) {
       //      time = it->time(); // UNUSED
       //      outOfTimeChi2 = it->outOfTimeChi2(); // UNUSED
       //      chi2 = it->chi2(); // UNUSED
       flags = it->recoFlag();
 
       edm::ESHandle<EcalSeverityLevelAlgo> sevlv;
       iSetup.get<EcalSeverityLevelAlgoRcd>().get(sevlv);
       severity = sevlv->severityLevel( id, rechits);
     }
     bool isNotSpike = ((pho_maxet->isEB() && (severity!=3 && severity!=4 ) &&
     (flags != 2) ) || pho_maxet->isEE());
     if (!isNotSpike) continue;  // move on to next photon
     // END of determining ECAL Spikes
     */
 
     bool pho_current_passPhotonID = false;
     bool pho_current_isEB = pho_maxet->isEB();
     bool pho_current_isEE = pho_maxet->isEE();
 
     if (pho_current_isEB && (pho_maxet->sigmaIetaIeta() < 0.01 || pho_maxet->hadronicOverEm() < 0.05)) {
       // Photon object in barrel passes photon ID
       pho_current_passPhotonID = true;
       photon_count_bar++;
     } else if (pho_current_isEE && (pho_maxet->hadronicOverEm() < 0.05)) {
       // Photon object in endcap passes photon ID
       pho_current_passPhotonID = true;
       photon_count_end++;
     }
 
     if (!found_lead_pho) {
       found_lead_pho = true;
       photon_passPhotonID = pho_current_passPhotonID;
       photon_et = pho_maxet->et();
       photon_eta = pho_maxet->eta();
       photon_phi = pho_maxet->phi();
     }
   }
 
   // If user requires a photon to be found, but none is, return.
   //   theRequirePhotonFound should pretty much always be set to 'True'
   //    except when running on qcd monte carlo just to see the jets.
   if (theRequirePhotonFound_ && (!photon_passPhotonID || photon_et < theMinPhotonEt_))
     return;
 
   // Find the highest et jet
   Handle<View<Jet> > jetCollection;
   iEvent.getByToken(theJetCollectionToken_, jetCollection);
   if (!jetCollection.isValid())
     return;
 
   float jet_pt = -8.0;
   float jet_eta = -8.0;
   float jet_phi = -8.0;
   int jet_count = 0;
   float jet2_pt = -9.0;
   float jet2_eta = -9.0;
   float jet2_phi = -9.0;
   // Assumption: jets are ordered by Et
   for (unsigned int i_jet = 0; i_jet < jetCollection->size(); i_jet++) {
     const Jet* jet = &jetCollection->at(i_jet);
 
     float jet_current_pt = jet->pt();
 
     // don't care about jets that overlap with the lead photon
     if (deltaR(jet->eta(), jet->phi(), photon_eta, photon_phi) < 0.5)
       continue;
     // stop looping over jets once we get to too low Et
     if (jet_current_pt < theMinJetPt_)
       break;
 
     jet_count++;
     if (jet_current_pt > jet_pt) {
       jet2_pt = jet_pt;  // 2nd highest jet get's et from current highest
       jet2_eta = jet_eta;
       jet2_phi = jet_phi;
       jet_pt = jet_current_pt;  // current highest jet gets et from the new highest
       jet_eta = jet->eta();
       jet_phi = jet->phi();
     } else if (jet_current_pt > jet2_pt) {
       jet2_pt = jet_current_pt;
       jet2_eta = jet->eta();
       jet2_phi = jet->phi();
     }
   }
 
   // Fill histograms if a jet found
   // NOTE: if a photon was required to be found, but wasn't
   //        we wouldn't have made it to this point in the code
   if (jet_pt > 0.0) {
     // Photon Plots
     h_photon_et->Fill(photon_et);
     h_photon_eta->Fill(photon_eta);
     h_photon_count_bar->Fill(photon_count_bar);
     h_photon_count_end->Fill(photon_count_end);
 
     // Photon Et hists for different orientations to the jet
     if (fabs(photon_eta) < 1.45 && photon_passPhotonID) {  // Lead photon is in barrel
       if (fabs(jet_eta) < 1.45) {                          //   jet is in barrel
         if (photon_eta * jet_eta > 0) {
           h_photon_et_jetcs->Fill(photon_et);
         } else {
           h_photon_et_jetco->Fill(photon_et);
         }
       } else if (jet_eta > 1.55 && jet_eta < 2.5) {  // jet is in endcap
         if (photon_eta * jet_eta > 0) {
           h_photon_et_jetfs->Fill(photon_et);
         } else {
           h_photon_et_jetfo->Fill(photon_et);
         }
       }
     }  // END of Lead Photon is in Barrel
 
     // Jet Plots
     h_jet_pt->Fill(jet_pt);
     h_jet_eta->Fill(jet_eta);
     h_jet_count->Fill(jet_count);
     h_deltaPhi_photon_jet->Fill(abs(deltaPhi(photon_phi, jet_phi)));
     if (abs(deltaPhi(photon_phi, jet_phi)) > 2.8)
       h_deltaEt_photon_jet->Fill((photon_et - jet_pt) / photon_et);
 
     // 2nd Highest Jet Plots
     if (jet2_pt > 0.0) {
       h_jet2_pt->Fill(jet2_pt);
       h_jet2_eta->Fill(jet2_eta);
       h_jet2_ptOverPhotonEt->Fill(jet2_pt / photon_et);
       h_deltaPhi_photon_jet2->Fill(abs(deltaPhi(photon_phi, jet2_phi)));
       h_deltaPhi_jet_jet2->Fill(abs(deltaPhi(jet_phi, jet2_phi)));
       h_deltaR_jet_jet2->Fill(deltaR(jet_eta, jet_phi, jet2_eta, jet2_phi));
       h_deltaR_photon_jet2->Fill(deltaR(photon_eta, photon_phi, jet2_eta, jet2_phi));
     }
   }
   // End of Filling histograms
 }

void QcdPhotonsDQM::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	,
		edm::EventSetup const &
	)

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 104 of file QcdPhotonsDQM.cc.

References dqm::dqmstoreimpl::DQMStore::IBooker::book1D(), mps_fire::i, LogTrace, hlt_dqm_clientPB-live_cfg::me, dqm::impl::MonitorElement::setBinLabel(), dqm::dqmstoreimpl::DQMStore::IBooker::setCurrentFolder(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                 {
   logTraceName = "QcdPhotonAnalyzer";
 
   LogTrace(logTraceName) << "Parameters initialization";
 
   ibooker.setCurrentFolder("Physics/QcdPhotons");  // Use folder with name of PAG
 
   std::stringstream aStringStream;
   std::string aString;
   aStringStream << theMinJetPt_;
   aString = aStringStream.str();
 
   // Monitor of triggers passed
   int numOfTriggersToMonitor = thePlotTheseTriggersToo_.size();
   h_triggers_passed = ibooker.book1D(
       "triggers_passed", "Events passing these trigger paths", numOfTriggersToMonitor, 0, numOfTriggersToMonitor);
   for (int i = 0; i < numOfTriggersToMonitor; i++) {
     h_triggers_passed->setBinLabel(i + 1, thePlotTheseTriggersToo_[i]);
   }
 
   // Keep the number of plots and number of bins to a minimum!
   h_photon_et_beforeCuts = ibooker.book1D(
       "photon_et_beforeCuts", "#gamma with highest E_{T};E_{T}(#gamma) (GeV)", 20, 0., thePlotPhotonMaxEt_);
   h_photon_et =
       ibooker.book1D("photon_et", "#gamma with highest E_{T};E_{T}(#gamma) (GeV)", 20, 0., thePlotPhotonMaxEt_);
   h_photon_eta = ibooker.book1D(
       "photon_eta", "#gamma with highest E_{T};#eta(#gamma)", 40, -thePlotPhotonMaxEta_, thePlotPhotonMaxEta_);
   h_photon_count_bar = ibooker.book1D(
       "photon_count_bar", "Number of #gamma's passing selection (Barrel);Number of #gamma's", 8, -0.5, 7.5);
   h_photon_count_end = ibooker.book1D(
       "photon_count_end", "Number of #gamma's passing selection (Endcap);Number of #gamma's", 8, -0.5, 7.5);
   h_jet_pt =
       ibooker.book1D("jet_pt",
                      "Jet with highest p_{T} (from " + theJetCollectionLabel_.label() + ");p_{T}(1^{st} jet) (GeV)",
                      20,
                      0.,
                      thePlotPhotonMaxEt_);
   h_jet_eta = ibooker.book1D("jet_eta",
                              "Jet with highest p_{T} (from " + theJetCollectionLabel_.label() + ");#eta(1^{st} jet)",
                              20,
                              -thePlotJetMaxEta_,
                              thePlotJetMaxEta_);
   h_deltaPhi_photon_jet =
       ibooker.book1D("deltaPhi_photon_jet",
                      "#Delta#phi between Highest E_{T} #gamma and jet;#Delta#phi(#gamma,1^{st} jet)",
                      20,
                      0,
                      3.1415926);
   h_deltaPhi_jet_jet2 = ibooker.book1D("deltaPhi_jet_jet2",
                                        "#Delta#phi between Highest E_{T} jet and 2^{nd} "
                                        "jet;#Delta#phi(1^{st} jet,2^{nd} jet)",
                                        20,
                                        0,
                                        3.1415926);
   h_deltaEt_photon_jet = ibooker.book1D("deltaEt_photon_jet",
                                         "(E_{T}(#gamma)-p_{T}(jet))/E_{T}(#gamma) when #Delta#phi(#gamma,1^{st} "
                                         "jet) > 2.8;#DeltaE_{T}(#gamma,1^{st} jet)/E_{T}(#gamma)",
                                         20,
                                         -1.0,
                                         1.0);
   h_jet_count =
       ibooker.book1D("jet_count",
                      "Number of " + theJetCollectionLabel_.label() + " (p_{T} > " + aString + " GeV);Number of Jets",
                      8,
                      -0.5,
                      7.5);
   h_jet2_pt = ibooker.book1D(
       "jet2_pt",
       "Jet with 2^{nd} highest p_{T} (from " + theJetCollectionLabel_.label() + ");p_{T}(2^{nd} jet) (GeV)",
       20,
       0.,
       thePlotPhotonMaxEt_);
   h_jet2_eta =
       ibooker.book1D("jet2_eta",
                      "Jet with 2^{nd} highest p_{T} (from " + theJetCollectionLabel_.label() + ");#eta(2^{nd} jet)",
                      20,
                      -thePlotJetMaxEta_,
                      thePlotJetMaxEta_);
   h_jet2_ptOverPhotonEt = ibooker.book1D(
       "jet2_ptOverPhotonEt", "p_{T}(2^{nd} highest jet) / E_{T}(#gamma);p_{T}(2^{nd} Jet)/E_{T}(#gamma)", 20, 0.0, 4.0);
   h_deltaPhi_photon_jet2 = ibooker.book1D("deltaPhi_photon_jet2",
                                           "#Delta#phi between Highest E_{T} #gamma and 2^{nd} "
                                           "highest jet;#Delta#phi(#gamma,2^{nd} jet)",
                                           20,
                                           0,
                                           3.1415926);
   h_deltaR_jet_jet2 = ibooker.book1D(
       "deltaR_jet_jet2", "#DeltaR between Highest Jet and 2^{nd} Highest;#DeltaR(1^{st} jet,2^{nd} jet)", 30, 0, 6.0);
   h_deltaR_photon_jet2 = ibooker.book1D("deltaR_photon_jet2",
                                         "#DeltaR between Highest E_{T} #gamma and 2^{nd} "
                                         "jet;#DeltaR(#gamma, 2^{nd} jet)",
                                         30,
                                         0,
                                         6.0);
 
   // Photon Et for different jet configurations
   Float_t bins_et[] = {15, 20, 30, 50, 80};
   int num_bins_et = 4;
   h_photon_et_jetcs = ibooker.book1D("photon_et_jetcs",
                                      "#gamma with highest E_{T} (#eta(jet)<1.45, "
                                      "#eta(#gamma)#eta(jet)>0);E_{T}(#gamma) (GeV)",
                                      num_bins_et,
                                      bins_et);
   h_photon_et_jetco = ibooker.book1D("photon_et_jetco",
                                      "#gamma with highest E_{T} (#eta(jet)<1.45, "
                                      "#eta(#gamma)#eta(jet)<0);E_{T}(#gamma) (GeV)",
                                      num_bins_et,
                                      bins_et);
   h_photon_et_jetfs = ibooker.book1D("photon_et_jetfs",
                                      "#gamma with highest E_{T} (1.55<#eta(jet)<2.5, "
                                      "#eta(#gamma)#eta(jet)>0);E_{T}(#gamma) (GeV)",
                                      num_bins_et,
                                      bins_et);
   h_photon_et_jetfo = ibooker.book1D("photon_et_jetfo",
                                      "#gamma with highest E_{T} (1.55<#eta(jet)<2.5, "
                                      "#eta(#gamma)#eta(jet)<0);E_{T}(#gamma) (GeV)",
                                      num_bins_et,
                                      bins_et);
 
   auto setSumw2 = [](MonitorElement* me) {
     if (me->getTH1F()->GetSumw2N() == 0) {
       me->enableSumw2();
     }
   };
 
   setSumw2(h_photon_et_jetcs);
   setSumw2(h_photon_et_jetco);
   setSumw2(h_photon_et_jetfs);
   setSumw2(h_photon_et_jetfo);
 }

Member Data Documentation

MonitorElement* QcdPhotonsDQM::h_deltaEt_photon_jet

private

Definition at line 78 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_deltaPhi_jet_jet2

private

Definition at line 77 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_deltaPhi_photon_jet

private

Definition at line 76 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_deltaPhi_photon_jet2

private

Definition at line 82 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_deltaR_jet_jet2

private

Definition at line 83 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_deltaR_photon_jet2

private

Definition at line 84 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_jet2_eta

private

Definition at line 81 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_jet2_pt

private

Definition at line 80 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_jet2_ptOverPhotonEt

private

Definition at line 79 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_jet_count

private

Definition at line 75 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_jet_eta

private

Definition at line 74 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_jet_pt

private

Definition at line 73 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_photon_count_bar

private

Definition at line 71 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_photon_count_end

private

Definition at line 72 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_photon_et

private

Definition at line 69 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_photon_et_beforeCuts

private

Definition at line 68 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_photon_et_jetco

private

Definition at line 87 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_photon_et_jetcs

private

Definition at line 86 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_photon_et_jetfo

private

Definition at line 89 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_photon_et_jetfs

private

Definition at line 88 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_photon_eta

private

Definition at line 70 of file QcdPhotonsDQM.h.

MonitorElement* QcdPhotonsDQM::h_triggers_passed

private

Definition at line 67 of file QcdPhotonsDQM.h.

std::string QcdPhotonsDQM::logTraceName

private

Definition at line 44 of file QcdPhotonsDQM.h.

edm::InputTag QcdPhotonsDQM::theBarrelRecHitTag_

private

Definition at line 61 of file QcdPhotonsDQM.h.

edm::EDGetTokenT<EcalRecHitCollection> QcdPhotonsDQM::theBarrelRecHitToken_

private

Definition at line 63 of file QcdPhotonsDQM.h.

edm::InputTag QcdPhotonsDQM::theEndcapRecHitTag_

private

Definition at line 62 of file QcdPhotonsDQM.h.

edm::EDGetTokenT<EcalRecHitCollection> QcdPhotonsDQM::theEndcapRecHitToken_

private

Definition at line 64 of file QcdPhotonsDQM.h.

edm::InputTag QcdPhotonsDQM::theJetCollectionLabel_

private

Definition at line 49 of file QcdPhotonsDQM.h.

edm::EDGetTokenT<edm::View<reco::Jet> > QcdPhotonsDQM::theJetCollectionToken_

private

Definition at line 52 of file QcdPhotonsDQM.h.

double QcdPhotonsDQM::theMinJetPt_

private

Definition at line 54 of file QcdPhotonsDQM.h.

double QcdPhotonsDQM::theMinPhotonEt_

private

Definition at line 55 of file QcdPhotonsDQM.h.

edm::EDGetTokenT<reco::PhotonCollection> QcdPhotonsDQM::thePhotonCollectionToken_

private

Definition at line 51 of file QcdPhotonsDQM.h.

double QcdPhotonsDQM::thePlotJetMaxEta_

private

Definition at line 59 of file QcdPhotonsDQM.h.

double QcdPhotonsDQM::thePlotPhotonMaxEt_

private

Definition at line 57 of file QcdPhotonsDQM.h.

double QcdPhotonsDQM::thePlotPhotonMaxEta_

private

Definition at line 58 of file QcdPhotonsDQM.h.

std::vector<std::string> QcdPhotonsDQM::thePlotTheseTriggersToo_

private

Definition at line 48 of file QcdPhotonsDQM.h.

bool QcdPhotonsDQM::theRequirePhotonFound_

private

Definition at line 56 of file QcdPhotonsDQM.h.

std::string QcdPhotonsDQM::theTriggerPathToPass_

private

Definition at line 47 of file QcdPhotonsDQM.h.

edm::EDGetTokenT<reco::VertexCollection> QcdPhotonsDQM::theVertexCollectionToken_

private

Definition at line 53 of file QcdPhotonsDQM.h.

edm::EDGetTokenT<edm::TriggerResults> QcdPhotonsDQM::trigTagToken_

private

Definition at line 50 of file QcdPhotonsDQM.h.

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation