#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
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
std::vector< ConsumesInfo >	consumesInfo () const

	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

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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...

edm::EDGetTokenT < L1GlobalTriggerRecord >	m_l1GtRecordInputToken1

edm::EDGetTokenT < L1GlobalTriggerReadoutRecord >	m_l1GtRecordInputToken2

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

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: L1 Trigger report.

Implementation: <TODO: enter implementation details>

Author: : Vasile Mihai Ghete - HEPHY Vienna

Definition at line 46 of file L1GtTrigReport.h.

Member Typedef Documentation

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

private

Definition at line 153 of file L1GtTrigReport.h.

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

private

Definition at line 154 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 68 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_l1GtRecordInputToken1, m_l1GtRecordInputToken2, 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;
 
     if (m_useL1GlobalTriggerRecord) {
       m_l1GtRecordInputToken1=consumes<L1GlobalTriggerRecord>(m_l1GtRecordInputTag);
     }
     else{
       m_l1GtRecordInputToken2=consumes<L1GlobalTriggerReadoutRecord>(m_l1GtRecordInputTag);
     }
 
 }

L1GtTrigReport::~L1GtTrigReport ( )

virtual

destructor

Definition at line 134 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 167 of file L1GtTrigReport.cc.

References L1GtTrigReportEntry::addErrorEntry(), L1GtTrigReportEntry::addValidEntry(), edm::EventSetup::get(), edm::Event::getByToken(), L1GtTriggerMenu::gtAlgorithmMap(), L1GtStableParameters::gtNumberPhysTriggers(), L1GtStableParameters::gtNumberTechnicalTriggers(), L1GtPrescaleFactors::gtPrescaleFactors(), L1GtTriggerMenu::gtTechnicalTriggerMap(), 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_l1GtRecordInputToken1, m_l1GtRecordInputToken2, 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, edm::ESHandle< class >::product(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                  {
 
     // 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.getByToken(m_l1GtRecordInputToken1, gtRecord);
     } else {
         iEvent.getByToken(m_l1GtRecordInputToken2, 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
         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 160 of file L1GtTrigReport.cc.

void L1GtTrigReport::endJob ( void )

privatevirtual

end of job

Reimplemented from edm::EDAnalyzer.

Definition at line 693 of file L1GtTrigReport.cc.

References gather_cfg::cout, TauDecayModes::dec, 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;
 
         }
 
     }
 
     // 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;
 
     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";
 
             for (CItL1Menu itMenu = menuList.begin(); itMenu != menuList.end(); itMenu++) {
 
                 myCout << "\nReport for L1 menu:  " << (*itMenu) << "\n"
                         << std::endl;
 
                 myCout
                     << std::right << std::setw(45) << "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 )) {
 
                         myCout
                             << std::right << std::setw(45) << (*itEntry)->gtAlgoName() << " "
                             << std::right << std::setw(10) << (*itEntry)->gtNrEventsAccept() << " "
                             << std::right << std::setw(10) << (*itEntry)->gtNrEventsReject() << " "
                             << std::right << std::setw(10) << (*itEntry)->gtNrEventsError()
                             << "\n";
                     }
 
                 }
 
                 myCout
                     << "\n\n"
                     << std::right << std::setw(45) << "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 )) {
 
                         myCout
                             << std::right << std::setw(45) << (*itEntry)->gtAlgoName() << " "
                             << std::right << std::setw(10) << (*itEntry)->gtNrEventsAccept() << " "
                             << std::right << std::setw(10) << (*itEntry)->gtNrEventsReject() << " "
                             << std::right << std::setw(10) << (*itEntry)->gtNrEventsError()
                             << "\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";
 
             for (CItL1Menu itMenu = menuList.begin(); itMenu != menuList.end(); itMenu++) {
 
                 myCout << "\nReport for L1 menu:  " << (*itMenu) << "\n"
                         << std::endl;
                 myCout
                     << std::right << std::setw(45) << "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) << " "
                     << "\n";
 
                 for (CItEntry itEntry = m_entryList.begin(); itEntry != m_entryList.end(); itEntry++) {
 
                     if ( (( *itEntry )->gtDaqPartition() == m_physicsDaqPartition)
                             && ( ( *itEntry )->gtTriggerMenuName() == *itMenu )) {
                         myCout
                             << std::right << std::setw(45) << ( *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) << " "
                             << "\n";
                     }
                 }
 
                 myCout
                     << "\n\n"
                     << std::right << std::setw(45) << "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) << " "
                     << "\n";
 
                 for (CItEntry itEntry = m_entryListTechTrig.begin(); itEntry != m_entryListTechTrig.end(); itEntry++) {
 
                     if ( (( *itEntry )->gtDaqPartition() == m_physicsDaqPartition)
                             && ( ( *itEntry )->gtTriggerMenuName() == *itMenu )) {
                         myCout
                             << std::right << std::setw(45) << ( *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) << " "
                             << "\n";
                     }
                 }
             }
 
         }
 
             break;
         case 2: {
 
 
             for (CItL1Menu itMenu = menuList.begin(); itMenu != menuList.end(); itMenu++) {
 
                 myCout << "\nReport for L1 menu:  " << ( *itMenu ) << "\n"
                         << std::endl;
 
                 myCout
                     << std::right << std::setw(45) << "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(45) << (( *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(45) << "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(45) << (( *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(45) << "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(45) << (( *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(45) << "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(45) << (( *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";
 
             for (CItL1Menu itMenu = menuList.begin(); itMenu != menuList.end(); itMenu++) {
 
                 myCout << "\nReport for L1 menu:  " << ( *itMenu ) << "\n"
                         << std::endl;
                 myCout
                     << std::right << std::setw(45) << "Algorithm Key" << " "
                     << std::right << std::setw(10) << "Prescale" << "  "
                     << std::right << std::setw(5)  << "Mask" << " "
                     << std::right << std::setw(25) << "Before Mask" << " "
                     << std::right << std::setw(30) << "After Mask" << " "
                     << std::right << std::setw(22) << "Error"
                     << "\n"
                     << std::right << std::setw(64) << " " << std::setw(15) << "Passed"
                     << std::right << std::setw(1)  << " " << std::setw(15) << "Rejected"
                     << std::right << std::setw(1)  << " " << std::setw(15) << "Passed"
                     << std::right << std::setw(1)  << " " << std::setw(15) << "Rejected"
                     << "\n";
 
                 for (CItEntry itEntry = m_entryList.begin(); itEntry != m_entryList.end(); itEntry++) {
 
                     if ( (( *itEntry )->gtDaqPartition() == m_physicsDaqPartition)
                             && ( ( *itEntry )->gtTriggerMenuName() == *itMenu )) {
                         myCout
                             << std::right << std::setw(45) << ( *itEntry )->gtAlgoName() << " "
                             << std::right << std::setw(10) << ( *itEntry )->gtPrescaleFactor() << " "
                             << std::right << std::setw(5)  << " " << std::hex << ( *itEntry )->gtTriggerMask() << std::dec << " "
                             << std::right << std::setw(15) << ( *itEntry )->gtNrEventsAcceptBeforeMask() << " "
                             << std::right << std::setw(15) << ( *itEntry )->gtNrEventsRejectBeforeMask() << " "
                             << std::right << std::setw(15) << ( *itEntry )->gtNrEventsAccept() << " "
                             << std::right << std::setw(15) << ( *itEntry )->gtNrEventsReject() << " "
                             << std::right << std::setw(15) << ( *itEntry )->gtNrEventsError()
                             << "\n";
                     }
                 }
 
                 myCout
                     << "\n\n"
                     << std::right << std::setw(45) << "Technical Trigger Key" << " "
                     << std::right << std::setw(10) << "Prescale" << "  "
                     << std::right << std::setw(5)  << "Mask" << " "
                     << std::right << std::setw(25) << "Before Mask" << " "
                     << std::right << std::setw(30) << "After Mask" << " "
                     << std::right << std::setw(22) << "Error"
                     << "\n"
                     << std::right << std::setw(64) << " " << std::setw(15) << "Passed"
                     << std::right << std::setw(1)  << " " << std::setw(15) << "Rejected"
                     << std::right << std::setw(1)  << " " << std::setw(15) << "Passed"
                     << std::right << std::setw(1)  << " " << std::setw(15) << "Rejected"
                     << "\n";
 
                 for (CItEntry itEntry = m_entryListTechTrig.begin(); itEntry != m_entryListTechTrig.end(); itEntry++) {
 
                     if ( (( *itEntry )->gtDaqPartition() == m_physicsDaqPartition)
                             && ( ( *itEntry )->gtTriggerMenuName() == *itMenu )) {
                         myCout
                             << std::right << std::setw(45) << ( *itEntry )->gtAlgoName() << " "
                             << std::right << std::setw(10) << ( *itEntry )->gtPrescaleFactor() << " "
                             << std::right << std::setw(5)  << " " << std::hex << ( *itEntry )->gtTriggerMask() << std::dec << " "
                             << std::right << std::setw(15) << ( *itEntry )->gtNrEventsAcceptBeforeMask() << " "
                             << std::right << std::setw(15) << ( *itEntry )->gtNrEventsRejectBeforeMask() << " "
                             << std::right << std::setw(15) << ( *itEntry )->gtNrEventsAccept() << " "
                             << std::right << std::setw(15) << ( *itEntry )->gtNrEventsReject() << " "
                             << std::right << std::setw(15) << ( *itEntry )->gtNrEventsError()
                             << "\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(45) << "Algorithm Key" << " "
                     << std::right << std::setw(10) << "Passed" << " "
                     << std::right << std::setw(10) << "Rejected" << " "
                     << std::right << std::setw(10) << "Error" << std::setw(2) << " "
                     << "\n";
 
                 for (CItEntry itEntry = m_entryList.begin(); itEntry != m_entryList.end(); itEntry++) {
 
                     if ( (( *itEntry )->gtDaqPartition() == 0)) {
 
                         myCout
                             << std::right << std::setw(45) << ( *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) << " "
                             << "\n";
                     }
 
                 }
 
                 myCout
                     << "\n\n"
                     << std::right << std::setw(45) << "Technical Trigger Key" << " "
                     << std::right << std::setw(10) << "Passed" << " "
                     << std::right << std::setw(10) << "Rejected" << " "
                     << std::right << std::setw(10) << "Error" << std::setw(2) << " "
                     << "\n";
 
                 for (CItEntry itEntry = m_entryListTechTrig.begin(); itEntry != m_entryListTechTrig.end(); itEntry++) {
 
                     if ( ( *itEntry )->gtDaqPartition() == 0) {
 
                         myCout
                             << std::right << std::setw(45) << ( *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(45) << "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) << " "
                     << "\n";
 
                 for (CItEntry itEntry = m_entryList.begin(); itEntry != m_entryList.end(); itEntry++) {
 
                     if ( ( *itEntry )->gtDaqPartition() == 0) {
                         myCout
                             << std::right << std::setw(45) << ( *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) << " "
                             << "\n";
                     }
                 }
 
                 myCout
                     << "\n\n"
                     << std::right << std::setw(45) << "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) << " "
                     << "\n";
 
                 for (CItEntry itEntry = m_entryListTechTrig.begin(); itEntry != m_entryListTechTrig.end(); itEntry++) {
 
                     if ( ( *itEntry )->gtDaqPartition() == 0) {
                         myCout
                             << std::right << std::setw(45) << ( *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) << " "
                             << "\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 148 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 151 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 145 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 142 of file L1GtTrigReport.h.

Referenced by analyze(), and endJob().

const L1GtTriggerMenu* L1GtTrigReport::m_l1GtMenu

private

Definition at line 115 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtMenuCacheID

private

Definition at line 116 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

const L1GtPrescaleFactors* L1GtTrigReport::m_l1GtPfAlgo

private

prescale factors

Definition at line 86 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtPfAlgoCacheID

private

Definition at line 87 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

const L1GtPrescaleFactors* L1GtTrigReport::m_l1GtPfTech

private

Definition at line 89 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtPfTechCacheID

private

Definition at line 90 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 125 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

edm::EDGetTokenT<L1GlobalTriggerRecord> L1GtTrigReport::m_l1GtRecordInputToken1

private

Definition at line 127 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

edm::EDGetTokenT<L1GlobalTriggerReadoutRecord> L1GtTrigReport::m_l1GtRecordInputToken2

private

Definition at line 128 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

const L1GtStableParameters* L1GtTrigReport::m_l1GtStablePar

private

cached stuff

stable parameters

Definition at line 72 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtStableParCacheID

private

Definition at line 73 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

const L1GtTriggerMask* L1GtTrigReport::m_l1GtTmAlgo

private

trigger masks & veto masks

Definition at line 96 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtTmAlgoCacheID

private

Definition at line 97 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

const L1GtTriggerMask* L1GtTrigReport::m_l1GtTmTech

private

Definition at line 99 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtTmTechCacheID

private

Definition at line 100 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

const L1GtTriggerMask* L1GtTrigReport::m_l1GtTmVetoAlgo

private

Definition at line 102 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtTmVetoAlgoCacheID

private

Definition at line 103 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

const L1GtTriggerMask* L1GtTrigReport::m_l1GtTmVetoTech

private

Definition at line 105 of file L1GtTrigReport.h.

Referenced by analyze().

unsigned long long L1GtTrigReport::m_l1GtTmVetoTechCacheID

private

Definition at line 106 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

unsigned int L1GtTrigReport::m_numberDaqPartitions

private

number of DAQ partitions

Definition at line 82 of file L1GtTrigReport.h.

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

unsigned int L1GtTrigReport::m_numberDaqPartitionsMax

private

Definition at line 83 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

unsigned int L1GtTrigReport::m_numberPhysTriggers

private

number of physics triggers

Definition at line 76 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

unsigned int L1GtTrigReport::m_numberTechnicalTriggers

private

number of technical triggers

Definition at line 79 of file L1GtTrigReport.h.

Referenced by analyze(), and L1GtTrigReport().

unsigned int L1GtTrigReport::m_physicsDaqPartition

private

index of physics DAQ partition

Definition at line 157 of file L1GtTrigReport.h.

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

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

private

Definition at line 92 of file L1GtTrigReport.h.

Referenced by analyze().

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

private

Definition at line 93 of file L1GtTrigReport.h.

Referenced by analyze().

int L1GtTrigReport::m_printOutput

private

print output

Definition at line 134 of file L1GtTrigReport.h.

Referenced by endJob(), and L1GtTrigReport().

int L1GtTrigReport::m_printVerbosity

private

print verbosity

Definition at line 131 of file L1GtTrigReport.h.

Referenced by endJob(), and L1GtTrigReport().

int L1GtTrigReport::m_totalEvents

private

counters

global number of events processed

Definition at line 139 of file L1GtTrigReport.h.

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

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

private

Definition at line 108 of file L1GtTrigReport.h.

Referenced by analyze().

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

private

Definition at line 109 of file L1GtTrigReport.h.

Referenced by analyze().

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

private

Definition at line 111 of file L1GtTrigReport.h.

Referenced by analyze().

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

private

Definition at line 112 of file L1GtTrigReport.h.

Referenced by analyze().

bool L1GtTrigReport::m_useL1GlobalTriggerRecord

private

boolean flag to select the input record

Definition at line 122 of file L1GtTrigReport.h.

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation