QcdPhotonsDQM Class Reference

#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
void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final
void	beginStream (edm::StreamID id) final
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDAnalyzer ()
void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	endRun (edm::Run const &run, edm::EventSetup const &setup) final
virtual bool	getCanSaveByLumi ()
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

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::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache
Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)
static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)
static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)
static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)
Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const
Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_
edm::EDPutTokenT< DQMToken >	runToken_
unsigned int	streamId_

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::QcdPhotonsDQM

(

const edm::ParameterSet &

parameters

)

Constructor.

Definition at line 57 of file QcdPhotonsDQM.cc.

                                                           {
  // 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::~QcdPhotonsDQM ( )

override

Destructor.

Definition at line 102 of file QcdPhotonsDQM.cc.

{}

Member Function Documentation

analyze()

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

overridevirtual

Get the analysis.

Reimplemented from DQMEDAnalyzer.

Definition at line 235 of file QcdPhotonsDQM.cc.

                                                                         {
  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
}

References a, funct::abs(), edm::HLTGlobalStatus::accept(), b, SiPixelRawToDigiRegional_cfi::deltaPhi, PbPb_ZMuSkimMuonDPG_cff::deltaR, mps_fire::i, iEvent, edm::HandleBase::isValid(), metsig::jet, jetfilter_cfi::jetCollection, LogTrace, ExoticaDQM_cfi::photonCollection, edm::Handle< T >::product(), trigNames, and spclusmultinvestigator_cfi::vertexCollection.

bookHistograms()

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

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 104 of file QcdPhotonsDQM.cc.

                                                                                                {
  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);
}

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

Member Data Documentation

h_deltaEt_photon_jet

MonitorElement* QcdPhotonsDQM::h_deltaEt_photon_jet

private

Definition at line 78 of file QcdPhotonsDQM.h.

h_deltaPhi_jet_jet2

MonitorElement* QcdPhotonsDQM::h_deltaPhi_jet_jet2

private

Definition at line 77 of file QcdPhotonsDQM.h.

h_deltaPhi_photon_jet

MonitorElement* QcdPhotonsDQM::h_deltaPhi_photon_jet

private

Definition at line 76 of file QcdPhotonsDQM.h.

h_deltaPhi_photon_jet2

MonitorElement* QcdPhotonsDQM::h_deltaPhi_photon_jet2

private

Definition at line 82 of file QcdPhotonsDQM.h.

h_deltaR_jet_jet2

MonitorElement* QcdPhotonsDQM::h_deltaR_jet_jet2

private

Definition at line 83 of file QcdPhotonsDQM.h.

h_deltaR_photon_jet2

MonitorElement* QcdPhotonsDQM::h_deltaR_photon_jet2

private

Definition at line 84 of file QcdPhotonsDQM.h.

h_jet2_eta

MonitorElement* QcdPhotonsDQM::h_jet2_eta

private

Definition at line 81 of file QcdPhotonsDQM.h.

h_jet2_pt

MonitorElement* QcdPhotonsDQM::h_jet2_pt

private

Definition at line 80 of file QcdPhotonsDQM.h.

h_jet2_ptOverPhotonEt

MonitorElement* QcdPhotonsDQM::h_jet2_ptOverPhotonEt

private

Definition at line 79 of file QcdPhotonsDQM.h.

h_jet_count

MonitorElement* QcdPhotonsDQM::h_jet_count

private

Definition at line 75 of file QcdPhotonsDQM.h.

h_jet_eta

MonitorElement* QcdPhotonsDQM::h_jet_eta

private

Definition at line 74 of file QcdPhotonsDQM.h.

h_jet_pt

MonitorElement* QcdPhotonsDQM::h_jet_pt

private

Definition at line 73 of file QcdPhotonsDQM.h.

h_photon_count_bar

MonitorElement* QcdPhotonsDQM::h_photon_count_bar

private

Definition at line 71 of file QcdPhotonsDQM.h.

h_photon_count_end

MonitorElement* QcdPhotonsDQM::h_photon_count_end

private

Definition at line 72 of file QcdPhotonsDQM.h.

h_photon_et

MonitorElement* QcdPhotonsDQM::h_photon_et

private

Definition at line 69 of file QcdPhotonsDQM.h.

h_photon_et_beforeCuts

MonitorElement* QcdPhotonsDQM::h_photon_et_beforeCuts

private

Definition at line 68 of file QcdPhotonsDQM.h.

h_photon_et_jetco

MonitorElement* QcdPhotonsDQM::h_photon_et_jetco

private

Definition at line 87 of file QcdPhotonsDQM.h.

h_photon_et_jetcs

MonitorElement* QcdPhotonsDQM::h_photon_et_jetcs

private

Definition at line 86 of file QcdPhotonsDQM.h.

h_photon_et_jetfo

MonitorElement* QcdPhotonsDQM::h_photon_et_jetfo

private

Definition at line 89 of file QcdPhotonsDQM.h.

h_photon_et_jetfs

MonitorElement* QcdPhotonsDQM::h_photon_et_jetfs

private

Definition at line 88 of file QcdPhotonsDQM.h.

h_photon_eta

MonitorElement* QcdPhotonsDQM::h_photon_eta

private

Definition at line 70 of file QcdPhotonsDQM.h.

h_triggers_passed

MonitorElement* QcdPhotonsDQM::h_triggers_passed

private

Definition at line 67 of file QcdPhotonsDQM.h.

logTraceName

std::string QcdPhotonsDQM::logTraceName

private

Definition at line 44 of file QcdPhotonsDQM.h.

theBarrelRecHitTag_

edm::InputTag QcdPhotonsDQM::theBarrelRecHitTag_

private

Definition at line 61 of file QcdPhotonsDQM.h.

theBarrelRecHitToken_

edm::EDGetTokenT<EcalRecHitCollection> QcdPhotonsDQM::theBarrelRecHitToken_

private

Definition at line 63 of file QcdPhotonsDQM.h.

theEndcapRecHitTag_

edm::InputTag QcdPhotonsDQM::theEndcapRecHitTag_

private

Definition at line 62 of file QcdPhotonsDQM.h.

theEndcapRecHitToken_

edm::EDGetTokenT<EcalRecHitCollection> QcdPhotonsDQM::theEndcapRecHitToken_

private

Definition at line 64 of file QcdPhotonsDQM.h.

theJetCollectionLabel_

edm::InputTag QcdPhotonsDQM::theJetCollectionLabel_

private

Definition at line 49 of file QcdPhotonsDQM.h.

theJetCollectionToken_

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

private

Definition at line 52 of file QcdPhotonsDQM.h.

theMinJetPt_

double QcdPhotonsDQM::theMinJetPt_

private

Definition at line 54 of file QcdPhotonsDQM.h.

theMinPhotonEt_

double QcdPhotonsDQM::theMinPhotonEt_

private

Definition at line 55 of file QcdPhotonsDQM.h.

thePhotonCollectionToken_

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

private

Definition at line 51 of file QcdPhotonsDQM.h.

thePlotJetMaxEta_

double QcdPhotonsDQM::thePlotJetMaxEta_

private

Definition at line 59 of file QcdPhotonsDQM.h.

thePlotPhotonMaxEt_

double QcdPhotonsDQM::thePlotPhotonMaxEt_

private

Definition at line 57 of file QcdPhotonsDQM.h.

thePlotPhotonMaxEta_

double QcdPhotonsDQM::thePlotPhotonMaxEta_

private

Definition at line 58 of file QcdPhotonsDQM.h.

thePlotTheseTriggersToo_

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

private

Definition at line 48 of file QcdPhotonsDQM.h.

theRequirePhotonFound_

bool QcdPhotonsDQM::theRequirePhotonFound_

private

Definition at line 56 of file QcdPhotonsDQM.h.

theTriggerPathToPass_

std::string QcdPhotonsDQM::theTriggerPathToPass_

private

Definition at line 47 of file QcdPhotonsDQM.h.

theVertexCollectionToken_

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

private

Definition at line 53 of file QcdPhotonsDQM.h.

trigTagToken_

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

private

Definition at line 50 of file QcdPhotonsDQM.h.