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, 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 45 of file L1GlobalTriggerGTL.h.

Constructor & Destructor Documentation

L1GlobalTriggerGTL()

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

Definition at line 77 of file L1GlobalTriggerGTL.cc.

    : 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);
}

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

~L1GlobalTriggerGTL()

L1GlobalTriggerGTL::~L1GlobalTriggerGTL ( )

virtual

Definition at line 95 of file L1GlobalTriggerGTL.cc.

                                        {
  reset();
  delete m_candL1Mu;
  delete m_gtEtaPhiConversions;
}

References m_candL1Mu, m_gtEtaPhiConversions, and reset().

Member Function Documentation

getAlgorithmOR()

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

inline

return algorithm OR decision

Definition at line 91 of file L1GlobalTriggerGTL.h.

                                                                                                {
    return m_gtlAlgorithmOR;
  }

References m_gtlAlgorithmOR.

Referenced by L1GlobalTriggerFDL::run().

getCandL1Mu()

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

inline

return global muon trigger candidate

Definition at line 96 of file L1GlobalTriggerGTL.h.

{ return m_candL1Mu; }

References m_candL1Mu.

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

getDecisionWord()

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

inline

return decision

Definition at line 86 of file L1GlobalTriggerGTL.h.

                                                                                                 {
    return m_gtlDecisionWord;
  }

References m_gtlDecisionWord.

init()

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

initialize the class (mainly reserve)

Definition at line 102 of file L1GlobalTriggerGTL.cc.

                                                                            {
  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);
}

References m_candL1Mu.

Referenced by L1GlobalTrigger::produce().

printGmtData()

void L1GlobalTriggerGTL::printGmtData

(

const int

iBxInEvent

)

const

print received Muon dataWord

Definition at line 666 of file L1GlobalTriggerGTL.cc.

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

References LogTrace, and m_candL1Mu.

Referenced by receiveGmtObjectData().

receiveGmtObjectData()

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 116 of file L1GlobalTriggerGTL.cc.

                                                                {
  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);
  }
}

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

Referenced by L1GlobalTrigger::produce().

reset()

void L1GlobalTriggerGTL::reset

(

void

)

clear GTL

Definition at line 658 of file L1GlobalTriggerGTL.cc.

                               {
  m_candL1Mu->clear();
 
  m_gtlDecisionWord.reset();
  m_gtlAlgorithmOR.reset();
}

References m_candL1Mu, m_gtlAlgorithmOR, and m_gtlDecisionWord.

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

run()

void L1GlobalTriggerGTL::run	(	edm::Event &	iEvent,
		const edm::EventSetup &	evSetup,
		const L1GlobalTriggerPSB *	ptrGtPSB,
		const bool	produceL1GtObjectMapRecord,
		const int	iBxInEvent,
		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 158 of file L1GlobalTriggerGTL.cc.

                                                            {
  // 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 = nullptr;
          const L1GtCondition *cond1Condition = nullptr;
 
          // 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 = nullptr;
    }
  }
}

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(), 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(), L1GtHfBitCountsCondition::print(), L1GtHfRingEtSumsCondition::print(), L1GtCastorCondition::print(), L1GtBptxCondition::print(), L1GtExternalCondition::print(), L1GtJetCountsCondition::print(), L1GtEnergySumCondition::print(), L1GtMuonCondition::print(), L1GtCaloCondition::print(), edm::print(), L1GtCorrelationCondition::print(), L1GtEtaPhiConversions::print(), L1GtAlgorithmEvaluation::print(), L1GlobalTriggerObjectMap::print(), edm::ESHandle< T >::product(), L1GlobalTriggerObjectMap::setAlgoBitNumber(), L1GlobalTriggerObjectMap::setAlgoGtlResult(), L1GlobalTriggerObjectMap::setAlgoName(), L1GtMuonCondition::setGtCorrParDeltaPhiNrBins(), L1GtCaloCondition::setGtCorrParDeltaPhiNrBins(), L1GtEtaPhiConversions::setVerbosity(), L1GtConditionEvaluation::setVerbosity(), L1GlobalTriggerObjectMap::swapCombinationVector(), L1GlobalTriggerObjectMapRecord::swapGtObjectMap(), L1GlobalTriggerObjectMap::swapOperandTokenVector(), and TauJet.

Referenced by L1GlobalTrigger::produce().

setVerbosity()

void L1GlobalTriggerGTL::setVerbosity ( const int  verbosity )

inline

Definition at line 99 of file L1GlobalTriggerGTL.h.

{ m_verbosity = verbosity; }

References m_verbosity, and HIPAlignmentAlgorithm_cfi::verbosity.

Referenced by L1GlobalTrigger::L1GlobalTrigger().

Member Data Documentation

m_candL1Mu

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

private

Definition at line 119 of file L1GlobalTriggerGTL.h.

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

m_conditionResultMaps

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

private

Definition at line 125 of file L1GlobalTriggerGTL.h.

Referenced by run().

m_gtEtaPhiConversions

L1GtEtaPhiConversions* L1GlobalTriggerGTL::m_gtEtaPhiConversions

private

Definition at line 116 of file L1GlobalTriggerGTL.h.

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

m_gtlAlgorithmOR

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

private

Definition at line 121 of file L1GlobalTriggerGTL.h.

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

m_gtlDecisionWord

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

private

Definition at line 122 of file L1GlobalTriggerGTL.h.

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

m_isDebugEnabled

bool L1GlobalTriggerGTL::m_isDebugEnabled

private

Definition at line 130 of file L1GlobalTriggerGTL.h.

Referenced by receiveGmtObjectData(), and run().

m_l1CaloGeometry

const L1CaloGeometry* L1GlobalTriggerGTL::m_l1CaloGeometry

private

Definition at line 109 of file L1GlobalTriggerGTL.h.

Referenced by run().

m_l1CaloGeometryCacheID

unsigned long long L1GlobalTriggerGTL::m_l1CaloGeometryCacheID

private

Definition at line 110 of file L1GlobalTriggerGTL.h.

Referenced by L1GlobalTriggerGTL(), and run().

m_l1GtMenu

const L1GtTriggerMenu* L1GlobalTriggerGTL::m_l1GtMenu

private

Definition at line 105 of file L1GlobalTriggerGTL.h.

Referenced by run().

m_l1GtMenuCacheID

unsigned long long L1GlobalTriggerGTL::m_l1GtMenuCacheID

private

Definition at line 106 of file L1GlobalTriggerGTL.h.

Referenced by L1GlobalTriggerGTL(), and run().

m_l1MuTriggerScales

const L1MuTriggerScales* L1GlobalTriggerGTL::m_l1MuTriggerScales

private

Definition at line 112 of file L1GlobalTriggerGTL.h.

Referenced by run().

m_l1MuTriggerScalesCacheID

unsigned long long L1GlobalTriggerGTL::m_l1MuTriggerScalesCacheID

private

Definition at line 113 of file L1GlobalTriggerGTL.h.

Referenced by L1GlobalTriggerGTL(), and run().

m_verbosity

int L1GlobalTriggerGTL::m_verbosity

private

verbosity level

Definition at line 129 of file L1GlobalTriggerGTL.h.

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