L1GtTrigReport Class Reference

#include <L1GtTrigReport.h>

Inheritance diagram for L1GtTrigReport:

Public Member Functions
	L1GtTrigReport (const edm::ParameterSet &)
	constructor More...
virtual	~L1GtTrigReport ()
	destructor More...
Public Member Functions inherited from edm::EDAnalyzer
	EDAnalyzer ()
std::string	workerType () const
virtual	~EDAnalyzer ()

Private Types
typedef std::list < L1GtTrigReportEntry * > ::const_iterator	CItEntry
typedef std::list < L1GtTrigReportEntry * > ::iterator	ItEntry

Private Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)
	analyze each event More...
virtual void	beginJob ()
virtual void	endJob ()
	end of job More...

Private Attributes
std::list< L1GtTrigReportEntry * >	m_entryList
	list of individual entries in the report for physics algorithms More...
std::list< L1GtTrigReportEntry * >	m_entryListTechTrig
	list of individual entries in the report for technical triggers More...
std::vector< int >	m_globalNrAccepts
	global number of events accepted by any of the L1 algorithm in any menu More...
std::vector< int >	m_globalNrErrors
	global number of events with error (EDProduct[s] not found) More...
const L1GtTriggerMenu *	m_l1GtMenu
unsigned long long	m_l1GtMenuCacheID
const L1GtPrescaleFactors *	m_l1GtPfAlgo
	prescale factors More...
unsigned long long	m_l1GtPfAlgoCacheID
const L1GtPrescaleFactors *	m_l1GtPfTech
unsigned long long	m_l1GtPfTechCacheID
edm::InputTag	m_l1GtRecordInputTag
	input tag for GT record (L1 GT DAQ record or L1 GT "lite" record): More...
const L1GtStableParameters *	m_l1GtStablePar
	cached stuff More...
unsigned long long	m_l1GtStableParCacheID
const L1GtTriggerMask *	m_l1GtTmAlgo
	trigger masks & veto masks More...
unsigned long long	m_l1GtTmAlgoCacheID
const L1GtTriggerMask *	m_l1GtTmTech
unsigned long long	m_l1GtTmTechCacheID
const L1GtTriggerMask *	m_l1GtTmVetoAlgo
unsigned long long	m_l1GtTmVetoAlgoCacheID
const L1GtTriggerMask *	m_l1GtTmVetoTech
unsigned long long	m_l1GtTmVetoTechCacheID
unsigned int	m_numberDaqPartitions
	number of DAQ partitions More...
unsigned int	m_numberDaqPartitionsMax
unsigned int	m_numberPhysTriggers
	number of physics triggers More...
unsigned int	m_numberTechnicalTriggers
	number of technical triggers More...
unsigned int	m_physicsDaqPartition
	index of physics DAQ partition More...
const std::vector< std::vector < int > > *	m_prescaleFactorsAlgoTrig
const std::vector< std::vector < int > > *	m_prescaleFactorsTechTrig
int	m_printOutput
	print output More...
int	m_printVerbosity
	print verbosity More...
int	m_totalEvents
	counters More...
std::vector< unsigned int >	m_triggerMaskAlgoTrig
std::vector< unsigned int >	m_triggerMaskTechTrig
std::vector< unsigned int >	m_triggerMaskVetoAlgoTrig
std::vector< unsigned int >	m_triggerMaskVetoTechTrig
bool	m_useL1GlobalTriggerRecord
	boolean flag to select the input record More...

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType
typedef WorkerT< EDAnalyzer >	WorkerType
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::EDAnalyzer
CurrentProcessingContext const *	currentContext () const

Detailed Description

Description: L1 Trigger report.

Implementation: <TODO: enter implementation details>

Author

: Vasile Mihai Ghete - HEPHY Vienna

$Date$ $Revision$

Definition at line 45 of file L1GtTrigReport.h.

Member Typedef Documentation

typedef std::list<L1GtTrigReportEntry*>::const_iterator L1GtTrigReport::CItEntry

private

Definition at line 149 of file L1GtTrigReport.h.

typedef std::list<L1GtTrigReportEntry*>::iterator L1GtTrigReport::ItEntry

private

Definition at line 150 of file L1GtTrigReport.h.

Constructor & Destructor Documentation

L1GtTrigReport::L1GtTrigReport ( const edm::ParameterSet &  pSet )

explicit

constructor

input tag for GT record (L1 GT DAQ record or L1 GT "lite" record):

Definition at line 72 of file L1GtTrigReport.cc.

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), LogDebug, m_entryList, m_entryListTechTrig, m_l1GtMenuCacheID, m_l1GtPfAlgoCacheID, m_l1GtPfTechCacheID, m_l1GtRecordInputTag, m_l1GtStableParCacheID, m_l1GtTmAlgoCacheID, m_l1GtTmTechCacheID, m_l1GtTmVetoAlgoCacheID, m_l1GtTmVetoTechCacheID, m_numberDaqPartitions, m_numberDaqPartitionsMax, m_numberPhysTriggers, m_numberTechnicalTriggers, m_physicsDaqPartition, m_printOutput, m_printVerbosity, m_totalEvents, and m_useL1GlobalTriggerRecord.

                                                          {

    // boolean flag to select the input record
    // if true, it will use L1GlobalTriggerRecord
    m_useL1GlobalTriggerRecord = pSet.getParameter<bool>("UseL1GlobalTriggerRecord");

    m_l1GtRecordInputTag = pSet.getParameter<edm::InputTag>("L1GtRecordInputTag");

    // print verbosity
    m_printVerbosity = pSet.getUntrackedParameter<int>("PrintVerbosity", 2);

    // print output
    m_printOutput = pSet.getUntrackedParameter<int>("PrintOutput", 3);

    LogDebug("L1GtTrigReport") << "\n  Use L1GlobalTriggerRecord:   " << m_useL1GlobalTriggerRecord
            << "\n   (if false: L1GtTrigReport uses L1GlobalTriggerReadoutRecord.)"
            << "\n  Input tag for L1 GT record:  " << m_l1GtRecordInputTag.label() << " \n"
            << "\n  Print verbosity level:           " << m_printVerbosity << " \n"
            << "\n  Print output:                    " << m_printOutput << " \n" << std::endl;

    // initialize cached IDs

    //
    m_l1GtStableParCacheID = 0ULL;

    m_numberPhysTriggers = 0;
    m_numberTechnicalTriggers = 0;
    m_numberDaqPartitions = 0;
    m_numberDaqPartitionsMax = 0;

    //
    m_l1GtPfAlgoCacheID = 0ULL;
    m_l1GtPfTechCacheID = 0ULL;

    m_l1GtTmAlgoCacheID = 0ULL;
    m_l1GtTmTechCacheID = 0ULL;

    m_l1GtTmVetoAlgoCacheID = 0ULL;
    m_l1GtTmVetoTechCacheID = 0ULL;

    //
    m_l1GtMenuCacheID = 0ULL;

    // initialize global counters

    // number of events processed
    m_totalEvents = 0;

    //
    m_entryList.clear();
    m_entryListTechTrig.clear();

    // set the index of physics DAQ partition TODO input parameter?
    m_physicsDaqPartition = 0;

}

L1GtTrigReport::~L1GtTrigReport ( )

virtual

destructor

Definition at line 131 of file L1GtTrigReport.cc.

References m_entryList, and m_entryListTechTrig.

                                {

    for (ItEntry itEntry = m_entryList.begin(); itEntry != m_entryList.end(); itEntry++) {
        if (*itEntry != 0) {
            delete *itEntry;
            *itEntry = 0;
        }
    }

    m_entryList.clear();

    for (ItEntry itEntry = m_entryListTechTrig.begin(); itEntry != m_entryListTechTrig.end(); itEntry++) {
        if (*itEntry != 0) {
            delete *itEntry;
            *itEntry = 0;
        }
    }

    m_entryListTechTrig.clear();

}

Member Function Documentation

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

privatevirtual

analyze each event

Implements edm::EDAnalyzer.

Definition at line 164 of file L1GtTrigReport.cc.

References L1GtTrigReportEntry::addErrorEntry(), L1GtTrigReportEntry::addValidEntry(), edm::EventSetup::get(), edm::Event::getByLabel(), L1GtTriggerMenu::gtAlgorithmMap(), L1GtStableParameters::gtNumberPhysTriggers(), L1GtStableParameters::gtNumberTechnicalTriggers(), L1GtPrescaleFactors::gtPrescaleFactors(), L1GtTriggerMask::gtTriggerMask(), L1GtTriggerMenu::gtTriggerMenuName(), edm::HandleBase::isValid(), edm::InputTag::label(), LogDebug, m_entryList, m_entryListTechTrig, m_globalNrAccepts, m_globalNrErrors, m_l1GtMenu, m_l1GtMenuCacheID, m_l1GtPfAlgo, m_l1GtPfAlgoCacheID, m_l1GtPfTech, m_l1GtPfTechCacheID, m_l1GtRecordInputTag, m_l1GtStablePar, m_l1GtStableParCacheID, m_l1GtTmAlgo, m_l1GtTmAlgoCacheID, m_l1GtTmTech, m_l1GtTmTechCacheID, m_l1GtTmVetoAlgo, m_l1GtTmVetoAlgoCacheID, m_l1GtTmVetoTech, m_l1GtTmVetoTechCacheID, m_numberDaqPartitions, m_numberDaqPartitionsMax, m_numberPhysTriggers, m_numberTechnicalTriggers, m_physicsDaqPartition, m_prescaleFactorsAlgoTrig, m_prescaleFactorsTechTrig, m_totalEvents, m_triggerMaskAlgoTrig, m_triggerMaskTechTrig, m_triggerMaskVetoAlgoTrig, m_triggerMaskVetoTechTrig, m_useL1GlobalTriggerRecord, dtDQMClient_cfg::prescaleFactor, and edm::ESHandle< class >::product().

                                                                                 {

    // increase the number of processed events
    m_totalEvents++;

    // get / update the stable parameters from the EventSetup
    // local cache & check on cacheIdentifier

    unsigned long long l1GtStableParCacheID =
            evSetup.get<L1GtStableParametersRcd>().cacheIdentifier();

    if (m_l1GtStableParCacheID != l1GtStableParCacheID) {

        edm::ESHandle<L1GtStableParameters> l1GtStablePar;
        evSetup.get<L1GtStableParametersRcd>().get(l1GtStablePar);
        m_l1GtStablePar = l1GtStablePar.product();

        // number of physics triggers
        m_numberPhysTriggers = m_l1GtStablePar->gtNumberPhysTriggers();

        // number of technical triggers
        m_numberTechnicalTriggers = m_l1GtStablePar->gtNumberTechnicalTriggers();

        // number of DAQ partitions
        m_numberDaqPartitions = 8; // FIXME add it to stable parameters

        if (m_numberDaqPartitionsMax < m_numberDaqPartitions) {

            int numberDaqPartitionsOld = m_numberDaqPartitionsMax;
            m_numberDaqPartitionsMax = m_numberDaqPartitions;

            m_globalNrErrors.reserve(m_numberDaqPartitionsMax);
            m_globalNrAccepts.reserve(m_numberDaqPartitionsMax);

            for (unsigned int iDaq = numberDaqPartitionsOld; iDaq < m_numberDaqPartitionsMax; ++iDaq) {

                m_globalNrErrors.push_back(0);
                m_globalNrAccepts.push_back(0);

            }

        }

        //
        m_l1GtStableParCacheID = l1GtStableParCacheID;

    }

    // get / update the prescale factors from the EventSetup
    // local cache & check on cacheIdentifier

    unsigned long long l1GtPfAlgoCacheID =
            evSetup.get<L1GtPrescaleFactorsAlgoTrigRcd>().cacheIdentifier();

    if (m_l1GtPfAlgoCacheID != l1GtPfAlgoCacheID) {

        edm::ESHandle<L1GtPrescaleFactors> l1GtPfAlgo;
        evSetup.get<L1GtPrescaleFactorsAlgoTrigRcd>().get(l1GtPfAlgo);
        m_l1GtPfAlgo = l1GtPfAlgo.product();

        m_prescaleFactorsAlgoTrig = & ( m_l1GtPfAlgo->gtPrescaleFactors() );

        m_l1GtPfAlgoCacheID = l1GtPfAlgoCacheID;

    }

    unsigned long long l1GtPfTechCacheID =
            evSetup.get<L1GtPrescaleFactorsTechTrigRcd>().cacheIdentifier();

    if (m_l1GtPfTechCacheID != l1GtPfTechCacheID) {

        edm::ESHandle<L1GtPrescaleFactors> l1GtPfTech;
        evSetup.get<L1GtPrescaleFactorsTechTrigRcd>().get(l1GtPfTech);
        m_l1GtPfTech = l1GtPfTech.product();

        m_prescaleFactorsTechTrig = & ( m_l1GtPfTech->gtPrescaleFactors() );

        m_l1GtPfTechCacheID = l1GtPfTechCacheID;

    }

    // get / update the trigger mask from the EventSetup
    // local cache & check on cacheIdentifier

    unsigned long long l1GtTmAlgoCacheID =
            evSetup.get<L1GtTriggerMaskAlgoTrigRcd>().cacheIdentifier();

    if (m_l1GtTmAlgoCacheID != l1GtTmAlgoCacheID) {

        edm::ESHandle<L1GtTriggerMask> l1GtTmAlgo;
        evSetup.get<L1GtTriggerMaskAlgoTrigRcd>().get(l1GtTmAlgo);
        m_l1GtTmAlgo = l1GtTmAlgo.product();

        m_triggerMaskAlgoTrig = m_l1GtTmAlgo->gtTriggerMask();

        m_l1GtTmAlgoCacheID = l1GtTmAlgoCacheID;

    }

    unsigned long long l1GtTmTechCacheID =
            evSetup.get<L1GtTriggerMaskTechTrigRcd>().cacheIdentifier();

    if (m_l1GtTmTechCacheID != l1GtTmTechCacheID) {

        edm::ESHandle<L1GtTriggerMask> l1GtTmTech;
        evSetup.get<L1GtTriggerMaskTechTrigRcd>().get(l1GtTmTech);
        m_l1GtTmTech = l1GtTmTech.product();

        m_triggerMaskTechTrig = m_l1GtTmTech->gtTriggerMask();

        m_l1GtTmTechCacheID = l1GtTmTechCacheID;

    }

    unsigned long long l1GtTmVetoAlgoCacheID =
            evSetup.get<L1GtTriggerMaskVetoAlgoTrigRcd>().cacheIdentifier();

    if (m_l1GtTmVetoAlgoCacheID != l1GtTmVetoAlgoCacheID) {

        edm::ESHandle<L1GtTriggerMask> l1GtTmVetoAlgo;
        evSetup.get<L1GtTriggerMaskVetoAlgoTrigRcd>().get(l1GtTmVetoAlgo);
        m_l1GtTmVetoAlgo = l1GtTmVetoAlgo.product();

        m_triggerMaskVetoAlgoTrig = m_l1GtTmVetoAlgo->gtTriggerMask();

        m_l1GtTmVetoAlgoCacheID = l1GtTmVetoAlgoCacheID;

    }

    unsigned long long l1GtTmVetoTechCacheID =
            evSetup.get<L1GtTriggerMaskVetoTechTrigRcd>().cacheIdentifier();

    if (m_l1GtTmVetoTechCacheID != l1GtTmVetoTechCacheID) {

        edm::ESHandle<L1GtTriggerMask> l1GtTmVetoTech;
        evSetup.get<L1GtTriggerMaskVetoTechTrigRcd>().get(l1GtTmVetoTech);
        m_l1GtTmVetoTech = l1GtTmVetoTech.product();

        m_triggerMaskVetoTechTrig = m_l1GtTmVetoTech->gtTriggerMask();

        m_l1GtTmVetoTechCacheID = l1GtTmVetoTechCacheID;

    }

    // get / update the trigger menu from the EventSetup
    // local cache & check on cacheIdentifier

    unsigned long long l1GtMenuCacheID =
            evSetup.get<L1GtTriggerMenuRcd>().cacheIdentifier();

    if (m_l1GtMenuCacheID != l1GtMenuCacheID) {

        edm::ESHandle<L1GtTriggerMenu> l1GtMenu;
        evSetup.get<L1GtTriggerMenuRcd>().get(l1GtMenu);
        m_l1GtMenu = l1GtMenu.product();

        m_l1GtMenuCacheID = l1GtMenuCacheID;

        LogDebug("L1GtTrigReport") << "\n  Changing L1 menu to : \n"
                << m_l1GtMenu->gtTriggerMenuName() << "\n\n" << std::endl;

    }


    const AlgorithmMap& algorithmMap = m_l1GtMenu->gtAlgorithmMap();
    //const AlgorithmMap& technicalTriggerMap = m_l1GtMenu->gtTechnicalTriggerMap();

    const std::string& menuName = m_l1GtMenu->gtTriggerMenuName();

    // ... end EventSetup

    // get L1GlobalTriggerReadoutRecord or L1GlobalTriggerRecord
    // in L1GlobalTriggerRecord, only the physics partition is available
    edm::Handle<L1GlobalTriggerReadoutRecord> gtReadoutRecord;
    edm::Handle<L1GlobalTriggerRecord> gtRecord;

    if (m_useL1GlobalTriggerRecord) {
        iEvent.getByLabel(m_l1GtRecordInputTag, gtRecord);
    } else {
        iEvent.getByLabel(m_l1GtRecordInputTag, gtReadoutRecord);
    }

    bool validRecord = false;

    unsigned int pfIndexAlgo = 0; // get them later from the record
    unsigned int pfIndexTech = 0;

    DecisionWord gtDecisionWordBeforeMask;
    DecisionWord gtDecisionWordAfterMask;

    TechnicalTriggerWord technicalTriggerWordBeforeMask;
    TechnicalTriggerWord technicalTriggerWordAfterMask;

    if (m_useL1GlobalTriggerRecord) {

        if (gtRecord.isValid()) {

            // get Global Trigger decision and the decision word
            bool gtDecision = gtRecord->decision();

            gtDecisionWordBeforeMask = gtRecord->decisionWordBeforeMask();
            gtDecisionWordAfterMask = gtRecord->decisionWord();

            technicalTriggerWordBeforeMask = gtRecord->technicalTriggerWordBeforeMask();
            technicalTriggerWordAfterMask = gtRecord->technicalTriggerWord();

            if (gtDecision) {
                m_globalNrAccepts[m_physicsDaqPartition]++;
            }

            pfIndexAlgo = gtRecord->gtPrescaleFactorIndexAlgo();
            pfIndexTech = gtRecord->gtPrescaleFactorIndexTech();

            validRecord = true;

        } else {

            m_globalNrErrors[m_physicsDaqPartition]++;

            edm::LogWarning("L1GtTrigReport") << "\n  L1GlobalTriggerRecord with input tag "
                    << m_l1GtRecordInputTag.label() << " not found."
                    << "\n  Event classified as Error\n\n"
                    << std::endl;

        }

    } else {
        if (gtReadoutRecord.isValid()) {

            // check if the readout record has size greater than zero, then proceeds
            const std::vector<L1GtFdlWord>& fdlVec = gtReadoutRecord->gtFdlVector();
            size_t fdlVecSize = fdlVec.size();

            if (fdlVecSize > 0) {

                LogDebug("L1GtTrigReport") << "\n  L1GlobalTriggerReadoutRecord with input tag "
                        << m_l1GtRecordInputTag.label() << " has gtFdlVector of size " << fdlVecSize
                        << std::endl;

                // get Global Trigger finalOR and the decision word
                boost::uint16_t gtFinalOR = gtReadoutRecord->finalOR();

                gtDecisionWordBeforeMask = gtReadoutRecord->decisionWord();
                technicalTriggerWordBeforeMask = gtReadoutRecord->technicalTriggerWord();

                for (unsigned int iDaqPartition = 0; iDaqPartition < m_numberDaqPartitions; ++iDaqPartition) {

                    bool gtDecision = static_cast<bool>(gtFinalOR & ( 1 << iDaqPartition ));
                    if (gtDecision) {
                        m_globalNrAccepts[iDaqPartition]++;
                    }

                }

                pfIndexAlgo
                        = static_cast<unsigned int>( ( gtReadoutRecord->gtFdlWord() ).gtPrescaleFactorIndexAlgo());
                pfIndexTech
                        = static_cast<unsigned int>( ( gtReadoutRecord->gtFdlWord() ).gtPrescaleFactorIndexTech());

                validRecord = true;

            } else {

                for (unsigned int iDaqPartition = 0; iDaqPartition < m_numberDaqPartitions; ++iDaqPartition) {
                    m_globalNrErrors[iDaqPartition]++;
                }

                edm::LogWarning("L1GtTrigReport") << "\n  L1GlobalTriggerReadoutRecord with input tag "
                        << m_l1GtRecordInputTag.label() << " has gtFdlVector of size " << fdlVecSize
                        << "\n  Invalid L1GlobalTriggerReadoutRecord!"
                        << "\n  Event classified as Error\n\n"
                        << std::endl;

                validRecord = false;

            }

        } else {

            for (unsigned int iDaqPartition = 0; iDaqPartition < m_numberDaqPartitions; ++iDaqPartition) {
                m_globalNrErrors[iDaqPartition]++;
            }

            edm::LogWarning("L1GtTrigReport") << "\n  L1GlobalTriggerReadoutRecord with input tag "
                    << m_l1GtRecordInputTag.label() << " not found."
                    << "\n  Event classified as Error\n\n"
                    << std::endl;

        }

    }

    // get the prescale factor set used in the actual luminosity segment
    const std::vector<int>& prescaleFactorsAlgoTrig =
            ( *m_prescaleFactorsAlgoTrig ).at(pfIndexAlgo);

    const std::vector<int>& prescaleFactorsTechTrig =
            ( *m_prescaleFactorsTechTrig ).at(pfIndexTech);


    if (validRecord) {

        // loop over algorithms and increase the corresponding counters
        for (CItAlgo itAlgo = algorithmMap.begin(); itAlgo != algorithmMap.end(); itAlgo++) {

            std::string algName = itAlgo->first;
            int algBitNumber = ( itAlgo->second ).algoBitNumber();

            // the result before applying the trigger masks is available
            // in both L1GlobalTriggerReadoutRecord or L1GlobalTriggerRecord
            bool algResultBeforeMask = gtDecisionWordBeforeMask[algBitNumber];

            int prescaleFactor = prescaleFactorsAlgoTrig.at(algBitNumber);

            for (unsigned int iDaqPartition = 0; iDaqPartition < m_numberDaqPartitions; ++iDaqPartition) {

                unsigned int triggerMask = ( m_triggerMaskAlgoTrig.at(algBitNumber) ) & ( 1
                        << iDaqPartition );

                bool algResultAfterMask = false;

                if (m_useL1GlobalTriggerRecord) {
                    if (iDaqPartition == m_physicsDaqPartition) {
                        // result available already for physics DAQ partition
                        // in lite record
                        algResultAfterMask = gtDecisionWordAfterMask[algBitNumber];
                    } else {
                        // apply the masks for other partitions
                        algResultAfterMask = algResultBeforeMask;

                        if (triggerMask) {
                            algResultAfterMask = false;
                        }
                    }
                } else {
                    // apply the masks for L1GlobalTriggerReadoutRecord
                    algResultAfterMask = algResultBeforeMask;

                    if (triggerMask) {
                        algResultAfterMask = false;
                    }
                }

                L1GtTrigReportEntry* entryRep = new L1GtTrigReportEntry(
                        menuName, algName, prescaleFactor, triggerMask, iDaqPartition);

                int iCount = 0;

                for (CItEntry itEntry = m_entryList.begin(); itEntry != m_entryList.end(); itEntry++) {
                    if ( ( *entryRep ) == * ( *itEntry )) {
                        iCount++;
                        // increase the corresponding counter in the list entry
                        ( *itEntry )->addValidEntry(algResultAfterMask, algResultBeforeMask);
                    }
                }

                if (iCount == 0) {
                    // if entry not in the list, increase the corresponding counter
                    // and push the entry in the list
                    entryRep->addValidEntry(algResultAfterMask, algResultBeforeMask);
                    m_entryList.push_back(entryRep);
                } else {
                    delete entryRep;
                }
            }
        }

        // loop over technical triggers and increase the corresponding counters
        // FIXME move to names when technical triggers available in menu
        //for (CItAlgo itAlgo = technicalTriggerMap.begin(); itAlgo != technicalTriggerMap.end(); itAlgo++) {
        for (unsigned int iTechTrig = 0; iTechTrig < m_numberTechnicalTriggers; ++iTechTrig) {

            //std::string ttName = itAlgo->first;
            //int ttBitNumber = ( itAlgo->second ).algoBitNumber();
            std::string ttName = boost::lexical_cast<std::string>(iTechTrig);
            int ttBitNumber = iTechTrig;

            // the result before applying the trigger masks is available
            // in both L1GlobalTriggerReadoutRecord or L1GlobalTriggerRecord
            bool ttResultBeforeMask = technicalTriggerWordBeforeMask[ttBitNumber];

            int prescaleFactor = prescaleFactorsTechTrig.at(ttBitNumber);

            for (unsigned int iDaqPartition = 0; iDaqPartition < m_numberDaqPartitions; ++iDaqPartition) {

                unsigned int triggerMask = ( m_triggerMaskTechTrig.at(ttBitNumber) ) & ( 1
                        << iDaqPartition );

                bool ttResultAfterMask = false;

                if (m_useL1GlobalTriggerRecord) {
                    if (iDaqPartition == m_physicsDaqPartition) {
                        // result available already for physics DAQ partition
                        // in lite record
                        ttResultAfterMask = technicalTriggerWordAfterMask[ttBitNumber];
                    } else {
                        // apply the masks for other partitions
                        ttResultAfterMask = ttResultBeforeMask;

                        if (triggerMask) {
                            ttResultAfterMask = false;
                        }
                    }
                } else {
                    // apply the masks for L1GlobalTriggerReadoutRecord
                    ttResultAfterMask = ttResultBeforeMask;

                    if (triggerMask) {
                        ttResultAfterMask = false;
                    }
                }

                L1GtTrigReportEntry* entryRep = new L1GtTrigReportEntry(
                        menuName, ttName, prescaleFactor, triggerMask, iDaqPartition);

                int iCount = 0;

                for (CItEntry itEntry = m_entryListTechTrig.begin(); itEntry
                        != m_entryListTechTrig.end(); itEntry++) {
                    if ( ( *entryRep ) == * ( *itEntry )) {
                        iCount++;
                        // increase the corresponding counter in the list entry
                        ( *itEntry )->addValidEntry(ttResultAfterMask, ttResultBeforeMask);
                    }
                }

                if (iCount == 0) {
                    // if entry not in the list, increase the corresponding counter
                    // and push the entry in the list
                    entryRep->addValidEntry(ttResultAfterMask, ttResultBeforeMask);
                    m_entryListTechTrig.push_back(entryRep);
                } else {
                    delete entryRep;
                }
            }
        }

    } else {

        // loop over algorithms and increase the error counters
        for (CItAlgo itAlgo = algorithmMap.begin(); itAlgo != algorithmMap.end(); itAlgo++) {

            std::string algName = itAlgo->first;
            int algBitNumber = ( itAlgo->second ).algoBitNumber();

            int prescaleFactor = prescaleFactorsAlgoTrig.at(algBitNumber);

            for (unsigned int iDaqPartition = 0; iDaqPartition < m_numberDaqPartitions; ++iDaqPartition) {

                unsigned int triggerMask = ( m_triggerMaskAlgoTrig.at(algBitNumber) ) & ( 1
                        << iDaqPartition );

                L1GtTrigReportEntry* entryRep = new L1GtTrigReportEntry(
                        menuName, algName, prescaleFactor, triggerMask, iDaqPartition);

                int iCount = 0;

                for (CItEntry itEntry = m_entryList.begin(); itEntry != m_entryList.end(); itEntry++) {

                    if ( ( *entryRep ) == * ( *itEntry )) {
                        iCount++;
                        // increase the corresponding counter in the list entry
                        ( *itEntry )->addErrorEntry();
                    }
                }

                if (iCount == 0) {
                    // if entry not in the list, increase the corresponding counter
                    // and push the entry in the list
                    entryRep->addErrorEntry();
                    m_entryList.push_back(entryRep);
                } else {
                    delete entryRep;
                }
            }

        }

        // loop over technical triggers and increase the error counters
        // FIXME move to names when technical triggers available in menu
        //for (CItAlgo itAlgo = technicalTriggerMap.begin(); itAlgo != technicalTriggerMap.end(); itAlgo++) {
        for (unsigned int iTechTrig = 0; iTechTrig < m_numberTechnicalTriggers; ++iTechTrig) {

            //std::string ttName = itAlgo->first;
            //int ttBitNumber = ( itAlgo->second ).algoBitNumber();
            std::string ttName = boost::lexical_cast<std::string>(iTechTrig);
            int ttBitNumber = iTechTrig;

            int prescaleFactor = prescaleFactorsTechTrig.at(ttBitNumber);

            for (unsigned int iDaqPartition = 0; iDaqPartition < m_numberDaqPartitions; ++iDaqPartition) {

                unsigned int triggerMask = ( m_triggerMaskTechTrig.at(ttBitNumber) ) & ( 1
                        << iDaqPartition );

                L1GtTrigReportEntry* entryRep = new L1GtTrigReportEntry(
                        menuName, ttName, prescaleFactor, triggerMask, iDaqPartition);

                int iCount = 0;

                for (CItEntry itEntry = m_entryListTechTrig.begin(); itEntry
                        != m_entryListTechTrig.end(); itEntry++) {

                    if ( ( *entryRep ) == * ( *itEntry )) {
                        iCount++;
                        // increase the corresponding counter in the list entry
                        ( *itEntry )->addErrorEntry();
                    }
                }

                if (iCount == 0) {
                    // if entry not in the list, increase the corresponding counter
                    // and push the entry in the list
                    entryRep->addErrorEntry();
                    m_entryListTechTrig.push_back(entryRep);
                } else {
                    delete entryRep;
                }
            }

        }

    }

}

void L1GtTrigReport::beginJob ( void  )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 157 of file L1GtTrigReport.cc.

                              {

    // empty

}

void L1GtTrigReport::endJob ( void  )

privatevirtual

end of job

Reimplemented from edm::EDAnalyzer.

Definition at line 691 of file L1GtTrigReport.cc.

References gather_cfg::cout, LogTrace, m_entryList, m_entryListTechTrig, m_globalNrAccepts, m_globalNrErrors, m_numberDaqPartitions, m_physicsDaqPartition, m_printOutput, m_printVerbosity, m_totalEvents, m_useL1GlobalTriggerRecord, and mathSSE::sqrt().

                            {

    // define an output stream to print into
    // it can then be directed to whatever log level is desired
    std::ostringstream myCout;

    myCout << std::dec << std::endl;
    myCout << "L1T-Report " << "----------       Event Summary       ----------\n";
    myCout << "L1T-Report " << "Total number of events processed: " << m_totalEvents << "\n";
    myCout << "L1T-Report\n";

    myCout
        << "\n"
        << "   DAQ partition "
        << "           Total "
        << " Passed[finalOR] "
        << "        Rejected "
        << "          Errors "
        << "\n" << std::endl;

    for (unsigned int iDaqPartition = 0; iDaqPartition < m_numberDaqPartitions; ++iDaqPartition) {

        int rejectedEvents = m_totalEvents - m_globalNrErrors[iDaqPartition]
                - m_globalNrAccepts[iDaqPartition];

        if (m_useL1GlobalTriggerRecord && ( iDaqPartition != m_physicsDaqPartition )) {
            continue;
        } else {

            myCout
                << std::right << std::setw(16) << iDaqPartition << " "
                << std::right << std::setw(16) << m_totalEvents << " "
                << std::right << std::setw(16) << m_globalNrAccepts[iDaqPartition] << " "
                << std::right << std::setw(16) << rejectedEvents << " "
                << std::right << std::setw(16) << m_globalNrErrors[iDaqPartition] << std::endl;

        }

    }

    switch (m_printVerbosity) {
        case 0: {

            myCout
                << "\nL1T-Report " << "---------- L1 Trigger Global Summary - DAQ Partition "
                << m_physicsDaqPartition << "----------\n\n";

            myCout
                << "\n\n Number of events written after applying L1 prescale factors"
                << " and trigger masks\n" << " if not explicitly mentioned.\n\n";

            myCout
                << std::right << std::setw(35) << "Algorithm Key" << " "
                << std::right << std::setw(10) << "Passed" << " "
                << std::right << std::setw(10) << "Rejected" << " "
                << std::right << std::setw(10) << "Error" << std::setw(2) << " "
                << std::right << std::setw(20) << "Trigger Menu Key"
                << "\n";

            for (CItEntry itEntry = m_entryList.begin(); itEntry != m_entryList.end(); itEntry++) {

                if ( ( *itEntry )->gtDaqPartition() == m_physicsDaqPartition) {

                    myCout
                        << std::right << std::setw(35) << ( *itEntry )->gtAlgoName() << " "
                        << std::right << std::setw(10) << ( *itEntry )->gtNrEventsAccept() << " "
                        << std::right << std::setw(10) << ( *itEntry )->gtNrEventsReject() << " "
                        << std::right << std::setw(10) << ( *itEntry )->gtNrEventsError() << std::setw(2) << " "
                        << std::right << std::setw(20) << ( *itEntry )->gtTriggerMenuName()
                        << "\n";
                }

            }

            myCout
                << "\n\n"
                << std::right << std::setw(35) << "Technical Trigger Key" << " "
                << std::right << std::setw(10) << "Passed" << " "
                << std::right << std::setw(10) << "Rejected" << " "
                << std::right << std::setw(10) << "Error" << std::setw(2) << " "
                << std::right << std::setw(20) << "Trigger Menu Key"
                << "\n";

            for (CItEntry itEntry = m_entryListTechTrig.begin(); itEntry
                    != m_entryListTechTrig.end(); itEntry++) {

                if ( ( *itEntry )->gtDaqPartition() == m_physicsDaqPartition) {

                    myCout
                        << std::right << std::setw(35) << ( *itEntry )->gtAlgoName() << " "
                        << std::right << std::setw(10) << ( *itEntry )->gtNrEventsAccept() << " "
                        << std::right << std::setw(10) << ( *itEntry )->gtNrEventsReject() << " "
                        << std::right << std::setw(10) << ( *itEntry )->gtNrEventsError() << std::setw(2) << " "
                        << std::right << std::setw(20) << ( *itEntry )->gtTriggerMenuName()
                        << "\n";
                }

            }

        }

            break;
        case 1: {

            myCout << "\nL1T-Report " << "---------- L1 Trigger Global Summary - DAQ Partition "
                    << m_physicsDaqPartition << "----------\n\n";

            myCout << "\n\n Number of events written after applying L1 prescale factors"
                    << " and trigger masks\n" << " if not explicitly mentioned.\n\n";

            myCout
                << std::right << std::setw(35) << "Algorithm Key" << " "
                << std::right << std::setw(10) << "Prescale" << " "
                << std::right << std::setw(5)  << "Mask" << " "
                << std::right << std::setw(10) << "Passed" << " "
                << std::right << std::setw(10) << "Rejected" << " "
                << std::right << std::setw(10) << "Error" << std::setw(2) << " "
                << std::right << std::setw(20) << "Trigger Menu Key"
                << "\n";

            for (CItEntry itEntry = m_entryList.begin(); itEntry != m_entryList.end(); itEntry++) {

                if ( ( *itEntry )->gtDaqPartition() == m_physicsDaqPartition) {
                    myCout
                        << std::right << std::setw(35) << ( *itEntry )->gtAlgoName() << " "
                        << std::right << std::setw(10) << ( *itEntry )->gtPrescaleFactor() << "    "
                        << std::right << std::setw(2) //<< std::setfill('0')
                        << std::hex << ( *itEntry )->gtTriggerMask() //<< std::setfill(' ')
                        << std::dec << " "
                        << std::right << std::setw(10) << ( *itEntry )->gtNrEventsAccept() << " "
                        << std::right << std::setw(10) << ( *itEntry )->gtNrEventsReject() << " "
                        << std::right << std::setw(10) << ( *itEntry )->gtNrEventsError() << std::setw(2) << " "
                        << std::right << std::setw(20) << ( *itEntry )->gtTriggerMenuName()
                        << "\n";
                }
            }

            myCout
                << "\n\n"
                << std::right << std::setw(35) << "Technical Trigger Key" << " "
                << std::right << std::setw(10) << "Prescale" << " "
                << std::right << std::setw(5)  << "Mask" << " "
                << std::right << std::setw(10) << "Passed" << " "
                << std::right << std::setw(10) << "Rejected" << " "
                << std::right << std::setw(10) << "Error" << std::setw(2) << " "
                << std::right << std::setw(20) << "Trigger Menu Key"
                << "\n";

            for (CItEntry itEntry = m_entryListTechTrig.begin(); itEntry != m_entryListTechTrig.end(); itEntry++) {

                if ( ( *itEntry )->gtDaqPartition() == m_physicsDaqPartition) {
                    myCout
                        << std::right << std::setw(35) << ( *itEntry )->gtAlgoName() << " "
                        << std::right << std::setw(10) << ( *itEntry )->gtPrescaleFactor() << "    "
                        << std::right << std::setw(2) //<< std::setfill('0')
                        << std::hex << ( *itEntry )->gtTriggerMask() //<< std::setfill(' ')
                        << std::dec << " "
                        << std::right << std::setw(10) << ( *itEntry )->gtNrEventsAccept() << " "
                        << std::right << std::setw(10) << ( *itEntry )->gtNrEventsReject() << " "
                        << std::right << std::setw(10) << ( *itEntry )->gtNrEventsError() << std::setw(2) << " "
                        << std::right << std::setw(20) << ( *itEntry )->gtTriggerMenuName()
                        << "\n";
                }
            }

        }

            break;
        case 2: {

            // get the list of menus for the sample analyzed
            //
            std::set<std::string> menuList;
            typedef std::set<std::string>::const_iterator CItL1Menu;

            for (CItEntry itEntry = m_entryList.begin(); itEntry != m_entryList.end(); itEntry++) {
                menuList.insert( ( *itEntry )->gtTriggerMenuName());
            }

            myCout
                    << "\nThe following L1 menus were used for this sample: " << std::endl;
            for (CItL1Menu itMenu = menuList.begin(); itMenu != menuList.end(); itMenu++) {
                myCout << "  " << ( *itMenu ) << std::endl;
            }
            myCout << "\n" << std::endl;

            for (CItL1Menu itMenu = menuList.begin(); itMenu != menuList.end(); itMenu++) {

                myCout << "Report for L1 menu:  " << ( *itMenu ) << "\n"
                        << std::endl;

                myCout
                    << std::right << std::setw(35) << "Algorithm Key" << " "
                    << std::right << std::setw(10) << "Passed" << " "
                    << std::right << std::setw(10) << "Rejected" << " "
                    << std::right << std::setw(10) << "Error" << "\n";

                for (CItEntry itEntry = m_entryList.begin(); itEntry != m_entryList.end(); itEntry++) {

                    if ( ( ( *itEntry )->gtDaqPartition() == m_physicsDaqPartition )
                            && ( ( *itEntry )->gtTriggerMenuName() == *itMenu )) {

                        int nrEventsAccept = ( *itEntry )->gtNrEventsAccept();
                        int nrEventsReject = ( *itEntry )->gtNrEventsReject();
                        int nrEventsError = ( *itEntry )->gtNrEventsError();

                        myCout
                            << std::right << std::setw(35) << (( *itEntry )->gtAlgoName()) << " "
                            << std::right << std::setw(10) << nrEventsAccept << " "
                            << std::right << std::setw(10) << nrEventsReject << " "
                            << std::right << std::setw(10) << nrEventsError << "\n";

                    }
                }

                // efficiency and its statistical error

                myCout << "\n\n"
                    << std::right << std::setw(35) << "Algorithm Key" << "    "
                    << std::right << std::setw(10) << "Efficiency " << " "
                    << std::right << std::setw(10) << "Stat error (%)" << "\n";

                for (CItEntry itEntry = m_entryList.begin(); itEntry != m_entryList.end(); itEntry++) {

                    if ( ( ( *itEntry )->gtDaqPartition() == 0 ) && ( ( *itEntry )->gtTriggerMenuName()
                            == *itMenu )) {

                        int nrEventsAccept = ( *itEntry )->gtNrEventsAccept();
                        int nrEventsReject = ( *itEntry )->gtNrEventsReject();
                        int nrEventsError = ( *itEntry )->gtNrEventsError();

                        int totalEvents = nrEventsAccept + nrEventsReject + nrEventsError;

                        // efficiency and their statistical error
                        float eff = 0.;
                        float statErrEff = 0.;

                        if (totalEvents != 0) {
                            eff = static_cast<float> (nrEventsAccept)
                                    / static_cast<float> (totalEvents);
                            statErrEff = sqrt(eff * ( 1.0 - eff )
                                    / static_cast<float> (totalEvents));

                        }

                        myCout
                            << std::right << std::setw(35) << (( *itEntry )->gtAlgoName()) << " "
                            << std::right << std::setw(10) << std::fixed << std::setprecision(2)
                            << 100.*eff << " +- "
                            << std::right << std::setw(10) << std::setprecision(2)
                            << 100.*statErrEff << "\n";


                    }

                }

                myCout
                    << "\n\n"
                    << std::right << std::setw(35) << "Technical Trigger Key" << " "
                    << std::right << std::setw(10) << "Passed" << " "
                    << std::right << std::setw(10) << "Rejected" << " "
                    << std::right << std::setw(10) << "Error" << "\n";

                for (CItEntry itEntry = m_entryListTechTrig.begin(); itEntry
                        != m_entryListTechTrig.end(); itEntry++) {

                    if ( ( ( *itEntry )->gtDaqPartition() == m_physicsDaqPartition )
                            && ( ( *itEntry )->gtTriggerMenuName() == *itMenu )) {

                        int nrEventsAccept = ( *itEntry )->gtNrEventsAccept();
                        int nrEventsReject = ( *itEntry )->gtNrEventsReject();
                        int nrEventsError = ( *itEntry )->gtNrEventsError();

                        myCout
                            << std::right << std::setw(35) << (( *itEntry )->gtAlgoName()) << " "
                            << std::right << std::setw(10) << nrEventsAccept << " "
                            << std::right << std::setw(10) << nrEventsReject << " "
                            << std::right << std::setw(10) << nrEventsError << "\n";

                    }
                }

                // efficiency and its statistical error

                myCout << "\n\n"
                    << std::right << std::setw(35) << "Technical Trigger Key" << "    "
                    << std::right << std::setw(10) << "Efficiency " << " "
                    << std::right << std::setw(10) << "Stat error (%)" << "\n";

                for (CItEntry itEntry = m_entryListTechTrig.begin(); itEntry
                        != m_entryListTechTrig.end(); itEntry++) {

                    if ( ( ( *itEntry )->gtDaqPartition() == 0 ) && ( ( *itEntry )->gtTriggerMenuName()
                            == *itMenu )) {

                        int nrEventsAccept = ( *itEntry )->gtNrEventsAccept();
                        int nrEventsReject = ( *itEntry )->gtNrEventsReject();
                        int nrEventsError = ( *itEntry )->gtNrEventsError();

                        int totalEvents = nrEventsAccept + nrEventsReject + nrEventsError;

                        // efficiency and their statistical error
                        float eff = 0.;
                        float statErrEff = 0.;

                        if (totalEvents != 0) {
                            eff = static_cast<float> (nrEventsAccept)
                                    / static_cast<float> (totalEvents);
                            statErrEff = sqrt(eff * ( 1.0 - eff )
                                    / static_cast<float> (totalEvents));

                        }

                        myCout
                            << std::right << std::setw(35) << (( *itEntry )->gtAlgoName()) << " "
                            << std::right << std::setw(10) << std::fixed << std::setprecision(2)
                            << 100.*eff << " +- "
                            << std::right << std::setw(10) << std::setprecision(2)
                            << 100.*statErrEff << "\n";


                    }

                }

            }


        }
            break;

        case 10: {

            myCout << "\nL1T-Report " << "---------- L1 Trigger Global Summary - DAQ Partition "
                    << m_physicsDaqPartition << "----------\n\n";

            myCout
                << std::right << std::setw(35) << "Algorithm Key" << " "
                << std::right << std::setw(10) << "Prescale" << " "
                << std::right << std::setw(5)  << "Mask" << " "
                << std::right << std::setw(15) << "Before Mask" << " "
                << std::right << std::setw(15) << "After Mask" << " "
                << std::right << std::setw(15) << "Error" << std::setw(2) << " "
                << std::right << std::setw(20) << "Trigger Menu Key"
                << "\n"
                << std::right << std::setw(53) << " " << std::setw(15) << "Passed" << " "
                << std::right << std::setw(15) << "Passed" << " " << "\n"
                << std::right << std::setw(53) << " " << std::setw(15) << "Rejected" << " "
                << std::right << std::setw(15) << "Rejected" << " "
                << "\n";

            for (CItEntry itEntry = m_entryList.begin(); itEntry != m_entryList.end(); itEntry++) {

                if ( ( *itEntry )->gtDaqPartition() == m_physicsDaqPartition) {
                    myCout
                        << std::right << std::setw(35) << ( *itEntry )->gtAlgoName() << " "
                        << std::right << std::setw(10) << ( *itEntry )->gtPrescaleFactor() << " "
                        << std::right << std::setw(3) << " " << std::setw(2) //<< std::setfill('0')
                        << std::hex << ( *itEntry )->gtTriggerMask() //<< std::setfill(' ')
                        << std::dec << " "
                        << std::right << std::setw(15) << ( *itEntry )->gtNrEventsAcceptBeforeMask() << " "
                        << std::right << std::setw(15) << ( *itEntry )->gtNrEventsAccept() << " "
                        << std::right << std::setw(15) << ( *itEntry )->gtNrEventsError() << std::setw(2) << " "
                        << std::right << std::setw(20) << ( *itEntry )->gtTriggerMenuName()
                        << "\n"
                        << std::right << std::setw(53) << " "
                        << std::right << std::setw(15) << ( *itEntry )->gtNrEventsRejectBeforeMask() << " "
                        << std::right << std::setw(15) << ( *itEntry )->gtNrEventsReject()
                        << "\n";
                }
            }

            myCout
                << "\n\n"
                << std::right << std::setw(35) << "Technical Trigger Key" << " "
                << std::right << std::setw(10) << "Prescale" << " "
                << std::right << std::setw(5)  << "Mask" << " "
                << std::right << std::setw(15) << "Before Mask" << " "
                << std::right << std::setw(15) << "After Mask" << " "
                << std::right << std::setw(15) << "Error" << std::setw(2) << " "
                << std::right << std::setw(20) << "Trigger Menu Key"
                << "\n"
                << std::right << std::setw(53) << " " << std::setw(15) << "Passed" << " "
                << std::right << std::setw(15) << "Passed" << " "
                << "\n"
                << std::right << std::setw(53) << " " << std::setw(15) << "Rejected" << " "
                << std::right << std::setw(15) << "Rejected" << " "
                << "\n";

            for (CItEntry itEntry = m_entryListTechTrig.begin(); itEntry != m_entryListTechTrig.end(); itEntry++) {

                if ( ( *itEntry )->gtDaqPartition() == m_physicsDaqPartition) {
                    myCout
                    << std::right << std::setw(35) << ( *itEntry )->gtAlgoName() << " "
                    << std::right << std::setw(10) << ( *itEntry )->gtPrescaleFactor() << " "
                    << std::right << std::setw(3) << " " << std::setw(2) //<< std::setfill('0')
                    << std::hex << ( *itEntry )->gtTriggerMask() //<< std::setfill(' ')
                    << std::dec << " "
                    << std::right << std::setw(15) << ( *itEntry )->gtNrEventsAcceptBeforeMask() << " "
                    << std::right << std::setw(15) << ( *itEntry )->gtNrEventsAccept() << " "
                    << std::right << std::setw(15) << ( *itEntry )->gtNrEventsError() << std::setw(2) << " "
                    << std::right << std::setw(20) << ( *itEntry )->gtTriggerMenuName()
                    << "\n"
                    << std::right << std::setw(53) << " "
                    << std::right << std::setw(15) << ( *itEntry )->gtNrEventsRejectBeforeMask() << " "
                    << std::right << std::setw(15) << ( *itEntry )->gtNrEventsReject()
                    << "\n";
                }
            }
        }

            break;
        case 100: {

            for (unsigned int iDaqPartition = 0; iDaqPartition < m_numberDaqPartitions; ++iDaqPartition) {

                myCout << "\nL1T-Report "
                        << "---------- L1 Trigger Global Summary - DAQ Partition " << iDaqPartition
                        << " " << "----------\n\n";

                myCout
                    << std::right << std::setw(35) << "Algorithm Key" << " "
                    << std::right << std::setw(10) << "Passed" << " "
                    << std::right << std::setw(10) << "Rejected" << " "
                    << std::right << std::setw(10) << "Error" << std::setw(2) << " "
                    << std::right << std::setw(20) << "Trigger Menu Key"
                    << "\n";

                for (CItEntry itEntry = m_entryList.begin(); itEntry != m_entryList.end(); itEntry++) {

                    if ( ( *itEntry )->gtDaqPartition() == 0) {

                        myCout
                            << std::right << std::setw(35) << ( *itEntry )->gtAlgoName() << " "
                            << std::right << std::setw(10) << ( *itEntry )->gtNrEventsAccept() << " "
                            << std::right << std::setw(10) << ( *itEntry )->gtNrEventsReject() << " "
                            << std::right << std::setw(10) << ( *itEntry )->gtNrEventsError() << std::setw(2) << " "
                            << std::right << std::setw(20) << ( *itEntry )->gtTriggerMenuName()
                            << "\n";
                    }

                }

                myCout
                    << "\n\n"
                    << std::right << std::setw(35) << "Technical Trigger Key" << " "
                    << std::right << std::setw(10) << "Passed" << " "
                    << std::right << std::setw(10) << "Rejected" << " "
                    << std::right << std::setw(10) << "Error" << std::setw(2) << " "
                    << std::right << std::setw(20) << "Trigger Menu Key"
                    << "\n";

                for (CItEntry itEntry = m_entryListTechTrig.begin(); itEntry != m_entryListTechTrig.end(); itEntry++) {

                    if ( ( *itEntry )->gtDaqPartition() == 0) {

                        myCout
                            << std::right << std::setw(35) << ( *itEntry )->gtAlgoName() << " "
                            << std::right << std::setw(10) << ( *itEntry )->gtNrEventsAccept() << " "
                            << std::right << std::setw(10) << ( *itEntry )->gtNrEventsReject() << " "
                            << std::right << std::setw(10) << ( *itEntry )->gtNrEventsError() << std::setw(2) << " "
                            << std::right << std::setw(20) << ( *itEntry )->gtTriggerMenuName()
                            << "\n";
                    }

                }

            }
        }

            break;
        case 101: {

            for (unsigned int iDaqPartition = 0; iDaqPartition < m_numberDaqPartitions; ++iDaqPartition) {

                myCout << "\nL1T-Report "
                        << "---------- L1 Trigger Global Summary - DAQ Partition " << iDaqPartition
                        << " " << "----------\n\n";

                myCout
                    << std::right << std::setw(35) << "Algorithm Key" << " "
                    << std::right << std::setw(10) << "Prescale" << " "
                    << std::right << std::setw(5)  << "Mask" << " "
                    << std::right << std::setw(10) << "Passed" << " "
                    << std::right << std::setw(10) << "Rejected" << " "
                    << std::right << std::setw(10) << "Error" << std::setw(2) << " "
                    << std::right << std::setw(20) << "Trigger Menu Key"
                    << "\n";

                for (CItEntry itEntry = m_entryList.begin(); itEntry != m_entryList.end(); itEntry++) {

                    if ( ( *itEntry )->gtDaqPartition() == 0) {
                        myCout
                            << std::right << std::setw(35) << ( *itEntry )->gtAlgoName() << " "
                            << std::right << std::setw(10) << ( *itEntry )->gtPrescaleFactor() << "   "
                            << std::right << std::setw(2) //<< std::setfill('0')
                            << std::hex << ( *itEntry )->gtTriggerMask() //<< std::setfill(' ')
                            << std::dec << " "
                            << std::right << std::setw(10) << ( *itEntry )->gtNrEventsAccept() << " "
                            << std::right << std::setw(10) << ( *itEntry )->gtNrEventsReject() << " "
                            << std::right << std::setw(10) << ( *itEntry )->gtNrEventsError() << std::setw(2) << " "
                            << std::right << std::setw(20) << ( *itEntry )->gtTriggerMenuName()
                            << "\n";
                    }
                }

                myCout
                    << "\n\n"
                    << std::right << std::setw(35) << "Technical Trigger Key" << " "
                    << std::right << std::setw(10) << "Prescale" << " "
                    << std::right << std::setw(5)  << "Mask" << " "
                    << std::right << std::setw(10) << "Passed" << " "
                    << std::right << std::setw(10) << "Rejected" << " "
                    << std::right << std::setw(10) << "Error" << std::setw(2) << " "
                    << std::right << std::setw(20) << "Trigger Menu Key"
                    << "\n";

                for (CItEntry itEntry = m_entryListTechTrig.begin(); itEntry != m_entryListTechTrig.end(); itEntry++) {

                    if ( ( *itEntry )->gtDaqPartition() == 0) {
                        myCout
                            << std::right << std::setw(35) << ( *itEntry )->gtAlgoName() << " "
                            << std::right << std::setw(10) << ( *itEntry )->gtPrescaleFactor() << "   "
                            << std::right << std::setw(2) //<< std::setfill('0')
                            << std::hex << ( *itEntry )->gtTriggerMask() //<< std::setfill(' ')
                            << std::dec << " "
                            << std::right << std::setw(10) << ( *itEntry )->gtNrEventsAccept() << " "
                            << std::right << std::setw(10) << ( *itEntry )->gtNrEventsReject() << " "
                            << std::right << std::setw(10) << ( *itEntry )->gtNrEventsError() << std::setw(2) << " "
                            << std::right << std::setw(20) << ( *itEntry )->gtTriggerMenuName()
                            << "\n";
                    }
                }

            }
        }

            break;
        default: {
            myCout
                << "\n\nL1GtTrigReport: Error - no print verbosity level = " << m_printVerbosity
                << " defined! \nCheck available values in the cfi file." << "\n";
        }

            break;
    }

    // TODO for other verbosity levels
    // print the trigger menu, the prescale factors and the trigger mask, etc


    myCout << std::endl;
    myCout << "L1T-Report end!" << std::endl;
    myCout << std::endl;

    switch (m_printOutput) {
        case 0: {

            std::cout << myCout.str() << std::endl;

        }

            break;
        case 1: {

            LogTrace("L1GtTrigReport") << myCout.str() << std::endl;

        }
            break;

        case 2: {

            edm::LogVerbatim("L1GtTrigReport") << myCout.str() << std::endl;

        }

            break;
        case 3: {

            edm::LogInfo("L1GtTrigReport") << myCout.str();

        }

            break;
        default: {
            std::cout
                << "\n\n  L1GtTrigReport: Error - no print output = " << m_printOutput
                << " defined! \n  Check available values in the cfi file." << "\n" << std::endl;

        }
            break;
    }

}

Member Data Documentation

std::list<L1GtTrigReportEntry*> L1GtTrigReport::m_entryList

private

list of individual entries in the report for physics algorithms

Definition at line 144 of file L1GtTrigReport.h.

Referenced by analyze(), endJob(), L1GtTrigReport(), and ~L1GtTrigReport().

std::list<L1GtTrigReportEntry*> L1GtTrigReport::m_entryListTechTrig

private

list of individual entries in the report for technical triggers

Definition at line 147 of file L1GtTrigReport.h.

Referenced by analyze(), endJob(), L1GtTrigReport(), and ~L1GtTrigReport().

std::vector<int> L1GtTrigReport::m_globalNrAccepts

private

global number of events accepted by any of the L1 algorithm in any menu

Definition at line 141 of file L1GtTrigReport.h.

Referenced by analyze(), and endJob().

std::vector<int> L1GtTrigReport::m_globalNrErrors

private

global number of events with error (EDProduct[s] not found)

Definition at line 138 of file L1GtTrigReport.h.

Referenced by analyze(), and endJob().

const L1GtTriggerMenu* L1GtTrigReport::m_l1GtMenu

private

Definition at line 114 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtMenuCacheID

private

Definition at line 115 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

const L1GtPrescaleFactors* L1GtTrigReport::m_l1GtPfAlgo

private

prescale factors

Definition at line 85 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtPfAlgoCacheID

private

Definition at line 86 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

const L1GtPrescaleFactors* L1GtTrigReport::m_l1GtPfTech

private

Definition at line 88 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtPfTechCacheID

private

Definition at line 89 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

edm::InputTag L1GtTrigReport::m_l1GtRecordInputTag

private

input tag for GT record (L1 GT DAQ record or L1 GT "lite" record):

Definition at line 124 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

const L1GtStableParameters* L1GtTrigReport::m_l1GtStablePar

private

cached stuff

stable parameters

Definition at line 71 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtStableParCacheID

private

Definition at line 72 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

const L1GtTriggerMask* L1GtTrigReport::m_l1GtTmAlgo

private

trigger masks & veto masks

Definition at line 95 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtTmAlgoCacheID

private

Definition at line 96 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

const L1GtTriggerMask* L1GtTrigReport::m_l1GtTmTech

private

Definition at line 98 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtTmTechCacheID

private

Definition at line 99 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

const L1GtTriggerMask* L1GtTrigReport::m_l1GtTmVetoAlgo

private

Definition at line 101 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtTmVetoAlgoCacheID

private

Definition at line 102 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

const L1GtTriggerMask* L1GtTrigReport::m_l1GtTmVetoTech

private

Definition at line 104 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtTmVetoTechCacheID

private

Definition at line 105 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

unsigned int L1GtTrigReport::m_numberDaqPartitions

private

number of DAQ partitions

Definition at line 81 of file L1GtTrigReport.h.

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

unsigned int L1GtTrigReport::m_numberDaqPartitionsMax

private

Definition at line 82 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

unsigned int L1GtTrigReport::m_numberPhysTriggers

private

number of physics triggers

Definition at line 75 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

unsigned int L1GtTrigReport::m_numberTechnicalTriggers

private

number of technical triggers

Definition at line 78 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

unsigned int L1GtTrigReport::m_physicsDaqPartition

private

index of physics DAQ partition

Definition at line 153 of file L1GtTrigReport.h.

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

const std::vector<std::vector<int> >* L1GtTrigReport::m_prescaleFactorsAlgoTrig

private

Definition at line 91 of file L1GtTrigReport.h.

Referenced by analyze().

const std::vector<std::vector<int> >* L1GtTrigReport::m_prescaleFactorsTechTrig

private

Definition at line 92 of file L1GtTrigReport.h.

Referenced by analyze().

int L1GtTrigReport::m_printOutput

private

print output

Definition at line 130 of file L1GtTrigReport.h.

Referenced by endJob(), and L1GtTrigReport().

int L1GtTrigReport::m_printVerbosity

private

print verbosity

Definition at line 127 of file L1GtTrigReport.h.

Referenced by endJob(), and L1GtTrigReport().

int L1GtTrigReport::m_totalEvents

private

counters

global number of events processed

Definition at line 135 of file L1GtTrigReport.h.

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

std::vector<unsigned int> L1GtTrigReport::m_triggerMaskAlgoTrig

private

Definition at line 107 of file L1GtTrigReport.h.

Referenced by analyze().

std::vector<unsigned int> L1GtTrigReport::m_triggerMaskTechTrig

private

Definition at line 108 of file L1GtTrigReport.h.

Referenced by analyze().

std::vector<unsigned int> L1GtTrigReport::m_triggerMaskVetoAlgoTrig

private

Definition at line 110 of file L1GtTrigReport.h.

Referenced by analyze().

std::vector<unsigned int> L1GtTrigReport::m_triggerMaskVetoTechTrig

private

Definition at line 111 of file L1GtTrigReport.h.

Referenced by analyze().

bool L1GtTrigReport::m_useL1GlobalTriggerRecord

private

boolean flag to select the input record

Definition at line 121 of file L1GtTrigReport.h.

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