CMS 3D CMS Logo

Classes | Public Member Functions | Private Member Functions | Private Attributes

L1ExtraDQM Class Reference

#include <L1ExtraDQM.h>

Inheritance diagram for L1ExtraDQM:
edm::EDAnalyzer

List of all members.

Classes

class  L1ExtraMonElement

Public Member Functions

 L1ExtraDQM (const edm::ParameterSet &)
virtual ~L1ExtraDQM ()

Private Member Functions

virtual void analyze (const edm::Event &, const edm::EventSetup &)
void analyzeL1ExtraCenJet (const edm::Event &, const edm::EventSetup &)
void analyzeL1ExtraETM (const edm::Event &, const edm::EventSetup &)
void analyzeL1ExtraETT (const edm::Event &, const edm::EventSetup &)
void analyzeL1ExtraForJet (const edm::Event &, const edm::EventSetup &)
void analyzeL1ExtraHfBitCounts (const edm::Event &, const edm::EventSetup &)
void analyzeL1ExtraHfRingEtSums (const edm::Event &, const edm::EventSetup &)
void analyzeL1ExtraHTM (const edm::Event &, const edm::EventSetup &)
void analyzeL1ExtraHTT (const edm::Event &, const edm::EventSetup &)
void analyzeL1ExtraIsoEG (const edm::Event &, const edm::EventSetup &)
void analyzeL1ExtraMuon (const edm::Event &, const edm::EventSetup &)
void analyzeL1ExtraNoIsoEG (const edm::Event &, const edm::EventSetup &)
void analyzeL1ExtraTauJet (const edm::Event &, const edm::EventSetup &)
virtual void beginJob ()
void beginRun (const edm::Run &, const edm::EventSetup &)
virtual void endJob ()
void endRun (const edm::Run &, const edm::EventSetup &)

Private Attributes

int m_currentRun
DQMStorem_dbe
 internal members
std::string m_dirName
 directory name for L1Extra plots
std::vector< L1ExtraMonElement
< l1extra::L1JetParticleCollection > * > 
m_meAnalysisL1ExtraCenJet
std::vector< L1ExtraMonElement
< l1extra::L1EtMissParticleCollection > * > 
m_meAnalysisL1ExtraETM
std::vector< L1ExtraMonElement
< l1extra::L1EtMissParticleCollection > * > 
m_meAnalysisL1ExtraETT
std::vector< L1ExtraMonElement
< l1extra::L1JetParticleCollection > * > 
m_meAnalysisL1ExtraForJet
std::vector< L1ExtraMonElement
< l1extra::L1HFRingsCollection > * > 
m_meAnalysisL1ExtraHfBitCounts
std::vector< L1ExtraMonElement
< l1extra::L1HFRingsCollection > * > 
m_meAnalysisL1ExtraHfRingEtSums
std::vector< L1ExtraMonElement
< l1extra::L1EtMissParticleCollection > * > 
m_meAnalysisL1ExtraHTM
std::vector< L1ExtraMonElement
< l1extra::L1EtMissParticleCollection > * > 
m_meAnalysisL1ExtraHTT
std::vector< L1ExtraMonElement
< l1extra::L1EmParticleCollection > * > 
m_meAnalysisL1ExtraIsoEG
std::vector< L1ExtraMonElement
< l1extra::L1MuonParticleCollection > * > 
m_meAnalysisL1ExtraMuon
 pointers to L1ExtraMonElement for each sub-analysis
std::vector< L1ExtraMonElement
< l1extra::L1EmParticleCollection > * > 
m_meAnalysisL1ExtraNoIsoEG
std::vector< L1ExtraMonElement
< l1extra::L1JetParticleCollection > * > 
m_meAnalysisL1ExtraTauJet
int m_nrBxInEventGct
int m_nrBxInEventGmt
 number of bunch crosses in event to be monitored
int m_nrEvJob
int m_nrEvRun
bool m_resetModule
L1RetrieveL1Extra m_retrieveL1Extra
 input parameters

Detailed Description

Description: online DQM module for L1Extra trigger objects.

Implementation: <TODO: enter implementation details>

Author:
: Vasile Mihai Ghete - HEPHY Vienna

$Date$ $Revision$

Definition at line 74 of file L1ExtraDQM.h.


Constructor & Destructor Documentation

L1ExtraDQM::L1ExtraDQM ( const edm::ParameterSet paramSet) [explicit]

Definition at line 31 of file L1ExtraDQM.cc.

References edm::ParameterSet::getUntrackedParameter(), m_dbe, m_dirName, m_meAnalysisL1ExtraCenJet, m_meAnalysisL1ExtraETM, m_meAnalysisL1ExtraETT, m_meAnalysisL1ExtraForJet, m_meAnalysisL1ExtraHfBitCounts, m_meAnalysisL1ExtraHfRingEtSums, m_meAnalysisL1ExtraHTM, m_meAnalysisL1ExtraHTT, m_meAnalysisL1ExtraIsoEG, m_meAnalysisL1ExtraMuon, m_meAnalysisL1ExtraNoIsoEG, m_meAnalysisL1ExtraTauJet, m_nrBxInEventGct, m_nrBxInEventGmt, cppFunctionSkipper::operator, DQMStore::setCurrentFolder(), and DQMStore::setVerbose().

                                                      :
    //
    m_retrieveL1Extra(paramSet.getParameter<edm::ParameterSet>("L1ExtraInputTags")),
    m_dirName(paramSet.getUntrackedParameter("DirName", std::string(
                    "L1T/L1ExtraDQM"))),
    //
    m_nrBxInEventGmt(paramSet.getParameter<int>("NrBxInEventGmt")),
    m_nrBxInEventGct(paramSet.getParameter<int>("NrBxInEventGct")),
    //
    m_dbe(0), m_resetModule(true), m_currentRun(-99),
    //
    m_nrEvJob(0),
    m_nrEvRun(0)

    {


    //
    if ((m_nrBxInEventGmt > 0) && ((m_nrBxInEventGmt % 2) == 0)) {
        m_nrBxInEventGmt = m_nrBxInEventGmt - 1;

        edm::LogInfo("L1ExtraDQM")
                << "\nWARNING: Number of bunch crossing to be monitored for GMT rounded to: "
                << m_nrBxInEventGmt
                << "\n         The number must be an odd number!\n"
                << std::endl;
    }

    if ((m_nrBxInEventGct > 0) && ((m_nrBxInEventGct % 2) == 0)) {
        m_nrBxInEventGct = m_nrBxInEventGct - 1;

        edm::LogInfo("L1ExtraDQM")
                << "\nWARNING: Number of bunch crossing to be monitored for GCT rounded to: "
                << m_nrBxInEventGct
                << "\n         The number must be an odd number!\n"
                << std::endl;
    }

    //
    m_meAnalysisL1ExtraMuon.reserve(m_nrBxInEventGmt);
    m_meAnalysisL1ExtraIsoEG.reserve(m_nrBxInEventGct);
    m_meAnalysisL1ExtraNoIsoEG.reserve(m_nrBxInEventGct);
    m_meAnalysisL1ExtraCenJet.reserve(m_nrBxInEventGct);
    m_meAnalysisL1ExtraForJet.reserve(m_nrBxInEventGct);
    m_meAnalysisL1ExtraTauJet.reserve(m_nrBxInEventGct);
    m_meAnalysisL1ExtraETT.reserve(m_nrBxInEventGct);
    m_meAnalysisL1ExtraETM.reserve(m_nrBxInEventGct);
    m_meAnalysisL1ExtraHTT.reserve(m_nrBxInEventGct);
    m_meAnalysisL1ExtraHTM.reserve(m_nrBxInEventGct);
    m_meAnalysisL1ExtraHfBitCounts.reserve(m_nrBxInEventGct);
    m_meAnalysisL1ExtraHfRingEtSums.reserve(m_nrBxInEventGct);

    m_dbe = edm::Service<DQMStore>().operator->();
    if (m_dbe == 0) {
        edm::LogInfo("L1ExtraDQM") << "\n Unable to get DQMStore service.";
    } else {

        if (paramSet.getUntrackedParameter<bool> ("DQMStore", false)) {
            m_dbe->setVerbose(0);
        }

        m_dbe->setCurrentFolder(m_dirName);

    }

}
L1ExtraDQM::~L1ExtraDQM ( ) [virtual]

Definition at line 99 of file L1ExtraDQM.cc.

                        {

    // empty

}

Member Function Documentation

void L1ExtraDQM::analyze ( const edm::Event iEvent,
const edm::EventSetup evSetup 
) [private, virtual]
void L1ExtraDQM::analyzeL1ExtraCenJet ( const edm::Event iEvent,
const edm::EventSetup evSetup 
) [private]

Definition at line 184 of file L1ExtraDQM.cc.

References L1RetrieveL1Extra::l1ExtraCenJet(), m_meAnalysisL1ExtraCenJet, m_nrBxInEventGct, m_retrieveL1Extra, and L1RetrieveL1Extra::validL1ExtraCenJet().

Referenced by analyze().

                                      {

    bool bookEta = true;
    bool bookPhi = true;

    bool isL1Coll = true;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;

        (m_meAnalysisL1ExtraCenJet.at(iBxInEvent))->fillNrObjects(
                m_retrieveL1Extra.l1ExtraCenJet(),
                m_retrieveL1Extra.validL1ExtraCenJet(), isL1Coll, bxInEvent);
        (m_meAnalysisL1ExtraCenJet.at(iBxInEvent))->fillEtPhiEta(
                m_retrieveL1Extra.l1ExtraCenJet(),
                m_retrieveL1Extra.validL1ExtraCenJet(), bookPhi, bookEta,
                isL1Coll, bxInEvent);
    }

}
void L1ExtraDQM::analyzeL1ExtraETM ( const edm::Event iEvent,
const edm::EventSetup evSetup 
) [private]

Definition at line 282 of file L1ExtraDQM.cc.

References L1RetrieveL1Extra::l1ExtraETM(), m_meAnalysisL1ExtraETM, m_nrBxInEventGct, m_retrieveL1Extra, and L1RetrieveL1Extra::validL1ExtraETM().

Referenced by analyze().

                                      {

    bool bookPhi = true;
    bool bookEta = false;

    bool isL1Coll = true;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;

        (m_meAnalysisL1ExtraETM.at(iBxInEvent))->fillEtPhiEta(m_retrieveL1Extra.l1ExtraETM(),
                m_retrieveL1Extra.validL1ExtraETM(), bookPhi, bookEta,
                isL1Coll, bxInEvent);

    }

}
void L1ExtraDQM::analyzeL1ExtraETT ( const edm::Event iEvent,
const edm::EventSetup evSetup 
) [private]

Definition at line 263 of file L1ExtraDQM.cc.

References L1RetrieveL1Extra::l1ExtraETT(), m_meAnalysisL1ExtraETT, m_nrBxInEventGct, m_retrieveL1Extra, and L1RetrieveL1Extra::validL1ExtraETT().

Referenced by analyze().

                                      {

    bool isL1Coll = true;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;

        (m_meAnalysisL1ExtraETT.at(iBxInEvent))->fillEtTotal(m_retrieveL1Extra.l1ExtraETT(),
                m_retrieveL1Extra.validL1ExtraETT(), isL1Coll, bxInEvent);

    }

}
void L1ExtraDQM::analyzeL1ExtraForJet ( const edm::Event iEvent,
const edm::EventSetup evSetup 
) [private]

Definition at line 211 of file L1ExtraDQM.cc.

References L1RetrieveL1Extra::l1ExtraForJet(), m_meAnalysisL1ExtraForJet, m_nrBxInEventGct, m_retrieveL1Extra, and L1RetrieveL1Extra::validL1ExtraForJet().

Referenced by analyze().

                                      {

    bool bookPhi = true;
    bool bookEta = true;

    bool isL1Coll = true;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;

        (m_meAnalysisL1ExtraForJet.at(iBxInEvent))->fillNrObjects(
                m_retrieveL1Extra.l1ExtraForJet(),
                m_retrieveL1Extra.validL1ExtraForJet(), isL1Coll, bxInEvent);
        (m_meAnalysisL1ExtraForJet.at(iBxInEvent))->fillEtPhiEta(
                m_retrieveL1Extra.l1ExtraForJet(),
                m_retrieveL1Extra.validL1ExtraForJet(), bookPhi, bookEta,
                isL1Coll, bxInEvent);
    }

}
void L1ExtraDQM::analyzeL1ExtraHfBitCounts ( const edm::Event iEvent,
const edm::EventSetup evSetup 
) [private]

Definition at line 345 of file L1ExtraDQM.cc.

References l1extra::L1HFRings::kNumRings, L1RetrieveL1Extra::l1ExtraHfBitCounts(), m_meAnalysisL1ExtraHfBitCounts, m_nrBxInEventGct, m_retrieveL1Extra, and L1RetrieveL1Extra::validL1ExtraHfBitCounts().

Referenced by analyze().

                                      {

    bool isL1Coll = true;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;

        for (int iCount = 0; iCount < l1extra::L1HFRings::kNumRings; ++iCount) {
            (m_meAnalysisL1ExtraHfBitCounts.at(iBxInEvent))->fillHfBitCounts(
                    m_retrieveL1Extra.l1ExtraHfBitCounts(),
                    m_retrieveL1Extra.validL1ExtraHfBitCounts(), iCount,
                    isL1Coll, bxInEvent);
        }
    }

}
void L1ExtraDQM::analyzeL1ExtraHfRingEtSums ( const edm::Event iEvent,
const edm::EventSetup evSetup 
) [private]

Definition at line 367 of file L1ExtraDQM.cc.

References l1extra::L1HFRings::kNumRings, L1RetrieveL1Extra::l1ExtraHfRingEtSums(), m_meAnalysisL1ExtraHfRingEtSums, m_nrBxInEventGct, m_retrieveL1Extra, and L1RetrieveL1Extra::validL1ExtraHfRingEtSums().

Referenced by analyze().

                                      {

    bool isL1Coll = true;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;

        for (int iCount = 0; iCount < l1extra::L1HFRings::kNumRings; ++iCount) {
            (m_meAnalysisL1ExtraHfRingEtSums.at(iBxInEvent))->fillHfRingEtSums(
                    m_retrieveL1Extra.l1ExtraHfRingEtSums(),
                    m_retrieveL1Extra.validL1ExtraHfRingEtSums(), iCount,
                    isL1Coll, bxInEvent);
        }
    }

}
void L1ExtraDQM::analyzeL1ExtraHTM ( const edm::Event iEvent,
const edm::EventSetup evSetup 
) [private]

Definition at line 323 of file L1ExtraDQM.cc.

References L1RetrieveL1Extra::l1ExtraHTM(), m_meAnalysisL1ExtraHTM, m_nrBxInEventGct, m_retrieveL1Extra, and L1RetrieveL1Extra::validL1ExtraHTM().

Referenced by analyze().

                                      {

    bool bookPhi = true;
    bool bookEta = false;

    bool isL1Coll = true;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;

        (m_meAnalysisL1ExtraHTM.at(iBxInEvent))->fillEtPhiEta(m_retrieveL1Extra.l1ExtraHTM(),
                m_retrieveL1Extra.validL1ExtraHTM(), bookPhi, bookEta,
                isL1Coll, bxInEvent);
    }

}
void L1ExtraDQM::analyzeL1ExtraHTT ( const edm::Event iEvent,
const edm::EventSetup evSetup 
) [private]

Definition at line 305 of file L1ExtraDQM.cc.

References L1RetrieveL1Extra::l1ExtraHTT(), m_meAnalysisL1ExtraHTT, m_nrBxInEventGct, m_retrieveL1Extra, and L1RetrieveL1Extra::validL1ExtraHTT().

Referenced by analyze().

                                      {

    bool isL1Coll = true;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;

        (m_meAnalysisL1ExtraHTT.at(iBxInEvent))->fillEtTotal(m_retrieveL1Extra.l1ExtraHTT(),
                m_retrieveL1Extra.validL1ExtraHTT(), isL1Coll, bxInEvent);

    }
}
void L1ExtraDQM::analyzeL1ExtraIsoEG ( const edm::Event iEvent,
const edm::EventSetup evSetup 
) [private]

Definition at line 132 of file L1ExtraDQM.cc.

References L1RetrieveL1Extra::l1ExtraIsoEG(), m_meAnalysisL1ExtraIsoEG, m_nrBxInEventGct, m_retrieveL1Extra, and L1RetrieveL1Extra::validL1ExtraIsoEG().

Referenced by analyze().

                                      {

    bool bookEta = true;
    bool bookPhi = true;

    bool isL1Coll = true;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;

        (m_meAnalysisL1ExtraIsoEG.at(iBxInEvent))->fillNrObjects(
                m_retrieveL1Extra.l1ExtraIsoEG(),
                m_retrieveL1Extra.validL1ExtraIsoEG(), isL1Coll, bxInEvent);
        (m_meAnalysisL1ExtraIsoEG.at(iBxInEvent))->fillPtPhiEta(
                m_retrieveL1Extra.l1ExtraIsoEG(),
                m_retrieveL1Extra.validL1ExtraIsoEG(), bookPhi, bookEta,
                isL1Coll, bxInEvent);
    }

}
void L1ExtraDQM::analyzeL1ExtraMuon ( const edm::Event iEvent,
const edm::EventSetup evSetup 
) [private]

Definition at line 105 of file L1ExtraDQM.cc.

References L1RetrieveL1Extra::l1ExtraMuon(), m_meAnalysisL1ExtraMuon, m_nrBxInEventGmt, m_retrieveL1Extra, and L1RetrieveL1Extra::validL1ExtraMuon().

Referenced by analyze().

                                      {

    bool bookEta = true;
    bool bookPhi = true;

    bool isL1Coll = true;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGmt; ++iBxInEvent) {

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGmt] -> [-X, 0, +X]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGmt + 1) / 2
                - m_nrBxInEventGmt;

        (m_meAnalysisL1ExtraMuon.at(iBxInEvent))->fillNrObjects(
                m_retrieveL1Extra.l1ExtraMuon(),
                m_retrieveL1Extra.validL1ExtraMuon(), isL1Coll, bxInEvent);
        (m_meAnalysisL1ExtraMuon.at(iBxInEvent))->fillPtPhiEta(
                m_retrieveL1Extra.l1ExtraMuon(),
                m_retrieveL1Extra.validL1ExtraMuon(), bookPhi, bookEta,
                isL1Coll, bxInEvent);

    }

}
void L1ExtraDQM::analyzeL1ExtraNoIsoEG ( const edm::Event iEvent,
const edm::EventSetup evSetup 
) [private]

Definition at line 158 of file L1ExtraDQM.cc.

References L1RetrieveL1Extra::l1ExtraNoIsoEG(), m_meAnalysisL1ExtraNoIsoEG, m_nrBxInEventGct, m_retrieveL1Extra, and L1RetrieveL1Extra::validL1ExtraNoIsoEG().

Referenced by analyze().

                                      {

    bool bookEta = true;
    bool bookPhi = true;

    bool isL1Coll = true;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;

        (m_meAnalysisL1ExtraNoIsoEG.at(iBxInEvent))->fillNrObjects(
                m_retrieveL1Extra.l1ExtraNoIsoEG(),
                m_retrieveL1Extra.validL1ExtraNoIsoEG(), isL1Coll, bxInEvent);
        (m_meAnalysisL1ExtraNoIsoEG.at(iBxInEvent))->fillPtPhiEta(
                m_retrieveL1Extra.l1ExtraNoIsoEG(),
                m_retrieveL1Extra.validL1ExtraNoIsoEG(), bookPhi, bookEta,
                isL1Coll, bxInEvent);
    }

}
void L1ExtraDQM::analyzeL1ExtraTauJet ( const edm::Event iEvent,
const edm::EventSetup evSetup 
) [private]

Definition at line 237 of file L1ExtraDQM.cc.

References L1RetrieveL1Extra::l1ExtraTauJet(), m_meAnalysisL1ExtraTauJet, m_nrBxInEventGct, m_retrieveL1Extra, and L1RetrieveL1Extra::validL1ExtraTauJet().

Referenced by analyze().

                                      {

    bool bookPhi = true;
    bool bookEta = true;

    bool isL1Coll = true;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;

        (m_meAnalysisL1ExtraTauJet.at(iBxInEvent))->fillNrObjects(
                m_retrieveL1Extra.l1ExtraTauJet(),
                m_retrieveL1Extra.validL1ExtraTauJet(), isL1Coll, bxInEvent);
        (m_meAnalysisL1ExtraTauJet.at(iBxInEvent))->fillEtPhiEta(
                m_retrieveL1Extra.l1ExtraTauJet(),
                m_retrieveL1Extra.validL1ExtraTauJet(), bookPhi, bookEta,
                isL1Coll, bxInEvent);
    }

}
void L1ExtraDQM::beginJob ( void  ) [private, virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 390 of file L1ExtraDQM.cc.

                          {


}
void L1ExtraDQM::beginRun ( const edm::Run iRun,
const edm::EventSetup evSetup 
) [private, virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 396 of file L1ExtraDQM.cc.

References bookHistograms(), CenJet, DQMStore::dirExists(), ETM, ETT, ForJet, HfBitCounts, HfRingEtSums, HTM, HTT, IsoEG, m_dbe, m_dirName, m_meAnalysisL1ExtraCenJet, m_meAnalysisL1ExtraETM, m_meAnalysisL1ExtraETT, m_meAnalysisL1ExtraForJet, m_meAnalysisL1ExtraHfBitCounts, m_meAnalysisL1ExtraHfRingEtSums, m_meAnalysisL1ExtraHTM, m_meAnalysisL1ExtraHTT, m_meAnalysisL1ExtraIsoEG, m_meAnalysisL1ExtraMuon, m_meAnalysisL1ExtraNoIsoEG, m_meAnalysisL1ExtraTauJet, m_nrBxInEventGct, m_nrBxInEventGmt, m_nrEvRun, Mu, NoIsoEG, cppFunctionSkipper::operator, DQMStore::rmdir(), DQMStore::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, and TauJet.

                                                                          {

    m_nrEvRun = 0;

    DQMStore* dbe = 0;
    dbe = edm::Service<DQMStore>().operator->();

    // clean up directory
    if (dbe) {
        dbe->setCurrentFolder(m_dirName);
        if (dbe->dirExists(m_dirName)) {
            dbe->rmdir(m_dirName);
        }
        dbe->setCurrentFolder(m_dirName);
    }

    std::vector<L1GtObject> l1Obj;

    // define standard sets of histograms

    //
    l1Obj.clear();
    l1Obj.push_back(Mu);
    int nrMonElements = 5;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGmt; ++iBxInEvent) {

        m_meAnalysisL1ExtraMuon.push_back(new L1ExtraDQM::L1ExtraMonElement<
                l1extra::L1MuonParticleCollection>(evSetup, nrMonElements));

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        // write it in hex [..., E, F, 0, 1, 2, ...]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;
        int bxInEventHex = (bxInEvent+ 16) % 16;

        std::stringstream ss;
        std::string bxInEventHexString;
        ss << std::uppercase << std::hex << bxInEventHex;
        ss >> bxInEventHexString;

        if (m_dbe) {
            dbe->setCurrentFolder(m_dirName + "/BxInEvent_"
                    + bxInEventHexString);
        }

        (m_meAnalysisL1ExtraMuon.at(iBxInEvent))->bookHistograms(evSetup, m_dbe,
                "L1_Mu", l1Obj);

    }

    //
    l1Obj.clear();
    l1Obj.push_back(IsoEG);
    nrMonElements = 4;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        m_meAnalysisL1ExtraIsoEG.push_back(new L1ExtraDQM::L1ExtraMonElement<
                l1extra::L1EmParticleCollection>(evSetup, nrMonElements));

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        // write it in hex [..., E, F, 0, 1, 2, ...]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;
        int bxInEventHex = (bxInEvent+ 16) % 16;

        std::stringstream ss;
        std::string bxInEventHexString;
        ss << std::uppercase << std::hex << bxInEventHex;
        ss >> bxInEventHexString;

        if (m_dbe) {
            dbe->setCurrentFolder(m_dirName + "/BxInEvent_"
                    + bxInEventHexString);
        }

        (m_meAnalysisL1ExtraIsoEG.at(iBxInEvent))->bookHistograms(evSetup, m_dbe,
                "L1_IsoEG", l1Obj);
    }

    //
    l1Obj.clear();
    l1Obj.push_back(NoIsoEG);
    nrMonElements = 4;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        m_meAnalysisL1ExtraNoIsoEG.push_back(new L1ExtraDQM::L1ExtraMonElement<
                l1extra::L1EmParticleCollection>(evSetup, nrMonElements));

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        // write it in hex [..., E, F, 0, 1, 2, ...]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;
        int bxInEventHex = (bxInEvent+ 16) % 16;

        std::stringstream ss;
        std::string bxInEventHexString;
        ss << std::uppercase << std::hex << bxInEventHex;
        ss >> bxInEventHexString;

        if (m_dbe) {
            dbe->setCurrentFolder(m_dirName + "/BxInEvent_"
                    + bxInEventHexString);
        }

        (m_meAnalysisL1ExtraNoIsoEG.at(iBxInEvent))->bookHistograms(evSetup, m_dbe,
                "L1_NoIsoEG", l1Obj);
    }

    //
    l1Obj.clear();
    l1Obj.push_back(CenJet);
    nrMonElements = 4;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        m_meAnalysisL1ExtraCenJet.push_back(new L1ExtraDQM::L1ExtraMonElement<
                l1extra::L1JetParticleCollection>(evSetup, nrMonElements));

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        // write it in hex [..., E, F, 0, 1, 2, ...]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;
        int bxInEventHex = (bxInEvent+ 16) % 16;

        std::stringstream ss;
        std::string bxInEventHexString;
        ss << std::uppercase << std::hex << bxInEventHex;
        ss >> bxInEventHexString;

        if (m_dbe) {
            dbe->setCurrentFolder(m_dirName + "/BxInEvent_"
                    + bxInEventHexString);
        }

        (m_meAnalysisL1ExtraCenJet.at(iBxInEvent))->bookHistograms(evSetup, m_dbe,
                "L1_CenJet", l1Obj);
    }

    //
    l1Obj.clear();
    l1Obj.push_back(ForJet);

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        m_meAnalysisL1ExtraForJet.push_back(new L1ExtraDQM::L1ExtraMonElement<
                l1extra::L1JetParticleCollection>(evSetup, nrMonElements));

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        // write it in hex [..., E, F, 0, 1, 2, ...]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;
        int bxInEventHex = (bxInEvent+ 16) % 16;

        std::stringstream ss;
        std::string bxInEventHexString;
        ss << std::uppercase << std::hex << bxInEventHex;
        ss >> bxInEventHexString;

        if (m_dbe) {
            dbe->setCurrentFolder(m_dirName + "/BxInEvent_"
                    + bxInEventHexString);
        }

        (m_meAnalysisL1ExtraForJet.at(iBxInEvent))->bookHistograms(evSetup, m_dbe,
                "L1_ForJet", l1Obj);
    }

    //
    l1Obj.clear();
    l1Obj.push_back(TauJet);

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        m_meAnalysisL1ExtraTauJet.push_back(new L1ExtraDQM::L1ExtraMonElement<
                l1extra::L1JetParticleCollection>(evSetup, nrMonElements));

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        // write it in hex [..., E, F, 0, 1, 2, ...]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;
        int bxInEventHex = (bxInEvent+ 16) % 16;

        std::stringstream ss;
        std::string bxInEventHexString;
        ss << std::uppercase << std::hex << bxInEventHex;
        ss >> bxInEventHexString;

        if (m_dbe) {
            dbe->setCurrentFolder(m_dirName + "/BxInEvent_"
                    + bxInEventHexString);
        }

        (m_meAnalysisL1ExtraTauJet.at(iBxInEvent))->bookHistograms(evSetup, m_dbe,
                "L1_TauJet", l1Obj);
    }

    //
    l1Obj.clear();
    l1Obj.push_back(ETT);
    nrMonElements = 1;

    bool bookPhi = false;
    bool bookEta = false;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        m_meAnalysisL1ExtraETT.push_back(new L1ExtraDQM::L1ExtraMonElement<
                l1extra::L1EtMissParticleCollection>(evSetup, nrMonElements));

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        // write it in hex [..., E, F, 0, 1, 2, ...]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;
        int bxInEventHex = (bxInEvent+ 16) % 16;

        std::stringstream ss;
        std::string bxInEventHexString;
        ss << std::uppercase << std::hex << bxInEventHex;
        ss >> bxInEventHexString;

        if (m_dbe) {
            dbe->setCurrentFolder(m_dirName + "/BxInEvent_"
                    + bxInEventHexString);
        }

        (m_meAnalysisL1ExtraETT.at(iBxInEvent))->bookHistograms(evSetup, m_dbe,
                "L1_ETT", l1Obj, bookPhi, bookEta);
    }

    //
    l1Obj.clear();
    l1Obj.push_back(ETM);
    nrMonElements = 2;

    bookPhi = true;
    bookEta = false;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        m_meAnalysisL1ExtraETM.push_back(new L1ExtraDQM::L1ExtraMonElement<
                l1extra::L1EtMissParticleCollection>(evSetup, nrMonElements));

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        // write it in hex [..., E, F, 0, 1, 2, ...]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;
        int bxInEventHex = (bxInEvent+ 16) % 16;

        std::stringstream ss;
        std::string bxInEventHexString;
        ss << std::uppercase << std::hex << bxInEventHex;
        ss >> bxInEventHexString;

        if (m_dbe) {
            dbe->setCurrentFolder(m_dirName + "/BxInEvent_"
                    + bxInEventHexString);
        }

        (m_meAnalysisL1ExtraETM.at(iBxInEvent))->bookHistograms(evSetup, m_dbe,
                "L1_ETM", l1Obj, bookPhi, bookEta);
    }

    //
    l1Obj.clear();
    l1Obj.push_back(HTT);
    nrMonElements = 1;

    bookPhi = false;
    bookEta = false;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        m_meAnalysisL1ExtraHTT.push_back(new L1ExtraDQM::L1ExtraMonElement<
                l1extra::L1EtMissParticleCollection>(evSetup, nrMonElements));

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        // write it in hex [..., E, F, 0, 1, 2, ...]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;
        int bxInEventHex = (bxInEvent+ 16) % 16;

        std::stringstream ss;
        std::string bxInEventHexString;
        ss << std::uppercase << std::hex << bxInEventHex;
        ss >> bxInEventHexString;

        if (m_dbe) {
            dbe->setCurrentFolder(m_dirName + "/BxInEvent_"
                    + bxInEventHexString);
        }

        (m_meAnalysisL1ExtraHTT.at(iBxInEvent))->bookHistograms(evSetup, m_dbe,
                "L1_HTT", l1Obj, bookPhi, bookEta);
    }

    //
    l1Obj.clear();
    l1Obj.push_back(HTM);
    nrMonElements = 2;

    bookPhi = true;
    bookEta = false;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        m_meAnalysisL1ExtraHTM.push_back(new L1ExtraDQM::L1ExtraMonElement<
                l1extra::L1EtMissParticleCollection>(evSetup, nrMonElements));

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        // write it in hex [..., E, F, 0, 1, 2, ...]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;
        int bxInEventHex = (bxInEvent+ 16) % 16;

        std::stringstream ss;
        std::string bxInEventHexString;
        ss << std::uppercase << std::hex << bxInEventHex;
        ss >> bxInEventHexString;

        if (m_dbe) {
            dbe->setCurrentFolder(m_dirName + "/BxInEvent_"
                    + bxInEventHexString);
        }

        (m_meAnalysisL1ExtraHTM.at(iBxInEvent))->bookHistograms(evSetup, m_dbe,
                "L1_HTM", l1Obj, bookPhi, bookEta);
    }

    //
    l1Obj.clear();
    l1Obj.push_back(HfBitCounts);
    nrMonElements = 1;

    bookPhi = false;
    bookEta = false;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        m_meAnalysisL1ExtraHfBitCounts.push_back(
                new L1ExtraDQM::L1ExtraMonElement<l1extra::L1HFRingsCollection>(
                        evSetup, nrMonElements));

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        // write it in hex [..., E, F, 0, 1, 2, ...]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;
        int bxInEventHex = (bxInEvent+ 16) % 16;

        std::stringstream ss;
        std::string bxInEventHexString;
        ss << std::uppercase << std::hex << bxInEventHex;
        ss >> bxInEventHexString;

        if (m_dbe) {
            dbe->setCurrentFolder(m_dirName + "/BxInEvent_"
                    + bxInEventHexString);
        }

        (m_meAnalysisL1ExtraHfBitCounts.at(iBxInEvent))->bookHistograms(evSetup,
                m_dbe, "L1_HfBitCounts", l1Obj, bookPhi, bookEta);
    }

    //
    l1Obj.clear();
    l1Obj.push_back(HfRingEtSums);
    nrMonElements = 1;

    bookPhi = false;
    bookEta = false;

    for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {

        m_meAnalysisL1ExtraHfRingEtSums.push_back(
                new L1ExtraDQM::L1ExtraMonElement<l1extra::L1HFRingsCollection>(
                        evSetup, nrMonElements));

        // convert to actual convention used in the hardware
        // (from [o, m_nrBxInEventGct] -> [-X, 0, +X]
        // write it in hex [..., E, F, 0, 1, 2, ...]
        int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2
                - m_nrBxInEventGct;
        int bxInEventHex = (bxInEvent+ 16) % 16;

        std::stringstream ss;
        std::string bxInEventHexString;
        ss << std::uppercase << std::hex << bxInEventHex;
        ss >> bxInEventHexString;

        if (m_dbe) {
            dbe->setCurrentFolder(m_dirName + "/BxInEvent_"
                    + bxInEventHexString);
        }

        (m_meAnalysisL1ExtraHfRingEtSums.at(iBxInEvent))->bookHistograms(evSetup,
                m_dbe, "L1_HfRingEtSums", l1Obj, bookPhi, bookEta);
    }

}
void L1ExtraDQM::endJob ( void  ) [private, virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 959 of file L1ExtraDQM.cc.

References m_nrEvJob.

                        {

    edm::LogInfo("L1ExtraDQM")
            << "\n\nTotal number of events analyzed in this job: " << m_nrEvJob
            << "\n" << std::endl;

    return;
}
void L1ExtraDQM::endRun ( const edm::Run run,
const edm::EventSetup evSetup 
) [private, virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 835 of file L1ExtraDQM.cc.

References edm::RunBase::id(), LogDebug, m_meAnalysisL1ExtraCenJet, m_meAnalysisL1ExtraETM, m_meAnalysisL1ExtraETT, m_meAnalysisL1ExtraForJet, m_meAnalysisL1ExtraHfBitCounts, m_meAnalysisL1ExtraHfRingEtSums, m_meAnalysisL1ExtraHTM, m_meAnalysisL1ExtraHTT, m_meAnalysisL1ExtraIsoEG, m_meAnalysisL1ExtraMuon, m_meAnalysisL1ExtraNoIsoEG, m_meAnalysisL1ExtraTauJet, m_nrEvJob, and m_nrEvRun.

                                                                       {

    // delete if event setup has changed only FIXME

    for (std::vector<L1ExtraMonElement<l1extra::L1MuonParticleCollection>*>::iterator
            iterME = m_meAnalysisL1ExtraMuon.begin(); iterME
            != m_meAnalysisL1ExtraMuon.end(); ++iterME) {

        delete *iterME;

    }
    m_meAnalysisL1ExtraMuon.clear();


    for (std::vector<L1ExtraMonElement<l1extra::L1EmParticleCollection>*>::iterator
            iterME = m_meAnalysisL1ExtraIsoEG.begin(); iterME
            != m_meAnalysisL1ExtraIsoEG.end(); ++iterME) {

        delete *iterME;

    }
    m_meAnalysisL1ExtraIsoEG.clear();


    for (std::vector<L1ExtraMonElement<l1extra::L1EmParticleCollection>*>::iterator
            iterME = m_meAnalysisL1ExtraNoIsoEG.begin(); iterME
            != m_meAnalysisL1ExtraNoIsoEG.end(); ++iterME) {

        delete *iterME;

    }
    m_meAnalysisL1ExtraNoIsoEG.clear();


    for (std::vector<L1ExtraMonElement<l1extra::L1JetParticleCollection>*>::iterator
            iterME = m_meAnalysisL1ExtraCenJet.begin(); iterME
            != m_meAnalysisL1ExtraCenJet.end(); ++iterME) {

        delete *iterME;

    }
    m_meAnalysisL1ExtraCenJet.clear();

    for (std::vector<L1ExtraMonElement<l1extra::L1JetParticleCollection>*>::iterator
            iterME = m_meAnalysisL1ExtraForJet.begin(); iterME
            != m_meAnalysisL1ExtraForJet.end(); ++iterME) {

        delete *iterME;

    }
    m_meAnalysisL1ExtraForJet.clear();

    for (std::vector<L1ExtraMonElement<l1extra::L1JetParticleCollection>*>::iterator
            iterME = m_meAnalysisL1ExtraTauJet.begin(); iterME
            != m_meAnalysisL1ExtraTauJet.end(); ++iterME) {

        delete *iterME;

    }
    m_meAnalysisL1ExtraTauJet.clear();


    for (std::vector<L1ExtraMonElement<l1extra::L1EtMissParticleCollection>*>::iterator
            iterME = m_meAnalysisL1ExtraETT.begin(); iterME
            != m_meAnalysisL1ExtraETT.end(); ++iterME) {

        delete *iterME;

    }
    m_meAnalysisL1ExtraETT.clear();

    for (std::vector<L1ExtraMonElement<l1extra::L1EtMissParticleCollection>*>::iterator
            iterME = m_meAnalysisL1ExtraETM.begin(); iterME
            != m_meAnalysisL1ExtraETM.end(); ++iterME) {

        delete *iterME;

    }
    m_meAnalysisL1ExtraETM.clear();

    for (std::vector<L1ExtraMonElement<l1extra::L1EtMissParticleCollection>*>::iterator
            iterME = m_meAnalysisL1ExtraHTT.begin(); iterME
            != m_meAnalysisL1ExtraHTT.end(); ++iterME) {

        delete *iterME;

    }
    m_meAnalysisL1ExtraHTT.clear();

    for (std::vector<L1ExtraMonElement<l1extra::L1EtMissParticleCollection>*>::iterator
            iterME = m_meAnalysisL1ExtraHTM.begin(); iterME
            != m_meAnalysisL1ExtraHTM.end(); ++iterME) {

        delete *iterME;

    }
    m_meAnalysisL1ExtraHTM.clear();


    for (std::vector<L1ExtraMonElement<l1extra::L1HFRingsCollection>*>::iterator
            iterME = m_meAnalysisL1ExtraHfBitCounts.begin(); iterME
            != m_meAnalysisL1ExtraHfBitCounts.end(); ++iterME) {

        delete *iterME;

    }
    m_meAnalysisL1ExtraHfBitCounts.clear();

    for (std::vector<L1ExtraMonElement<l1extra::L1HFRingsCollection>*>::iterator
            iterME = m_meAnalysisL1ExtraHfRingEtSums.begin(); iterME
            != m_meAnalysisL1ExtraHfRingEtSums.end(); ++iterME) {

        delete *iterME;

    }
    m_meAnalysisL1ExtraHfRingEtSums.clear();

    LogDebug("L1ExtraDQM") << "\n\n endRun: " << run.id()
            << "\n  Number of events analyzed in this run:       " << m_nrEvRun
            << "\n  Total number of events analyzed in this job: " << m_nrEvJob
            << "\n" << std::endl;

}

Member Data Documentation

int L1ExtraDQM::m_currentRun [private]

Definition at line 194 of file L1ExtraDQM.h.

internal members

Definition at line 191 of file L1ExtraDQM.h.

Referenced by beginRun(), and L1ExtraDQM().

std::string L1ExtraDQM::m_dirName [private]

directory name for L1Extra plots

Definition at line 183 of file L1ExtraDQM.h.

Referenced by beginRun(), and L1ExtraDQM().

Definition at line 214 of file L1ExtraDQM.h.

Referenced by analyzeL1ExtraCenJet(), beginRun(), endRun(), and L1ExtraDQM().

Definition at line 224 of file L1ExtraDQM.h.

Referenced by analyzeL1ExtraETM(), beginRun(), endRun(), and L1ExtraDQM().

Definition at line 221 of file L1ExtraDQM.h.

Referenced by analyzeL1ExtraETT(), beginRun(), endRun(), and L1ExtraDQM().

Definition at line 216 of file L1ExtraDQM.h.

Referenced by analyzeL1ExtraForJet(), beginRun(), endRun(), and L1ExtraDQM().

Definition at line 233 of file L1ExtraDQM.h.

Referenced by analyzeL1ExtraHfBitCounts(), beginRun(), endRun(), and L1ExtraDQM().

Definition at line 236 of file L1ExtraDQM.h.

Referenced by analyzeL1ExtraHfRingEtSums(), beginRun(), endRun(), and L1ExtraDQM().

Definition at line 230 of file L1ExtraDQM.h.

Referenced by analyzeL1ExtraHTM(), beginRun(), endRun(), and L1ExtraDQM().

Definition at line 227 of file L1ExtraDQM.h.

Referenced by analyzeL1ExtraHTT(), beginRun(), endRun(), and L1ExtraDQM().

Definition at line 209 of file L1ExtraDQM.h.

Referenced by analyzeL1ExtraIsoEG(), beginRun(), endRun(), and L1ExtraDQM().

pointers to L1ExtraMonElement for each sub-analysis

Definition at line 206 of file L1ExtraDQM.h.

Referenced by analyzeL1ExtraMuon(), beginRun(), endRun(), and L1ExtraDQM().

Definition at line 211 of file L1ExtraDQM.h.

Referenced by analyzeL1ExtraNoIsoEG(), beginRun(), endRun(), and L1ExtraDQM().

Definition at line 218 of file L1ExtraDQM.h.

Referenced by analyzeL1ExtraTauJet(), beginRun(), endRun(), and L1ExtraDQM().

number of bunch crosses in event to be monitored

Definition at line 186 of file L1ExtraDQM.h.

Referenced by analyzeL1ExtraMuon(), beginRun(), and L1ExtraDQM().

int L1ExtraDQM::m_nrEvJob [private]

Definition at line 197 of file L1ExtraDQM.h.

Referenced by analyze(), endJob(), and endRun().

int L1ExtraDQM::m_nrEvRun [private]

Definition at line 198 of file L1ExtraDQM.h.

Referenced by analyze(), beginRun(), and endRun().

bool L1ExtraDQM::m_resetModule [private]

Definition at line 193 of file L1ExtraDQM.h.