L1GlobalTriggerGTL Class Reference

#include <L1GlobalTriggerGTL.h>

Public Member Functions
const std::bitset < L1GlobalTriggerReadoutSetup::NumberPhysTriggers > &	getAlgorithmOR () const
	return algorithm OR decision More...
const std::vector< const L1MuGMTCand * > *	getCandL1Mu () const
	return global muon trigger candidate More...
const std::bitset < L1GlobalTriggerReadoutSetup::NumberPhysTriggers > &	getDecisionWord () const
	return decision More...
void	init (const int nrL1Mu, const int numberPhysTriggers)
	initialize the class (mainly reserve) More...
	L1GlobalTriggerGTL (const edm::InputTag &mutag, edm::ConsumesCollector &&iC)
void	printGmtData (const int iBxInEvent) const
	print received Muon dataWord More...
void	receiveGmtObjectData (edm::Event &, const edm::InputTag &, const int iBxInEvent, const bool receiveMu, const int nrL1Mu)
	receive data from Global Muon Trigger More...
void	reset ()
	clear GTL More...
void	run (edm::Event &iEvent, const edm::EventSetup &evSetup, const L1GlobalTriggerPSB *ptrGtPSB, const bool produceL1GtObjectMapRecord, const int iBxInEvent, std::auto_ptr< L1GlobalTriggerObjectMapRecord > &gtObjectMapRecord, const unsigned int numberPhysTriggers, const int nrL1Mu, const int nrL1NoIsoEG, const int nrL1IsoEG, const int nrL1CenJet, const int nrL1ForJet, const int nrL1TauJet, const int nrL1JetCounts, const int ifMuEtaNumberBits, const int ifCaloEtaNumberBits)
	run the GTL More...
void	setVerbosity (const int verbosity)
virtual	~L1GlobalTriggerGTL ()

Private Attributes
std::vector< const L1MuGMTCand * > *	m_candL1Mu
std::vector < L1GtAlgorithmEvaluation::ConditionEvaluationMap >	m_conditionResultMaps
L1GtEtaPhiConversions *	m_gtEtaPhiConversions
std::bitset < L1GlobalTriggerReadoutSetup::NumberPhysTriggers >	m_gtlAlgorithmOR
std::bitset < L1GlobalTriggerReadoutSetup::NumberPhysTriggers >	m_gtlDecisionWord
bool	m_isDebugEnabled
const L1CaloGeometry *	m_l1CaloGeometry
unsigned long long	m_l1CaloGeometryCacheID
const L1GtTriggerMenu *	m_l1GtMenu
unsigned long long	m_l1GtMenuCacheID
const L1MuTriggerScales *	m_l1MuTriggerScales
unsigned long long	m_l1MuTriggerScalesCacheID
int	m_verbosity
	verbosity level More...

Detailed Description

Description: Global Trigger Logic board.

Implementation: <TODO: enter implementation details>

Author

: M. Fierro - HEPHY Vienna - ORCA version

: Vasile Mihai Ghete - HEPHY Vienna - CMSSW version

Description: Global Trigger Logic board, see header file for details.

Implementation: <TODO: enter implementation details>

Author

: M. Fierro - HEPHY Vienna - ORCA version

: Vasile Mihai Ghete - HEPHY Vienna - CMSSW version

Definition at line 46 of file L1GlobalTriggerGTL.h.

Constructor & Destructor Documentation

L1GlobalTriggerGTL::L1GlobalTriggerGTL	(	const edm::InputTag &	mutag,
		edm::ConsumesCollector &&	iC
	)

Definition at line 77 of file L1GlobalTriggerGTL.cc.

References m_gtEtaPhiConversions, m_gtlAlgorithmOR, m_gtlDecisionWord, m_l1CaloGeometryCacheID, m_l1GtMenuCacheID, m_l1MuTriggerScalesCacheID, m_verbosity, and L1GtEtaPhiConversions::setVerbosity().

                                                                                                     :
    m_candL1Mu( new std::vector<const L1MuGMTCand*>),
    m_isDebugEnabled(edm::isDebugEnabled())
{

    m_gtlAlgorithmOR.reset();
    m_gtlDecisionWord.reset();

    // initialize cached IDs
    m_l1GtMenuCacheID = 0ULL;
    m_l1CaloGeometryCacheID = 0ULL;
    m_l1MuTriggerScalesCacheID = 0ULL;

    // pointer to conversion - actually done in the event loop (cached)
    m_gtEtaPhiConversions = new L1GtEtaPhiConversions();
    m_gtEtaPhiConversions->setVerbosity(m_verbosity);

    iC.consumes<std::vector<L1MuGMTCand> >(m_muGmtInputTag);

}

L1GlobalTriggerGTL::~L1GlobalTriggerGTL ( )

virtual

Definition at line 99 of file L1GlobalTriggerGTL.cc.

References m_candL1Mu, m_gtEtaPhiConversions, and reset().

                                        {

    reset();
    delete m_candL1Mu;
    delete m_gtEtaPhiConversions;

}

Member Function Documentation

const std::bitset<L1GlobalTriggerReadoutSetup::NumberPhysTriggers>& L1GlobalTriggerGTL::getAlgorithmOR ( ) const

inline

return algorithm OR decision

Definition at line 97 of file L1GlobalTriggerGTL.h.

References m_gtlAlgorithmOR.

Referenced by L1GlobalTriggerFDL::run().

    {
        return m_gtlAlgorithmOR;
    }

const std::vector<const L1MuGMTCand*>* L1GlobalTriggerGTL::getCandL1Mu ( ) const

inline

return global muon trigger candidate

Definition at line 103 of file L1GlobalTriggerGTL.h.

References m_candL1Mu.

Referenced by L1GtCorrelationCondition::evaluateCondition(), L1GtMuonCondition::evaluateCondition(), and L1GtMuonCondition::getCandidate().

    {
        return m_candL1Mu;
    }

const std::bitset<L1GlobalTriggerReadoutSetup::NumberPhysTriggers>& L1GlobalTriggerGTL::getDecisionWord ( ) const

inline

return decision

Definition at line 91 of file L1GlobalTriggerGTL.h.

References m_gtlDecisionWord.

    {
        return m_gtlDecisionWord;
    }

void L1GlobalTriggerGTL::init	(	const int	nrL1Mu,
		const int	numberPhysTriggers
	)

initialize the class (mainly reserve)

Definition at line 108 of file L1GlobalTriggerGTL.cc.

References m_candL1Mu.

Referenced by L1GlobalTrigger::produce().

                                                                            {

    m_candL1Mu->reserve(nrL1Mu);

    // FIXME move from bitset to std::vector<bool> to be able to use
    // numberPhysTriggers from EventSetup

    //m_gtlAlgorithmOR.reserve(numberPhysTriggers);
    //m_gtlAlgorithmOR.assign(numberPhysTriggers, false);

    //m_gtlDecisionWord.reserve(numberPhysTriggers);
    //m_gtlDecisionWord.assign(numberPhysTriggers, false);

}

void L1GlobalTriggerGTL::printGmtData

(

const int

iBxInEvent

)

const

print received Muon dataWord

Definition at line 744 of file L1GlobalTriggerGTL.cc.

References LogTrace, and m_candL1Mu.

Referenced by receiveGmtObjectData().

                                                                {

    LogTrace("L1GlobalTrigger")
            << "\nL1GlobalTrigger: GMT data received for BxInEvent = "
            << iBxInEvent << std::endl;

    int nrL1Mu = m_candL1Mu->size();
    LogTrace("L1GlobalTrigger")
            << "Number of GMT muons = " << nrL1Mu << "\n"
            << std::endl;

    for (std::vector<const L1MuGMTCand*>::const_iterator iter =
            m_candL1Mu->begin(); iter != m_candL1Mu->end(); iter++) {

        LogTrace("L1GlobalTrigger") << *(*iter) << std::endl;

    }

    LogTrace("L1GlobalTrigger") << std::endl;

}

void L1GlobalTriggerGTL::receiveGmtObjectData	(	edm::Event &	iEvent,
		const edm::InputTag &	muGmtInputTag,
		const int	iBxInEvent,
		const bool	receiveMu,
		const int	nrL1Mu
	)

receive data from Global Muon Trigger

Definition at line 124 of file L1GlobalTriggerGTL.cc.

References edm::Event::getByLabel(), edm::HandleBase::isValid(), LogDebug, m_isDebugEnabled, m_verbosity, printGmtData(), and reset().

Referenced by L1GlobalTrigger::produce().

                      {

    if (m_verbosity) {
        LogDebug("L1GlobalTrigger")
                << "\n**** L1GlobalTriggerGTL receiving muon data for BxInEvent = "
                << iBxInEvent << "\n     from input tag " << muGmtInputTag << "\n"
                << std::endl;

    }

    reset();

    // get data from Global Muon Trigger
    if (receiveMu) {

        edm::Handle<std::vector<L1MuGMTCand> > muonData;
        iEvent.getByLabel(muGmtInputTag, muonData);

        if (!muonData.isValid()) {
            if (m_verbosity) {
                edm::LogWarning("L1GlobalTrigger")
                        << "\nWarning: std::vector<L1MuGMTCand> with input tag "
                        << muGmtInputTag
                        << "\nrequested in configuration, but not found in the event.\n"
                        << std::endl;
            }
        } else {

            std::vector<L1MuGMTCand>::const_iterator itMuon;
            for (itMuon = muonData->begin(); itMuon != muonData->end(); itMuon++) {
                if ((*itMuon).bx() == iBxInEvent) {

                    (*m_candL1Mu).push_back(&(*itMuon));
                    //LogTrace("L1GlobalTrigger") << (*itMuon)
                    //        << std::endl;

                }

            }

        }
    }

    if (m_verbosity && m_isDebugEnabled) {
        printGmtData(iBxInEvent);
    }

}

void L1GlobalTriggerGTL::reset

(

void

)

clear GTL

Definition at line 734 of file L1GlobalTriggerGTL.cc.

References m_candL1Mu, m_gtlAlgorithmOR, and m_gtlDecisionWord.

Referenced by L1GlobalTrigger::produce(), receiveGmtObjectData(), and ~L1GlobalTriggerGTL().

                               {

    m_candL1Mu->clear();

    m_gtlDecisionWord.reset();
    m_gtlAlgorithmOR.reset();

}

void L1GlobalTriggerGTL::run	(	edm::Event &	iEvent,
		const edm::EventSetup &	evSetup,
		const L1GlobalTriggerPSB *	ptrGtPSB,
		const bool	produceL1GtObjectMapRecord,
		const int	iBxInEvent,
		std::auto_ptr< L1GlobalTriggerObjectMapRecord > &	gtObjectMapRecord,
		const unsigned int	numberPhysTriggers,
		const int	nrL1Mu,
		const int	nrL1NoIsoEG,
		const int	nrL1IsoEG,
		const int	nrL1CenJet,
		const int	nrL1ForJet,
		const int	nrL1TauJet,
		const int	nrL1JetCounts,
		const int	ifMuEtaNumberBits,
		const int	ifCaloEtaNumberBits
	)

run the GTL

Definition at line 176 of file L1GlobalTriggerGTL.cc.

References CenJet, L1GtCorrelationTemplate::cond0Category(), L1GtCorrelationTemplate::cond0Index(), L1GtCorrelationTemplate::cond1Category(), L1GtCorrelationTemplate::cond1Index(), CondBptx, CondCalo, CondCastor, CondCorrelation, CondEnergySum, CondExternal, CondHfBitCounts, CondHfRingEtSums, CondJetCounts, CondMuon, CondNull, L1GtEtaPhiConversions::convertL1Scales(), L1GtTriggerMenu::corCaloTemplate(), L1GtTriggerMenu::corEnergySumTemplate(), L1GtTriggerMenu::corMuonTemplate(), L1GtAlgorithmEvaluation::evaluateAlgorithm(), L1GtConditionEvaluation::evaluateConditionStoreResult(), ForJet, edm::EventSetup::get(), L1GtAlgorithmEvaluation::gtAlgoCombinationVector(), L1GtAlgorithmEvaluation::gtAlgoResult(), L1GtTriggerMenu::gtAlgorithmMap(), L1GtTriggerMenu::gtConditionMap(), L1GtEtaPhiConversions::gtObjectNrBinsPhi(), IsoEG, l1CaloGeometry_cfi::l1CaloGeometry, LogTrace, m_conditionResultMaps, m_gtEtaPhiConversions, m_gtlAlgorithmOR, m_isDebugEnabled, m_l1CaloGeometry, m_l1CaloGeometryCacheID, m_l1GtMenu, m_l1GtMenuCacheID, m_l1MuTriggerScales, m_l1MuTriggerScalesCacheID, m_verbosity, Mu, NoIsoEG, L1GtCondition::objectType(), L1GtAlgorithmEvaluation::operandTokenVector(), reco::print(), L1GtHfBitCountsCondition::print(), L1GtHfRingEtSumsCondition::print(), L1GtCastorCondition::print(), L1GtExternalCondition::print(), L1GtBptxCondition::print(), L1GtJetCountsCondition::print(), L1GtEnergySumCondition::print(), L1GtCorrelationCondition::print(), L1GtMuonCondition::print(), L1GtCaloCondition::print(), L1GtEtaPhiConversions::print(), L1GtAlgorithmEvaluation::print(), L1GlobalTriggerObjectMap::print(), edm::ESHandle< class >::product(), L1GlobalTriggerObjectMap::setAlgoBitNumber(), L1GlobalTriggerObjectMap::setAlgoGtlResult(), L1GlobalTriggerObjectMap::setAlgoName(), L1GtMuonCondition::setGtCorrParDeltaPhiNrBins(), L1GtCaloCondition::setGtCorrParDeltaPhiNrBins(), L1GtEtaPhiConversions::setVerbosity(), L1GtConditionEvaluation::setVerbosity(), L1GlobalTriggerObjectMap::swapCombinationVector(), L1GlobalTriggerObjectMap::swapOperandTokenVector(), and TauJet.

Referenced by L1GlobalTrigger::produce().

                                                                    {


    // 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;
    }

    const std::vector<ConditionMap>& conditionMap = m_l1GtMenu->gtConditionMap();
    const AlgorithmMap& algorithmMap = m_l1GtMenu->gtAlgorithmMap();

    const std::vector<std::vector<L1GtMuonTemplate> >& corrMuon =
            m_l1GtMenu->corMuonTemplate();

    const std::vector<std::vector<L1GtCaloTemplate> >& corrCalo =
            m_l1GtMenu->corCaloTemplate();

    const std::vector<std::vector<L1GtEnergySumTemplate> >& corrEnergySum =
            m_l1GtMenu->corEnergySumTemplate();

    // conversion needed for correlation conditions
    // done in the condition loop when the first correlation template is in the menu
    bool convertScale = false;

    // get / update the calorimeter geometry from the EventSetup
    // local cache & check on cacheIdentifier
    unsigned long long l1CaloGeometryCacheID =
            evSetup.get<L1CaloGeometryRecord>().cacheIdentifier();

    if (m_l1CaloGeometryCacheID != l1CaloGeometryCacheID) {

        edm::ESHandle<L1CaloGeometry> l1CaloGeometry;
        evSetup.get<L1CaloGeometryRecord>().get(l1CaloGeometry) ;
        m_l1CaloGeometry =  l1CaloGeometry.product();

        m_l1CaloGeometryCacheID = l1CaloGeometryCacheID;
        convertScale = true;

    }

    // get / update the eta and phi muon trigger scales from the EventSetup
    // local cache & check on cacheIdentifier
    unsigned long long l1MuTriggerScalesCacheID =
            evSetup.get<L1MuTriggerScalesRcd>().cacheIdentifier();

    if (m_l1MuTriggerScalesCacheID != l1MuTriggerScalesCacheID) {

        edm::ESHandle< L1MuTriggerScales> l1MuTriggerScales;
        evSetup.get< L1MuTriggerScalesRcd>().get(l1MuTriggerScales);
        m_l1MuTriggerScales = l1MuTriggerScales.product();

        m_l1MuTriggerScalesCacheID = l1MuTriggerScalesCacheID;
        convertScale = true;
    }

    if (convertScale) {
        m_gtEtaPhiConversions->setVerbosity(m_verbosity);
        m_gtEtaPhiConversions->convertL1Scales(m_l1CaloGeometry,
                m_l1MuTriggerScales, ifCaloEtaNumberBits, ifMuEtaNumberBits);

        // print the conversions if DEBUG and verbosity enabled

        if (m_verbosity && m_isDebugEnabled) {
            std::ostringstream myCout;
            m_gtEtaPhiConversions->print(myCout);

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

        // set convertScale to false to avoid executing the conversion
        // more than once - in case the scales change it will be set to true
        // in the cache check
        convertScale = false;
    }


    // loop over condition maps (one map per condition chip)
    // then loop over conditions in the map
    // save the results in temporary maps

    // never happens in production but at first event...
    if (m_conditionResultMaps.size() != conditionMap.size()) {
        m_conditionResultMaps.clear();
        m_conditionResultMaps.resize(conditionMap.size());
    }
    
    int iChip = -1;

    for (std::vector<ConditionMap>::const_iterator
            itCondOnChip = conditionMap.begin(); itCondOnChip != conditionMap.end(); itCondOnChip++) {

        iChip++;

        //L1GtAlgorithmEvaluation::ConditionEvaluationMap cMapResults;
        // L1GtAlgorithmEvaluation::ConditionEvaluationMap cMapResults((*itCondOnChip).size()); // hash map
        L1GtAlgorithmEvaluation::ConditionEvaluationMap& cMapResults =
                m_conditionResultMaps[iChip];

        for (CItCond itCond = itCondOnChip->begin(); itCond != itCondOnChip->end(); itCond++) {

            // evaluate condition
            switch ((itCond->second)->condCategory()) {
                case CondMuon: {

                    L1GtMuonCondition* muCondition = new L1GtMuonCondition(itCond->second, this,
                            nrL1Mu, ifMuEtaNumberBits);

                    muCondition->setVerbosity(m_verbosity);
                    muCondition->setGtCorrParDeltaPhiNrBins(
                            (m_gtEtaPhiConversions->gtObjectNrBinsPhi(Mu)) / 2
                                    + 1);
                    muCondition->evaluateConditionStoreResult();

                    cMapResults[itCond->first] = muCondition;

                    if (m_verbosity && m_isDebugEnabled) {
                        std::ostringstream myCout;
                        muCondition->print(myCout);

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

                    //delete muCondition;

                }
                    break;
                case CondCalo: {

                    L1GtCaloCondition* caloCondition = new L1GtCaloCondition(
                            itCond->second, ptrGtPSB,
                            nrL1NoIsoEG,
                            nrL1IsoEG,
                            nrL1CenJet,
                            nrL1ForJet,
                            nrL1TauJet,
                            ifCaloEtaNumberBits);

                    caloCondition->setVerbosity(m_verbosity);
                    caloCondition->setGtCorrParDeltaPhiNrBins(
                            (m_gtEtaPhiConversions->gtObjectNrBinsPhi(
                                    ((itCond->second)->objectType())[0])) / 2
                                    + 1);
                    caloCondition->evaluateConditionStoreResult();

                    cMapResults[itCond->first] = caloCondition;

                    if (m_verbosity && m_isDebugEnabled) {
                        std::ostringstream myCout;
                        caloCondition->print(myCout);

                        LogTrace("L1GlobalTrigger") << myCout.str() << std::endl;
                    }
                    //                    delete caloCondition;

                }
                    break;
                case CondEnergySum: {
                    L1GtEnergySumCondition* eSumCondition = new L1GtEnergySumCondition(
                            itCond->second, ptrGtPSB);

                    eSumCondition->setVerbosity(m_verbosity);
                    eSumCondition->evaluateConditionStoreResult();

                    cMapResults[itCond->first] = eSumCondition;

                    if (m_verbosity && m_isDebugEnabled) {
                        std::ostringstream myCout;
                        eSumCondition->print(myCout);

                        LogTrace("L1GlobalTrigger") << myCout.str() << std::endl;
                    }
                    //                    delete eSumCondition;

                }
                    break;
                case CondJetCounts: {
                    L1GtJetCountsCondition* jcCondition = new L1GtJetCountsCondition(
                            itCond->second, ptrGtPSB, nrL1JetCounts);

                    jcCondition->setVerbosity(m_verbosity);
                    jcCondition->evaluateConditionStoreResult();

                    cMapResults[itCond->first] = jcCondition;

                    if (m_verbosity && m_isDebugEnabled) {
                        std::ostringstream myCout;
                        jcCondition->print(myCout);

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

                    //                  delete jcCondition;

                }
                    break;
                case CondHfBitCounts: {
                    L1GtHfBitCountsCondition* bcCondition = new L1GtHfBitCountsCondition(
                            itCond->second, ptrGtPSB);

                    bcCondition->setVerbosity(m_verbosity);
                    bcCondition->evaluateConditionStoreResult();

                    cMapResults[itCond->first] = bcCondition;

                    if (m_isDebugEnabled ) {
                        std::ostringstream myCout;
                        bcCondition->print(myCout);

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

                    //                  delete bcCondition;

                }
                    break;
                case CondHfRingEtSums: {
                    L1GtHfRingEtSumsCondition* etCondition = new L1GtHfRingEtSumsCondition(
                            itCond->second, ptrGtPSB);

                    etCondition->setVerbosity(m_verbosity);
                    etCondition->evaluateConditionStoreResult();

                    cMapResults[itCond->first] = etCondition;

                    if (m_verbosity && m_isDebugEnabled) {
                        std::ostringstream myCout;
                        etCondition->print(myCout);

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

                    //                  delete etCondition;

                }
                    break;
                case CondCastor: {
                    bool castorCondResult = false;

                    // FIXME need a solution to read CASTOR
                    //if (castorConditionFlag) {
                    //    castorCondResult = castorData->conditionResult(itCond->first);
                    //}

                    L1GtCastorCondition* castorCondition = new L1GtCastorCondition(
                            itCond->second, castorCondResult);

                    castorCondition->setVerbosity(m_verbosity);
                    castorCondition->evaluateConditionStoreResult();

                    cMapResults[itCond->first] = castorCondition;

                    if (m_verbosity && m_isDebugEnabled) {
                        std::ostringstream myCout;
                        castorCondition->print(myCout);

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

                    //                  delete castorCondition;

                }
                    break;
                case CondBptx: {
                    bool bptxCondResult = true;

                    // FIXME need a solution to read BPTX with real value

                    L1GtBptxCondition* bptxCondition = new L1GtBptxCondition(
                            itCond->second, bptxCondResult);

                    bptxCondition->setVerbosity(m_verbosity);
                    bptxCondition->evaluateConditionStoreResult();

                    cMapResults[itCond->first] = bptxCondition;

                    if (m_verbosity && m_isDebugEnabled) {
                        std::ostringstream myCout;
                        bptxCondition->print(myCout);

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

                    //                  delete bptxCondition;

                }
                    break;
                case CondExternal: {
                    bool externalCondResult = true;

                    // FIXME need a solution to read External with real value

                    L1GtExternalCondition* externalCondition = new L1GtExternalCondition(
                            itCond->second, externalCondResult);

                    externalCondition->setVerbosity(m_verbosity);
                    externalCondition->evaluateConditionStoreResult();

                    cMapResults[itCond->first] = externalCondition;

                    if (m_verbosity && m_isDebugEnabled) {
                        std::ostringstream myCout;
                        externalCondition->print(myCout);

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

                    //                  delete externalCondition;

                }
                    break;
                case CondCorrelation: {

                    // get first the sub-conditions
                    const L1GtCorrelationTemplate* corrTemplate =
                        static_cast<const L1GtCorrelationTemplate*>(itCond->second);
                    const L1GtConditionCategory cond0Categ = corrTemplate->cond0Category();
                    const L1GtConditionCategory cond1Categ = corrTemplate->cond1Category();
                    const int cond0Ind = corrTemplate->cond0Index();
                    const int cond1Ind = corrTemplate->cond1Index();

                    const L1GtCondition* cond0Condition = 0;
                    const L1GtCondition* cond1Condition = 0;

                    // maximum number of objects received for evaluation of Type1s condition
                    int cond0NrL1Objects = 0;
                    int cond1NrL1Objects = 0;

                    int cond0EtaBits = 0;
                    int cond1EtaBits = 0;

                    switch (cond0Categ) {
                        case CondMuon: {
                            cond0Condition = &((corrMuon[iChip])[cond0Ind]);
                            cond0NrL1Objects = nrL1Mu;
                            cond0EtaBits = ifMuEtaNumberBits;
                        }
                            break;
                        case CondCalo: {
                            cond0Condition = &((corrCalo[iChip])[cond0Ind]);

                            switch ((cond0Condition->objectType())[0]) {
                                case NoIsoEG:
                                    cond0NrL1Objects= nrL1NoIsoEG;
                                    break;
                                case IsoEG:
                                    cond0NrL1Objects = nrL1IsoEG;
                                    break;
                                case CenJet:
                                    cond0NrL1Objects = nrL1CenJet;
                                    break;
                                case ForJet:
                                    cond0NrL1Objects = nrL1ForJet;
                                    break;
                                case TauJet:
                                    cond0NrL1Objects = nrL1TauJet;
                                    break;
                                default:
                                    cond0NrL1Objects = 0;
                                    break;
                            }

                            cond0EtaBits = ifCaloEtaNumberBits;
                        }
                            break;
                        case CondEnergySum: {
                            cond0Condition = &((corrEnergySum[iChip])[cond0Ind]);
                            cond0NrL1Objects = 1;
                        }
                            break;
                        default: {
                            // do nothing, should not arrive here
                        }
                            break;
                    }

                    switch (cond1Categ) {
                        case CondMuon: {
                            cond1Condition = &((corrMuon[iChip])[cond1Ind]);
                            cond1NrL1Objects = nrL1Mu;
                            cond1EtaBits = ifMuEtaNumberBits;
                        }
                            break;
                        case CondCalo: {
                            cond1Condition = &((corrCalo[iChip])[cond1Ind]);

                            switch ((cond1Condition->objectType())[0]) {
                                case NoIsoEG:
                                    cond1NrL1Objects= nrL1NoIsoEG;
                                    break;
                                case IsoEG:
                                    cond1NrL1Objects = nrL1IsoEG;
                                    break;
                                case CenJet:
                                    cond1NrL1Objects = nrL1CenJet;
                                    break;
                                case ForJet:
                                    cond1NrL1Objects = nrL1ForJet;
                                    break;
                                case TauJet:
                                    cond1NrL1Objects = nrL1TauJet;
                                    break;
                                default:
                                    cond1NrL1Objects = 0;
                                    break;
                            }

                             cond1EtaBits = ifCaloEtaNumberBits;
                        }
                            break;
                        case CondEnergySum: {
                            cond1Condition = &((corrEnergySum[iChip])[cond1Ind]);
                            cond1NrL1Objects = 1;
                        }
                            break;
                        default: {
                            // do nothing, should not arrive here
                        }
                            break;
                    }

                    L1GtCorrelationCondition* correlationCond =
                        new L1GtCorrelationCondition(itCond->second,
                            cond0Condition, cond1Condition,
                            cond0NrL1Objects, cond1NrL1Objects,
                            cond0EtaBits, cond1EtaBits,
                            this, ptrGtPSB, m_gtEtaPhiConversions);

                    correlationCond->setVerbosity(m_verbosity);
                    correlationCond->evaluateConditionStoreResult();

                    cMapResults[itCond->first] = correlationCond;

                    if (m_verbosity && m_isDebugEnabled) {
                        std::ostringstream myCout;
                        correlationCond->print(myCout);

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

                    //                  delete correlationCond;

                }
                    break;
                case CondNull: {

                    // do nothing

                }
                    break;
                default: {

                    // do nothing

                }
                    break;
            }

        }

    }

    // loop over algorithm map

    // empty vector for object maps - filled during loop
    std::vector<L1GlobalTriggerObjectMap> objMapVec;
    if (produceL1GtObjectMapRecord && (iBxInEvent == 0)) objMapVec.reserve(numberPhysTriggers);

    for (CItAlgo itAlgo = algorithmMap.begin(); itAlgo != algorithmMap.end(); itAlgo++) {

        L1GtAlgorithmEvaluation gtAlg(itAlgo->second);
        gtAlg.evaluateAlgorithm((itAlgo->second).algoChipNumber(), m_conditionResultMaps);

        int algBitNumber = (itAlgo->second).algoBitNumber();
        bool algResult = gtAlg.gtAlgoResult();

        if (algResult) {
            m_gtlAlgorithmOR.set(algBitNumber);
        }

        if (m_verbosity && m_isDebugEnabled) {
            std::ostringstream myCout;
            ( itAlgo->second ).print(myCout);
            gtAlg.print(myCout);

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


        // object maps only for BxInEvent = 0
        if (produceL1GtObjectMapRecord && (iBxInEvent == 0)) {

            // set object map
            L1GlobalTriggerObjectMap objMap;

            objMap.setAlgoName(itAlgo->first);
            objMap.setAlgoBitNumber(algBitNumber);
            objMap.setAlgoGtlResult(algResult);
            objMap.swapOperandTokenVector(gtAlg.operandTokenVector());
            objMap.swapCombinationVector(gtAlg.gtAlgoCombinationVector());
        // gtAlg is empty now...

            if (m_verbosity && m_isDebugEnabled) {
                std::ostringstream myCout1;
                objMap.print(myCout1);

                LogTrace("L1GlobalTrigger") << myCout1.str() << std::endl;
            }

            objMapVec.push_back(objMap);

        }


    }

    // object maps only for BxInEvent = 0
    if (produceL1GtObjectMapRecord && (iBxInEvent == 0)) {
        gtObjectMapRecord->swapGtObjectMap(objMapVec);
    }

    // loop over condition maps (one map per condition chip)
    // then loop over conditions in the map
    // delete the conditions created with new, zero pointer, do not clear map, keep the vector as is...
    for (std::vector<L1GtAlgorithmEvaluation::ConditionEvaluationMap>::iterator
            itCondOnChip  = m_conditionResultMaps.begin();
            itCondOnChip != m_conditionResultMaps.end(); itCondOnChip++) {

        for (L1GtAlgorithmEvaluation::ItEvalMap
                itCond  = itCondOnChip->begin();
                itCond != itCondOnChip->end(); itCond++) {

            delete itCond->second;
            itCond->second = 0;
        }
    }

}

void L1GlobalTriggerGTL::setVerbosity ( const int  verbosity )

inline

Definition at line 110 of file L1GlobalTriggerGTL.h.

References m_verbosity, and HLT_25ns14e33_v1_cff::verbosity.

Referenced by L1GlobalTrigger::L1GlobalTrigger().

                                                  {
        m_verbosity = verbosity;
    }

Member Data Documentation

std::vector<const L1MuGMTCand*>* L1GlobalTriggerGTL::m_candL1Mu

private

Definition at line 134 of file L1GlobalTriggerGTL.h.

Referenced by getCandL1Mu(), init(), printGmtData(), reset(), and ~L1GlobalTriggerGTL().

std::vector<L1GtAlgorithmEvaluation::ConditionEvaluationMap> L1GlobalTriggerGTL::m_conditionResultMaps

private

Definition at line 140 of file L1GlobalTriggerGTL.h.

Referenced by run().

L1GtEtaPhiConversions* L1GlobalTriggerGTL::m_gtEtaPhiConversions

private

Definition at line 130 of file L1GlobalTriggerGTL.h.

Referenced by L1GlobalTriggerGTL(), run(), and ~L1GlobalTriggerGTL().

std::bitset<L1GlobalTriggerReadoutSetup::NumberPhysTriggers> L1GlobalTriggerGTL::m_gtlAlgorithmOR

private

Definition at line 136 of file L1GlobalTriggerGTL.h.

Referenced by getAlgorithmOR(), L1GlobalTriggerGTL(), reset(), and run().

std::bitset<L1GlobalTriggerReadoutSetup::NumberPhysTriggers> L1GlobalTriggerGTL::m_gtlDecisionWord

private

Definition at line 137 of file L1GlobalTriggerGTL.h.

Referenced by getDecisionWord(), L1GlobalTriggerGTL(), and reset().

bool L1GlobalTriggerGTL::m_isDebugEnabled

private

Definition at line 147 of file L1GlobalTriggerGTL.h.

Referenced by receiveGmtObjectData(), and run().

const L1CaloGeometry* L1GlobalTriggerGTL::m_l1CaloGeometry

private

Definition at line 123 of file L1GlobalTriggerGTL.h.

Referenced by run().

unsigned long long L1GlobalTriggerGTL::m_l1CaloGeometryCacheID

private

Definition at line 124 of file L1GlobalTriggerGTL.h.

Referenced by L1GlobalTriggerGTL(), and run().

const L1GtTriggerMenu* L1GlobalTriggerGTL::m_l1GtMenu

private

Definition at line 119 of file L1GlobalTriggerGTL.h.

Referenced by run().

unsigned long long L1GlobalTriggerGTL::m_l1GtMenuCacheID

private

Definition at line 120 of file L1GlobalTriggerGTL.h.

Referenced by L1GlobalTriggerGTL(), and run().

const L1MuTriggerScales* L1GlobalTriggerGTL::m_l1MuTriggerScales

private

Definition at line 126 of file L1GlobalTriggerGTL.h.

Referenced by run().

unsigned long long L1GlobalTriggerGTL::m_l1MuTriggerScalesCacheID

private

Definition at line 127 of file L1GlobalTriggerGTL.h.

Referenced by L1GlobalTriggerGTL(), and run().

int L1GlobalTriggerGTL::m_verbosity

private

verbosity level

Definition at line 146 of file L1GlobalTriggerGTL.h.

Referenced by L1GlobalTriggerGTL(), receiveGmtObjectData(), run(), and setVerbosity().