L1ExtraDQM Class Reference

#include <L1ExtraDQM.h>

Inheritance diagram for L1ExtraDQM:

Classes
class	L1ExtraMonElement

Public Member Functions
	L1ExtraDQM (const edm::ParameterSet &)
virtual	~L1ExtraDQM ()
Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzer ()
ModuleDescription const &	moduleDescription () const
std::string	workerType () const
virtual	~EDAnalyzer ()
Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()
ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

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
DQMStore *	m_dbe
	internal members More...
std::string	m_dirName
	directory name for L1Extra plots More...
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 More...
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 More...
int	m_nrEvJob
int	m_nrEvRun
bool	m_resetModule
L1RetrieveL1Extra	m_retrieveL1Extra
	input parameters More...

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &)
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 ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Description: online DQM module for L1Extra trigger objects.

Implementation: <TODO: enter implementation details>

Author

: Vasile Mihai Ghete - HEPHY Vienna

$Date$

Description: online DQM module for L1Extra trigger objects.

Implementation: <TODO: enter implementation details>

Author

: Vasile Mihai Ghete - HEPHY Vienna

Definition at line 73 of file L1ExtraDQM.h.

Constructor & Destructor Documentation

L1ExtraDQM::L1ExtraDQM ( const edm::ParameterSet &  paramSet )

explicit

Definition at line 29 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 97 of file L1ExtraDQM.cc.

                        {

    // empty

}

Member Function Documentation

void L1ExtraDQM::analyze ( const edm::Event &  iEvent, const edm::EventSetup &  evSetup  )

privatevirtual

Implements edm::EDAnalyzer.

Definition at line 809 of file L1ExtraDQM.cc.

References analyzeL1ExtraCenJet(), analyzeL1ExtraETM(), analyzeL1ExtraETT(), analyzeL1ExtraForJet(), analyzeL1ExtraHfBitCounts(), analyzeL1ExtraHfRingEtSums(), analyzeL1ExtraHTM(), analyzeL1ExtraHTT(), analyzeL1ExtraIsoEG(), analyzeL1ExtraMuon(), analyzeL1ExtraNoIsoEG(), analyzeL1ExtraTauJet(), m_nrEvJob, m_nrEvRun, m_retrieveL1Extra, and L1RetrieveL1Extra::retrieveL1ExtraObjects().

                                      {

    ++m_nrEvJob;
    ++m_nrEvRun;

    //
    m_retrieveL1Extra.retrieveL1ExtraObjects(iEvent, evSetup);
    //
    analyzeL1ExtraMuon(iEvent, evSetup);
    analyzeL1ExtraIsoEG(iEvent, evSetup);
    analyzeL1ExtraNoIsoEG(iEvent, evSetup);
    analyzeL1ExtraCenJet(iEvent, evSetup);
    analyzeL1ExtraForJet(iEvent, evSetup);
    analyzeL1ExtraTauJet(iEvent, evSetup);
    analyzeL1ExtraETT(iEvent, evSetup);
    analyzeL1ExtraETM(iEvent, evSetup);
    analyzeL1ExtraHTT(iEvent, evSetup);
    analyzeL1ExtraHTM(iEvent, evSetup);
    analyzeL1ExtraHfBitCounts(iEvent, evSetup);
    analyzeL1ExtraHfRingEtSums(iEvent, evSetup);
}

void L1ExtraDQM::analyzeL1ExtraCenJet ( const edm::Event &  iEvent, const edm::EventSetup &  evSetup  )

private

Definition at line 182 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 280 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 261 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 209 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 343 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 365 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 321 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 303 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 130 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 103 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 156 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 235 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  )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 388 of file L1ExtraDQM.cc.

                          {


}

void L1ExtraDQM::beginRun ( const edm::Run &  iRun, const edm::EventSetup &  evSetup  )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 394 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  )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 957 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  )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 833 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 193 of file L1ExtraDQM.h.

DQMStore* L1ExtraDQM::m_dbe

private

internal members

Definition at line 190 of file L1ExtraDQM.h.

Referenced by beginRun(), and L1ExtraDQM().

std::string L1ExtraDQM::m_dirName

private

directory name for L1Extra plots

Definition at line 182 of file L1ExtraDQM.h.

Referenced by beginRun(), and L1ExtraDQM().

std::vector<L1ExtraMonElement<l1extra::L1JetParticleCollection>*> L1ExtraDQM::m_meAnalysisL1ExtraCenJet

private

Definition at line 213 of file L1ExtraDQM.h.

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

std::vector<L1ExtraMonElement<l1extra::L1EtMissParticleCollection>*> L1ExtraDQM::m_meAnalysisL1ExtraETM

private

Definition at line 223 of file L1ExtraDQM.h.

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

std::vector<L1ExtraMonElement<l1extra::L1EtMissParticleCollection>*> L1ExtraDQM::m_meAnalysisL1ExtraETT

private

Definition at line 220 of file L1ExtraDQM.h.

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

std::vector<L1ExtraMonElement<l1extra::L1JetParticleCollection>*> L1ExtraDQM::m_meAnalysisL1ExtraForJet

private

Definition at line 215 of file L1ExtraDQM.h.

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

std::vector<L1ExtraMonElement<l1extra::L1HFRingsCollection>*> L1ExtraDQM::m_meAnalysisL1ExtraHfBitCounts

private

Definition at line 232 of file L1ExtraDQM.h.

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

std::vector<L1ExtraMonElement<l1extra::L1HFRingsCollection>*> L1ExtraDQM::m_meAnalysisL1ExtraHfRingEtSums

private

Definition at line 235 of file L1ExtraDQM.h.

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

std::vector<L1ExtraMonElement<l1extra::L1EtMissParticleCollection>*> L1ExtraDQM::m_meAnalysisL1ExtraHTM

private

Definition at line 229 of file L1ExtraDQM.h.

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

std::vector<L1ExtraMonElement<l1extra::L1EtMissParticleCollection>*> L1ExtraDQM::m_meAnalysisL1ExtraHTT

private

Definition at line 226 of file L1ExtraDQM.h.

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

std::vector<L1ExtraMonElement<l1extra::L1EmParticleCollection>*> L1ExtraDQM::m_meAnalysisL1ExtraIsoEG

private

Definition at line 208 of file L1ExtraDQM.h.

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

std::vector<L1ExtraMonElement<l1extra::L1MuonParticleCollection>*> L1ExtraDQM::m_meAnalysisL1ExtraMuon

private

pointers to L1ExtraMonElement for each sub-analysis

Definition at line 205 of file L1ExtraDQM.h.

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

std::vector<L1ExtraMonElement<l1extra::L1EmParticleCollection>*> L1ExtraDQM::m_meAnalysisL1ExtraNoIsoEG

private

Definition at line 210 of file L1ExtraDQM.h.

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

std::vector<L1ExtraMonElement<l1extra::L1JetParticleCollection>*> L1ExtraDQM::m_meAnalysisL1ExtraTauJet

private

Definition at line 217 of file L1ExtraDQM.h.

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

int L1ExtraDQM::m_nrBxInEventGct

private

Definition at line 186 of file L1ExtraDQM.h.

Referenced by analyzeL1ExtraCenJet(), analyzeL1ExtraETM(), analyzeL1ExtraETT(), analyzeL1ExtraForJet(), analyzeL1ExtraHfBitCounts(), analyzeL1ExtraHfRingEtSums(), analyzeL1ExtraHTM(), analyzeL1ExtraHTT(), analyzeL1ExtraIsoEG(), analyzeL1ExtraNoIsoEG(), analyzeL1ExtraTauJet(), beginRun(), and L1ExtraDQM().

int L1ExtraDQM::m_nrBxInEventGmt

private

number of bunch crosses in event to be monitored

Definition at line 185 of file L1ExtraDQM.h.

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

int L1ExtraDQM::m_nrEvJob

private

Definition at line 196 of file L1ExtraDQM.h.

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

int L1ExtraDQM::m_nrEvRun

private

Definition at line 197 of file L1ExtraDQM.h.

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

bool L1ExtraDQM::m_resetModule

private

Definition at line 192 of file L1ExtraDQM.h.

L1RetrieveL1Extra L1ExtraDQM::m_retrieveL1Extra

private

input parameters

Definition at line 179 of file L1ExtraDQM.h.

Referenced by analyze(), analyzeL1ExtraCenJet(), analyzeL1ExtraETM(), analyzeL1ExtraETT(), analyzeL1ExtraForJet(), analyzeL1ExtraHfBitCounts(), analyzeL1ExtraHfRingEtSums(), analyzeL1ExtraHTM(), analyzeL1ExtraHTT(), analyzeL1ExtraIsoEG(), analyzeL1ExtraMuon(), analyzeL1ExtraNoIsoEG(), and analyzeL1ExtraTauJet().