l1t::GlobalBoard Class Reference

#include <GlobalBoard.h>

Classes
struct	PrescaleCounter

Public Member Functions
void	fillAlgRecord (int iBxInEvent, std::unique_ptr< GlobalAlgBlkBxCollection > &uGtAlgRecord, int prescaleSet, int menuUUID, int firmwareUUID)
	Fill the Daq Records. More...
const std::bitset< GlobalAlgBlk::maxPhysicsTriggers > &	getAlgorithmOR () const
	return algorithm OR decision More...
const BXVector< const l1t::L1Candidate * > *	getCandL1EG () const
	pointer to EG data list More...
const BXVector< const l1t::EtSum * > *	getCandL1EtSum () const
	pointer to Tau data list More...
const BXVector< const GlobalExtBlk * > *	getCandL1External () const
	pointer to Tau data list More...
const BXVector< const l1t::L1Candidate * > *	getCandL1Jet () const
	pointer to Jet data list More...
const BXVector< const l1t::Muon * > *	getCandL1Mu () const
	return global muon trigger candidate More...
const BXVector< std::shared_ptr< l1t::MuonShower > > *	getCandL1MuShower () const
	return global muon trigger candidate More...
const BXVector< const l1t::L1Candidate * > *	getCandL1Tau () const
	pointer to Tau data list More...
const std::bitset< GlobalAlgBlk::maxPhysicsTriggers > &	getDecisionWord () const
	return decision More...
	GlobalBoard ()
void	init (const int numberPhysTriggers, const int nrL1Mu, const int nrL1MuShower, const int nrL1EG, const int nrL1Tau, const int nrL1Jet, int bxFirst, int bxLast)
	initialize the class (mainly reserve) More...
void	printGmtData (const int iBxInEvent) const
	print received Muon dataWord More...
void	receiveCaloObjectData (const edm::Event &, const edm::EDGetTokenT< BXVector< l1t::EGamma >> &, const edm::EDGetTokenT< BXVector< l1t::Tau >> &, const edm::EDGetTokenT< BXVector< l1t::Jet >> &, const edm::EDGetTokenT< BXVector< l1t::EtSum >> &, const bool receiveEG, const int nrL1EG, const bool receiveTau, const int nrL1Tau, const bool receiveJet, const int nrL1Jet, const bool receiveEtSums)
	receive data from Global Muon Trigger More...
void	receiveExternalData (const edm::Event &, const edm::EDGetTokenT< BXVector< GlobalExtBlk >> &, const bool receiveExt)
void	receiveMuonObjectData (const edm::Event &, const edm::EDGetTokenT< BXVector< l1t::Muon >> &, const bool receiveMu, const int nrL1Mu)
void	receiveMuonShowerObjectData (const edm::Event &, const edm::EDGetTokenT< BXVector< l1t::MuonShower >> &, const bool receiveMuShower, const int nrL1MuShower)
void	reset ()
	clear uGT More...
void	resetCalo ()
void	resetExternal ()
void	resetMu ()
void	resetMuonShower ()
void	runFDL (const edm::Event &iEvent, const int iBxInEvent, const int totalBxInEvent, const unsigned int numberPhysTriggers, const std::vector< double > &prescaleFactorsAlgoTrig, const std::vector< unsigned int > &triggerMaskAlgoTrig, const std::vector< int > &triggerMaskVetoAlgoTrig, const bool algorithmTriggersUnprescaled, const bool algorithmTriggersUnmasked)
	run the uGT FDL (Apply Prescales and Veto) More...
void	runGTL (const edm::Event &iEvent, const edm::EventSetup &evSetup, const TriggerMenu *m_l1GtMenu, const bool produceL1GtObjectMapRecord, const int iBxInEvent, std::unique_ptr< GlobalObjectMapRecord > &gtObjectMapRecord, const unsigned int numberPhysTriggers, const int nrL1Mu, const int nrL1MuShower, const int nrL1EG, const int nrL1Tau, const int nrL1Jet)
	run the uGT GTL (Conditions and Algorithms) More...
void	setBxFirst (int bx)
void	setBxLast (int bx)
void	setResetPSCountersEachLumiSec (bool val)
void	setSemiRandomInitialPSCounters (bool val)
void	setVerbosity (const int verbosity)
virtual	~GlobalBoard ()

Static Private Member Functions
static std::vector< PrescaleCounter >	prescaleCounters (std::vector< double > const &prescaleFactorsAlgoTrig)
static std::vector< PrescaleCounter >	prescaleCountersWithSemirandomInitialCounter (std::vector< double > const &prescaleFactorsAlgoTrig, edm::Event const &iEvent)

Private Attributes
bool	m_algFinalOr
bool	m_algFinalOrVeto
bool	m_algInitialOr
bool	m_algIntermOr
bool	m_algPrescaledOr
unsigned int	m_boardEventCount
int	m_bxFirst_
int	m_bxLast_
BXVector< const l1t::L1Candidate * > *	m_candL1EG
BXVector< const l1t::EtSum * > *	m_candL1EtSum
BXVector< const GlobalExtBlk * > *	m_candL1External
BXVector< const l1t::L1Candidate * > *	m_candL1Jet
BXVector< const l1t::Muon * > *	m_candL1Mu
BXVector< std::shared_ptr< l1t::MuonShower > > *	m_candL1MuShower
BXVector< const l1t::L1Candidate * > *	m_candL1Tau
std::vector< AlgorithmEvaluation::ConditionEvaluationMap >	m_conditionResultMaps
unsigned int	m_currentLumi
std::bitset< GlobalAlgBlk::maxPhysicsTriggers >	m_gtlAlgorithmOR
std::bitset< GlobalAlgBlk::maxPhysicsTriggers >	m_gtlDecisionWord
bool	m_isDebugEnabled
const L1CaloGeometry *	m_l1CaloGeometry
unsigned long long	m_l1CaloGeometryCacheID
const TriggerMenu *	m_l1GtMenu
unsigned long long	m_l1GtMenuCacheID
const L1MuTriggerScales *	m_l1MuTriggerScales
unsigned long long	m_l1MuTriggerScalesCacheID
std::vector< std::vector< PrescaleCounter > >	m_prescaleCounterAlgoTrig
bool	m_resetPSCountersEachLumiSec = false
bool	m_semiRandomInitialPSCounters = false
GlobalAlgBlk	m_uGtAlgBlk
int	m_uGtBoardNumber
bool	m_uGtFinalBoard
int	m_verbosity
	verbosity level More...

Static Private Attributes
static constexpr size_t	m_singlestep = 100

Detailed Description

Definition at line 56 of file GlobalBoard.h.

Constructor & Destructor Documentation

GlobalBoard()

GlobalBoard::GlobalBoard

(

)

Definition at line 60 of file GlobalBoard.cc.

References m_boardEventCount, m_gtlAlgorithmOR, m_gtlDecisionWord, m_l1CaloGeometryCacheID, m_l1GtMenuCacheID, m_l1MuTriggerScalesCacheID, m_prescaleCounterAlgoTrig, m_uGtAlgBlk, m_uGtBoardNumber, m_uGtFinalBoard, and GlobalAlgBlk::reset().

    : m_candL1Mu(new BXVector<const l1t::Muon*>),
      m_candL1MuShower(new BXVector<std::shared_ptr<l1t::MuonShower>>),
      m_candL1EG(new BXVector<const l1t::L1Candidate*>),
      m_candL1Tau(new BXVector<const l1t::L1Candidate*>),
      m_candL1Jet(new BXVector<const l1t::L1Candidate*>),
      m_candL1EtSum(new BXVector<const l1t::EtSum*>),
      m_candL1External(new BXVector<const GlobalExtBlk*>),
      m_currentLumi(0),
      m_isDebugEnabled(edm::isDebugEnabled()) {
  m_uGtAlgBlk.reset();

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

  m_prescaleCounterAlgoTrig.clear();

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

  // Counter for number of events board sees
  m_boardEventCount = 0;

  // A single uGT GlobalBoard is taken into account in the emulator
  m_uGtBoardNumber = 0;
  m_uGtFinalBoard = true;
}

~GlobalBoard()

GlobalBoard::~GlobalBoard ( )

virtual

Definition at line 91 of file GlobalBoard.cc.

                             {
  //reset();  //why would we need a reset?
  delete m_candL1Mu;
  delete m_candL1MuShower;
  delete m_candL1EG;
  delete m_candL1Tau;
  delete m_candL1Jet;
  delete m_candL1EtSum;
  delete m_candL1External;
}

Member Function Documentation

fillAlgRecord()

void GlobalBoard::fillAlgRecord	(	int	iBxInEvent,
		std::unique_ptr< GlobalAlgBlkBxCollection > &	uGtAlgRecord,
		int	prescaleSet,
		int	menuUUID,
		int	firmwareUUID
	)

Fill the Daq Records.

Definition at line 1067 of file GlobalBoard.cc.

References LogDebug.

                                                       {
  if (m_verbosity) {
    LogDebug("L1TGlobal") << "\n**** GlobalBoard fill DAQ Records for bx= " << iBxInEvent;
  }

  // Set header information
  m_uGtAlgBlk.setbxInEventNr((iBxInEvent & 0xF));
  m_uGtAlgBlk.setPreScColumn(prescaleSet);
  m_uGtAlgBlk.setL1MenuUUID(menuUUID);
  m_uGtAlgBlk.setL1FirmwareUUID(firmwareUUID);

  m_uGtAlgBlk.setFinalORVeto(m_algFinalOrVeto);
  m_uGtAlgBlk.setFinalORPreVeto(m_algIntermOr);
  m_uGtAlgBlk.setFinalOR(m_algFinalOr);

  uGtAlgRecord->push_back(iBxInEvent, m_uGtAlgBlk);
}

getAlgorithmOR()

const std::bitset<GlobalAlgBlk::maxPhysicsTriggers>& l1t::GlobalBoard::getAlgorithmOR ( ) const

inline

return algorithm OR decision

Definition at line 147 of file GlobalBoard.h.

References m_gtlAlgorithmOR.

{ return m_gtlAlgorithmOR; }

getCandL1EG()

const BXVector<const l1t::L1Candidate*>* l1t::GlobalBoard::getCandL1EG ( ) const

inline

pointer to EG data list

Definition at line 156 of file GlobalBoard.h.

References m_candL1EG.

{ return m_candL1EG; }

getCandL1EtSum()

const BXVector<const l1t::EtSum*>* l1t::GlobalBoard::getCandL1EtSum ( ) const

inline

pointer to Tau data list

Definition at line 165 of file GlobalBoard.h.

References m_candL1EtSum.

{ return m_candL1EtSum; }

getCandL1External()

const BXVector<const GlobalExtBlk*>* l1t::GlobalBoard::getCandL1External ( ) const

inline

pointer to Tau data list

Definition at line 168 of file GlobalBoard.h.

References m_candL1External.

{ return m_candL1External; }

getCandL1Jet()

const BXVector<const l1t::L1Candidate*>* l1t::GlobalBoard::getCandL1Jet ( ) const

inline

pointer to Jet data list

Definition at line 159 of file GlobalBoard.h.

References m_candL1Jet.

{ return m_candL1Jet; }

getCandL1Mu()

const BXVector<const l1t::Muon*>* l1t::GlobalBoard::getCandL1Mu ( ) const

inline

return global muon trigger candidate

Definition at line 150 of file GlobalBoard.h.

References m_candL1Mu.

{ return m_candL1Mu; }

getCandL1MuShower()

const BXVector<std::shared_ptr<l1t::MuonShower> >* l1t::GlobalBoard::getCandL1MuShower ( ) const

inline

return global muon trigger candidate

Definition at line 153 of file GlobalBoard.h.

References m_candL1MuShower.

{ return m_candL1MuShower; }

getCandL1Tau()

const BXVector<const l1t::L1Candidate*>* l1t::GlobalBoard::getCandL1Tau ( ) const

inline

pointer to Tau data list

Definition at line 162 of file GlobalBoard.h.

References m_candL1Tau.

{ return m_candL1Tau; }

getDecisionWord()

const std::bitset<GlobalAlgBlk::maxPhysicsTriggers>& l1t::GlobalBoard::getDecisionWord ( ) const

inline

return decision

Definition at line 144 of file GlobalBoard.h.

References m_gtlDecisionWord.

{ return m_gtlDecisionWord; }

init()

void GlobalBoard::init	(	const int	numberPhysTriggers,
		const int	nrL1Mu,
		const int	nrL1MuShower,
		const int	nrL1EG,
		const int	nrL1Tau,
		const int	nrL1Jet,
		int	bxFirst,
		int	bxLast
	)

initialize the class (mainly reserve)

Definition at line 107 of file GlobalBoard.cc.

References simCaloStage2Layer1Digis_cfi::bxFirst, simCaloStage2Layer1Digis_cfi::bxLast, and LogDebug.

                                        {
  setBxFirst(bxFirst);
  setBxLast(bxLast);

  m_candL1Mu->setBXRange(m_bxFirst_, m_bxLast_);
  m_candL1MuShower->setBXRange(m_bxFirst_, m_bxLast_);
  m_candL1EG->setBXRange(m_bxFirst_, m_bxLast_);
  m_candL1Tau->setBXRange(m_bxFirst_, m_bxLast_);
  m_candL1Jet->setBXRange(m_bxFirst_, m_bxLast_);
  m_candL1EtSum->setBXRange(m_bxFirst_, m_bxLast_);
  m_candL1External->setBXRange(m_bxFirst_, m_bxLast_);

  m_uGtAlgBlk.reset();

  LogDebug("L1TGlobal") << "\t Initializing Board with bxFirst = " << m_bxFirst_ << ", bxLast = " << m_bxLast_;
}

prescaleCounters()

std::vector< l1t::GlobalBoard::PrescaleCounter > GlobalBoard::prescaleCounters ( std::vector< double > const &  prescaleFactorsAlgoTrig )

staticprivate

Definition at line 1141 of file GlobalBoard.cc.

References MillePedeFileConverter_cfg::out.

                                                      {
  std::vector<PrescaleCounter> out;
  out.reserve(prescaleFactorsAlgoTrig.size());
  for (size_t iAlgo = 0; iAlgo < prescaleFactorsAlgoTrig.size(); ++iAlgo) {
    out.emplace_back(prescaleFactorsAlgoTrig[iAlgo]);
  }
  return out;
}

prescaleCountersWithSemirandomInitialCounter()

std::vector< l1t::GlobalBoard::PrescaleCounter > GlobalBoard::prescaleCountersWithSemirandomInitialCounter ( std::vector< double > const &  prescaleFactorsAlgoTrig, edm::Event const &  iEvent  )

staticprivate

Definition at line 1152 of file GlobalBoard.cc.

References iEvent, and MillePedeFileConverter_cfg::out.

                                                                              {
  // pick a (semi)random number seeding based on run, lumi, event numbers,
  // this leads to different (semi)random numbers for different streams,
  // reminder: different streams have different initial event number
  std::srand(iEvent.id().run());
  std::srand(std::rand() + iEvent.id().luminosityBlock());
  std::srand(std::rand() + iEvent.id().event());
  int const semirandom = std::rand();

  std::vector<PrescaleCounter> out;
  out.reserve(prescaleFactorsAlgoTrig.size());

  for (size_t iAlgo = 0; iAlgo < prescaleFactorsAlgoTrig.size(); ++iAlgo) {
    out.emplace_back(prescaleFactorsAlgoTrig[iAlgo]);
    // initialise trigger_counter to a (semi)random integer
    // between 0 and prescale_count - 1 (both inclusive)
    // (this only changes the behaviour of triggers with PS > 1)
    auto& prescaleCounter = out.back();
    if (prescaleCounter.prescale_count > 0) {
      prescaleCounter.trigger_counter = semirandom % prescaleCounter.prescale_count;
    }
  }

  return out;
}

printGmtData()

void GlobalBoard::printGmtData

(

const int

iBxInEvent

)

const

print received Muon dataWord

Definition at line 1133 of file GlobalBoard.cc.

References LogTrace.

                                                            {
  LogTrace("L1TGlobal") << "\nl1t::L1GlobalTrigger: uGMT data received for BxInEvent = " << iBxInEvent;

  int nrL1Mu = m_candL1Mu->size(iBxInEvent);
  LogTrace("L1TGlobal") << "Number of GMT muons = " << nrL1Mu << "\n";
}

receiveCaloObjectData()

void GlobalBoard::receiveCaloObjectData	(	const edm::Event &	iEvent,
		const edm::EDGetTokenT< BXVector< l1t::EGamma >> &	egInputToken,
		const edm::EDGetTokenT< BXVector< l1t::Tau >> &	tauInputToken,
		const edm::EDGetTokenT< BXVector< l1t::Jet >> &	jetInputToken,
		const edm::EDGetTokenT< BXVector< l1t::EtSum >> &	sumInputToken,
		const bool	receiveEG,
		const int	nrL1EG,
		const bool	receiveTau,
		const int	nrL1Tau,
		const bool	receiveJet,
		const int	nrL1Jet,
		const bool	receiveEtSums
	)

receive data from Global Muon Trigger

Definition at line 132 of file GlobalBoard.cc.

References mps_fire::i, iEvent, edm::HandleBase::isValid(), metsig::jet, LogDebug, LogTrace, and metsig::tau.

                                                                       {
  if (m_verbosity) {
    LogDebug("L1TGlobal") << "\n**** Board receiving Calo Data ";
    //<<  "\n     from input tag " << caloInputTag << "\n"
  }

  resetCalo();

  // get data from Calorimeter
  if (receiveEG) {
    edm::Handle<BXVector<l1t::EGamma>> egData;
    iEvent.getByToken(egInputToken, egData);

    if (!egData.isValid()) {
      if (m_verbosity) {
        edm::LogWarning("L1TGlobal") << "\nWarning: BXVector<l1t::EGamma> with input tag "
                                     //<< caloInputTag
                                     << "\nrequested in configuration, but not found in the event.\n";
      }
    } else {
      // bx in EG data
      for (int i = egData->getFirstBX(); i <= egData->getLastBX(); ++i) {
        // Prevent from pushing back bx that is outside of allowed range
        if (i < m_bxFirst_ || i > m_bxLast_)
          continue;

        //Loop over EG in this bx
        int nObj = 0;
        for (std::vector<l1t::EGamma>::const_iterator eg = egData->begin(i); eg != egData->end(i); ++eg) {
          if (nObj < nrL1EG) {
            (*m_candL1EG).push_back(i, &(*eg));
          } else {
            edm::LogWarning("L1TGlobal") << " Too many EG (" << nObj << ") for uGT Configuration maxEG =" << nrL1EG;
          }
          LogDebug("L1TGlobal") << "EG  Pt " << eg->hwPt() << " Eta  " << eg->hwEta() << " Phi " << eg->hwPhi()
                                << "  Qual " << eg->hwQual() << "  Iso " << eg->hwIso();

          nObj++;
        }  //end loop over EG in bx
      }    //end loop over bx
    }      //end if over valid EG data
  }        //end if ReceiveEG data

  if (receiveTau) {
    edm::Handle<BXVector<l1t::Tau>> tauData;
    iEvent.getByToken(tauInputToken, tauData);

    if (!tauData.isValid()) {
      if (m_verbosity) {
        edm::LogWarning("L1TGlobal") << "\nWarning: BXVector<l1t::Tau> with input tag "
                                     //<< caloInputTag
                                     << "\nrequested in configuration, but not found in the event.\n";
      }
    } else {
      // bx in tau data
      for (int i = tauData->getFirstBX(); i <= tauData->getLastBX(); ++i) {
        // Prevent from pushing back bx that is outside of allowed range
        if (i < m_bxFirst_ || i > m_bxLast_)
          continue;

        //Loop over tau in this bx
        int nObj = 0;
        for (std::vector<l1t::Tau>::const_iterator tau = tauData->begin(i); tau != tauData->end(i); ++tau) {
          if (nObj < nrL1Tau) {
            (*m_candL1Tau).push_back(i, &(*tau));
          } else {
            LogTrace("L1TGlobal") << " Too many Tau (" << nObj << ") for uGT Configuration maxTau =" << nrL1Tau;
          }

          LogDebug("L1TGlobal") << "tau  Pt " << tau->hwPt() << " Eta  " << tau->hwEta() << " Phi " << tau->hwPhi()
                                << "  Qual " << tau->hwQual() << "  Iso " << tau->hwIso();
          nObj++;

        }  //end loop over tau in bx
      }    //end loop over bx
    }      //end if over valid tau data
  }        //end if ReceiveTau data

  if (receiveJet) {
    edm::Handle<BXVector<l1t::Jet>> jetData;
    iEvent.getByToken(jetInputToken, jetData);

    if (!jetData.isValid()) {
      if (m_verbosity) {
        edm::LogWarning("L1TGlobal") << "\nWarning: BXVector<l1t::Jet> with input tag "
                                     //<< caloInputTag
                                     << "\nrequested in configuration, but not found in the event.\n";
      }
    } else {
      // bx in jet data
      for (int i = jetData->getFirstBX(); i <= jetData->getLastBX(); ++i) {
        // Prevent from pushing back bx that is outside of allowed range
        if (i < m_bxFirst_ || i > m_bxLast_)
          continue;

        //Loop over jet in this bx
        int nObj = 0;
        for (std::vector<l1t::Jet>::const_iterator jet = jetData->begin(i); jet != jetData->end(i); ++jet) {
          if (nObj < nrL1Jet) {
            (*m_candL1Jet).push_back(i, &(*jet));
          } else {
            edm::LogWarning("L1TGlobal") << " Too many Jets (" << nObj << ") for uGT Configuration maxJet =" << nrL1Jet;
          }

          LogDebug("L1TGlobal") << "Jet  Pt " << jet->hwPt() << " Eta  " << jet->hwEta() << " Phi " << jet->hwPhi()
                                << "  Qual " << jet->hwQual() << "  Iso " << jet->hwIso();
          nObj++;
        }  //end loop over jet in bx
      }    //end loop over bx
    }      //end if over valid jet data
  }        //end if ReceiveJet data

  if (receiveEtSums) {
    edm::Handle<BXVector<l1t::EtSum>> etSumData;
    iEvent.getByToken(sumInputToken, etSumData);

    if (!etSumData.isValid()) {
      if (m_verbosity) {
        edm::LogWarning("L1TGlobal") << "\nWarning: BXVector<l1t::EtSum> with input tag "
                                     //<< caloInputTag
                                     << "\nrequested in configuration, but not found in the event.\n";
      }
    } else {
      for (int i = etSumData->getFirstBX(); i <= etSumData->getLastBX(); ++i) {
        // Prevent from pushing back bx that is outside of allowed range
        if (i < m_bxFirst_ || i > m_bxLast_)
          continue;

        //Loop over jet in this bx
        for (std::vector<l1t::EtSum>::const_iterator etsum = etSumData->begin(i); etsum != etSumData->end(i); ++etsum) {
          (*m_candL1EtSum).push_back(i, &(*etsum));

          /*  In case we need to split these out
              switch ( etsum->getType() ) {
             case l1t::EtSum::EtSumType::kMissingEt:
               {
             //(*m_candETM).push_back(i,&(*etsum));
             LogDebug("L1TGlobal") << "ETM:  Pt " << etsum->hwPt() <<  " Phi " << etsum->hwPhi();
               }
               break; 
             case l1t::EtSum::EtSumType::kMissingHt:
               {
             //(*m_candHTM).push_back(i,&(*etsum));
             LogDebug("L1TGlobal") << "HTM:  Pt " << etsum->hwPt() <<  " Phi " << etsum->hwPhi();
               }
               break;            
             case l1t::EtSum::EtSumType::kTotalEt:
               {
             //(*m_candETT).push_back(i,&(*etsum));
             LogDebug("L1TGlobal") << "ETT:  Pt " << etsum->hwPt();
               }
               break;            
             case l1t::EtSum::EtSumType::kTotalHt:
               {
             //(*m_candHTT).push_back(i,&(*etsum));
             LogDebug("L1TGlobal") << "HTT:  Pt " << etsum->hwPt();
               }
               break;
             case l1t::EtSum::EtSumType::kTowerCount:
               {
             //(*m_candTowerCount).push_back(i,&(*etsum));
             LogDebug("L1TGlobal") << "TowerCount: " << etsum->hwPt();
               }
               break;
             default:
               LogDebug("L1TGlobal") << "Default encounted ";
               break;
          }
*/

        }  //end loop over jet in bx
      }    //end loop over Bx
    }
  }
}

receiveExternalData()

void GlobalBoard::receiveExternalData	(	const edm::Event &	iEvent,
		const edm::EDGetTokenT< BXVector< GlobalExtBlk >> &	extInputToken,
		const bool	receiveExt
	)

Definition at line 432 of file GlobalBoard.cc.

References mps_fire::i, iEvent, edm::HandleBase::isValid(), and LogDebug.

                                                                  {
  if (m_verbosity) {
    LogDebug("L1TGlobal") << "\n**** GlobalBoard receiving external data = ";
    //<< "\n     from input tag " << muInputTag << "\n"
  }

  resetExternal();

  // get data from Global Muon Trigger
  if (receiveExt) {
    edm::Handle<BXVector<GlobalExtBlk>> extData;
    iEvent.getByToken(extInputToken, extData);

    if (!extData.isValid()) {
      if (m_verbosity) {
        edm::LogWarning("L1TGlobal") << "\nWarning: BXVector<GlobalExtBlk> with input tag "
                                     //<< muInputTag
                                     << "\nrequested in configuration, but not found in the event.\n";
      }
    } else {
      // bx in muon data
      for (int i = extData->getFirstBX(); i <= extData->getLastBX(); ++i) {
        // Prevent from pushing back bx that is outside of allowed range
        if (i < m_bxFirst_ || i > m_bxLast_)
          continue;

        //Loop over ext in this bx
        for (std::vector<GlobalExtBlk>::const_iterator ext = extData->begin(i); ext != extData->end(i); ++ext) {
          (*m_candL1External).push_back(i, &(*ext));
        }  //end loop over ext in bx
      }    //end loop over bx
    }      //end if over valid ext data
  }        //end if ReceiveExt data
}

receiveMuonObjectData()

void GlobalBoard::receiveMuonObjectData	(	const edm::Event &	iEvent,
		const edm::EDGetTokenT< BXVector< l1t::Muon >> &	muInputToken,
		const bool	receiveMu,
		const int	nrL1Mu
	)

Definition at line 320 of file GlobalBoard.cc.

References mps_fire::i, iEvent, edm::HandleBase::isValid(), LogDebug, and amptDefaultParameters_cff::mu.

                                                               {
  if (m_verbosity) {
    LogDebug("L1TGlobal") << "\n**** GlobalBoard receiving muon data = ";
    //<< "\n     from input tag " << muInputTag << "\n"
  }

  resetMu();

  // get data from Global Muon Trigger
  if (receiveMu) {
    edm::Handle<BXVector<l1t::Muon>> muonData;
    iEvent.getByToken(muInputToken, muonData);

    if (!muonData.isValid()) {
      if (m_verbosity) {
        edm::LogWarning("L1TGlobal") << "\nWarning: BXVector<l1t::Muon> with input tag "
                                     //<< muInputTag
                                     << "\nrequested in configuration, but not found in the event.\n";
      }
    } else {
      // bx in muon data
      for (int i = muonData->getFirstBX(); i <= muonData->getLastBX(); ++i) {
        // Prevent from pushing back bx that is outside of allowed range
        if (i < m_bxFirst_ || i > m_bxLast_)
          continue;

        //Loop over Muons in this bx
        int nObj = 0;
        for (std::vector<l1t::Muon>::const_iterator mu = muonData->begin(i); mu != muonData->end(i); ++mu) {
          if (nObj < nrL1Mu) {
            (*m_candL1Mu).push_back(i, &(*mu));
          } else {
            edm::LogWarning("L1TGlobal") << " Too many Muons (" << nObj << ") for uGT Configuration maxMu =" << nrL1Mu;
          }

          LogDebug("L1TGlobal") << "Muon  Pt " << mu->hwPt() << " EtaAtVtx  " << mu->hwEtaAtVtx() << " PhiAtVtx "
                                << mu->hwPhiAtVtx() << "  Qual " << mu->hwQual() << "  Iso " << mu->hwIso();
          nObj++;
        }  //end loop over muons in bx
      }    //end loop over bx
    }      //end if over valid muon data
  }        //end if ReceiveMuon data
}

receiveMuonShowerObjectData()

void GlobalBoard::receiveMuonShowerObjectData	(	const edm::Event &	iEvent,
		const edm::EDGetTokenT< BXVector< l1t::MuonShower >> &	muShowerInputToken,
		const bool	receiveMuShower,
		const int	nrL1MuShower
	)

Definition at line 368 of file GlobalBoard.cc.

References mps_fire::i, iEvent, edm::HandleBase::isValid(), and amptDefaultParameters_cff::mu.

                                                                           {
  // get data from Global Muon Trigger
  if (receiveMuShower) {
    edm::Handle<BXVector<l1t::MuonShower>> muonData;
    iEvent.getByToken(muShowerInputToken, muonData);

    if (!muonData.isValid()) {
      if (m_verbosity) {
        edm::LogWarning("L1TGlobal") << "\nWarning: BXVector<l1t::MuonShower> with input tag "
                                     << "\nrequested in configuration, but not found in the event.\n";
      }
    } else {
      // Loop over bx in muon data
      for (int i = muonData->getFirstBX(); i <= muonData->getLastBX(); ++i) {
        // Prevent from pushing back bx that is outside of allowed range
        if (i < m_bxFirst_ || i > m_bxLast_)
          continue;

        // Loop over Muon Showers in this bx
        int nObj = 0;
        for (std::vector<l1t::MuonShower>::const_iterator mu = muonData->begin(i); mu != muonData->end(i); ++mu) {
          if (nObj < nrL1MuShower) {
            /* NOTE: here the single object is split up into 5 separate MuonShower objects 
           similarly to the description in the UTM library, where the conditions are four different objects.
        */

            std::shared_ptr<l1t::MuonShower> musOneNominalInTime =
                std::make_shared<l1t::MuonShower>(false, false, false, false, false, false);
            std::shared_ptr<l1t::MuonShower> musOneTightInTime =
                std::make_shared<l1t::MuonShower>(false, false, false, false, false, false);
            std::shared_ptr<l1t::MuonShower> musTwoLooseDiffSectorsInTime =
                std::make_shared<l1t::MuonShower>(false, false, false, false, false, false);
            std::shared_ptr<l1t::MuonShower> musOutOfTime0 =
                std::make_shared<l1t::MuonShower>(false, false, false, false, false, false);
            std::shared_ptr<l1t::MuonShower> musOutOfTime1 =
                std::make_shared<l1t::MuonShower>(false, false, false, false, false, false);

            musOneNominalInTime->setOneNominalInTime(mu->isOneNominalInTime());
            musOneTightInTime->setOneTightInTime(mu->isOneTightInTime());
            musTwoLooseDiffSectorsInTime->setTwoLooseDiffSectorsInTime(mu->isTwoLooseDiffSectorsInTime());
            musOutOfTime0->setMusOutOfTime0(mu->musOutOfTime0());
            musOutOfTime1->setMusOutOfTime1(mu->musOutOfTime1());

            (*m_candL1MuShower).push_back(i, musOneNominalInTime);
            (*m_candL1MuShower).push_back(i, musOneTightInTime);
            (*m_candL1MuShower).push_back(i, musTwoLooseDiffSectorsInTime);
            (*m_candL1MuShower).push_back(i, musOutOfTime0);
            (*m_candL1MuShower).push_back(i, musOutOfTime1);

          } else {
            edm::LogWarning("L1TGlobal") << " Too many Muon Showers (" << nObj
                                         << ") for uGT Configuration maxMuShower =" << nrL1MuShower;
          }
          nObj++;
        }  //end loop over muon showers in bx
      }    //end loop over bx
    }      //end if over valid muon shower data
  }        //end if ReceiveMuonShower data
}

reset()

void GlobalBoard::reset

(

void

)

clear uGT

Definition at line 1090 of file GlobalBoard.cc.

                           {
  resetMu();
  resetMuonShower();
  resetCalo();
  resetExternal();

  m_uGtAlgBlk.reset();

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

resetCalo()

void GlobalBoard::resetCalo

(

)

Definition at line 1115 of file GlobalBoard.cc.

                               {
  m_candL1EG->clear();
  m_candL1Tau->clear();
  m_candL1Jet->clear();
  m_candL1EtSum->clear();

  m_candL1EG->setBXRange(m_bxFirst_, m_bxLast_);
  m_candL1Tau->setBXRange(m_bxFirst_, m_bxLast_);
  m_candL1Jet->setBXRange(m_bxFirst_, m_bxLast_);
  m_candL1EtSum->setBXRange(m_bxFirst_, m_bxLast_);
}

resetExternal()

void GlobalBoard::resetExternal

(

)

Definition at line 1127 of file GlobalBoard.cc.

                                   {
  m_candL1External->clear();
  m_candL1External->setBXRange(m_bxFirst_, m_bxLast_);
}

resetMu()

void GlobalBoard::resetMu

(

)

Definition at line 1103 of file GlobalBoard.cc.

                             {
  m_candL1Mu->clear();
  m_candL1Mu->setBXRange(m_bxFirst_, m_bxLast_);
}

resetMuonShower()

void GlobalBoard::resetMuonShower

(

)

Definition at line 1109 of file GlobalBoard.cc.

                                     {
  m_candL1MuShower->clear();
  m_candL1MuShower->setBXRange(m_bxFirst_, m_bxLast_);
}

runFDL()

void GlobalBoard::runFDL	(	const edm::Event &	iEvent,
		const int	iBxInEvent,
		const int	totalBxInEvent,
		const unsigned int	numberPhysTriggers,
		const std::vector< double > &	prescaleFactorsAlgoTrig,
		const std::vector< unsigned int > &	triggerMaskAlgoTrig,
		const std::vector< int > &	triggerMaskVetoAlgoTrig,
		const bool	algorithmTriggersUnprescaled,
		const bool	algorithmTriggersUnmasked
	)

run the uGT FDL (Apply Prescales and Veto)

if we are masking.

Definition at line 946 of file GlobalBoard.cc.

References iEvent, LogDebug, and or.

                                                                    {
  if (m_verbosity) {
    LogDebug("L1TGlobal") << "\n**** GlobalBoard apply Final Decision Logic ";
  }

  // update and clear prescales at the beginning of the luminosity segment
  if (m_prescaleCounterAlgoTrig.empty() or
      (m_currentLumi != iEvent.luminosityBlock() and m_resetPSCountersEachLumiSec)) {
    m_prescaleCounterAlgoTrig.clear();
    m_prescaleCounterAlgoTrig.reserve(totalBxInEvent);
    auto const& prescaleCountersAlgoTrig =
        m_semiRandomInitialPSCounters ? prescaleCountersWithSemirandomInitialCounter(prescaleFactorsAlgoTrig, iEvent)
                                      : prescaleCounters(prescaleFactorsAlgoTrig);
    for (int iBxInEvent = 0; iBxInEvent < totalBxInEvent; ++iBxInEvent) {
      m_prescaleCounterAlgoTrig.push_back(prescaleCountersAlgoTrig);
    }

    m_currentLumi = iEvent.luminosityBlock();
  }

  // Copy Algorithm bits to Prescaled word
  // Prescaling and Masking done below if requested.
  m_uGtAlgBlk.copyInitialToInterm();

  // -------------------------------------------
  //      Apply Prescales or skip if turned off
  // -------------------------------------------
  if (!algorithmTriggersUnprescaled) {
    // iBxInEvent is ... -2 -1 0 1 2 ... while counters are 0 1 2 3 4 ...
    int const inBxInEvent = totalBxInEvent / 2 + iBxInEvent;

    bool temp_algPrescaledOr = false;
    bool alreadyReported = false;
    for (unsigned int iBit = 0; iBit < numberPhysTriggers; ++iBit) {
      bool const bitValue = m_uGtAlgBlk.getAlgoDecisionInitial(iBit);
      if (bitValue) {
        // Make sure algo bit in range, warn otherwise
        if (iBit < prescaleFactorsAlgoTrig.size()) {
          if (prescaleFactorsAlgoTrig.at(iBit) != 1) {
            bool const triggered = m_prescaleCounterAlgoTrig.at(inBxInEvent).at(iBit).accept();
            if (triggered) {
              temp_algPrescaledOr = true;
            } else {
              // change bit to false in prescaled word and final decision word
              m_uGtAlgBlk.setAlgoDecisionInterm(iBit, false);
            }  //if Prescale counter reached zero
          }    //if prescale factor is not 1 (ie. no prescale)
          else {
            temp_algPrescaledOr = true;
          }
        }  // require bit in range
        else if (!alreadyReported) {
          alreadyReported = true;
          edm::LogWarning("L1TGlobal") << "\nWarning: algoBit >= prescaleFactorsAlgoTrig.size() in bx " << iBxInEvent;
        }
      }  //if algo bit is set true
    }    //loop over alg bits

    m_algPrescaledOr = temp_algPrescaledOr;  //temp

  } else {
    // Since not Prescaling just take OR of Initial Work
    m_algPrescaledOr = m_algInitialOr;

  }  //if we are going to apply prescales.

  // Copy Algorithm bits fron Prescaled word to Final Word
  // Masking done below if requested.
  m_uGtAlgBlk.copyIntermToFinal();

  if (!algorithmTriggersUnmasked) {
    bool temp_algFinalOr = false;
    bool alreadyReported = false;
    for (unsigned int iBit = 0; iBit < numberPhysTriggers; ++iBit) {
      const bool bitValue = m_uGtAlgBlk.getAlgoDecisionInterm(iBit);

      if (bitValue) {
        //bool isMasked = ( triggerMaskAlgoTrig.at(iBit) == 0 );
        bool isMasked = false;
        if (iBit < triggerMaskAlgoTrig.size())
          isMasked = (triggerMaskAlgoTrig.at(iBit) == 0);
        else if (!alreadyReported) {
          alreadyReported = true;
          edm::LogWarning("L1TGlobal") << "\nWarning: algoBit >= triggerMaskAlgoTrig.size() in bx " << iBxInEvent;
        }

        bool const passMask = (bitValue && !isMasked);

        if (passMask)
          temp_algFinalOr = true;
        else
          m_uGtAlgBlk.setAlgoDecisionFinal(iBit, false);

        // Check if veto mask is true, if it is, set the event veto flag.
        if (triggerMaskVetoAlgoTrig.at(iBit) == 1)
          m_algFinalOrVeto = true;
      }
    }

    m_algIntermOr = temp_algFinalOr;

  } else {
    m_algIntermOr = m_algPrescaledOr;

  }  

  // --------------------------
  // Set FinalOR for this board
  // --------------------------
  m_algFinalOr = (m_algIntermOr & !m_algFinalOrVeto);
}

runGTL()

void GlobalBoard::runGTL	(	const edm::Event &	iEvent,
		const edm::EventSetup &	evSetup,
		const TriggerMenu *	m_l1GtMenu,
		const bool	produceL1GtObjectMapRecord,
		const int	iBxInEvent,
		std::unique_ptr< GlobalObjectMapRecord > &	gtObjectMapRecord,
		const unsigned int	numberPhysTriggers,
		const int	nrL1Mu,
		const int	nrL1MuShower,
		const int	nrL1EG,
		const int	nrL1Tau,
		const int	nrL1Jet
	)

run the uGT GTL (Conditions and Algorithms)

Definition at line 470 of file GlobalBoard.cc.

References CorrelationThreeBodyTemplate::cond0Category(), CorrelationTemplate::cond0Category(), CorrelationWithOverlapRemovalTemplate::cond0Category(), CorrelationThreeBodyTemplate::cond0Index(), CorrelationTemplate::cond0Index(), CorrelationWithOverlapRemovalTemplate::cond0Index(), CorrelationThreeBodyTemplate::cond1Category(), CorrelationTemplate::cond1Category(), CorrelationWithOverlapRemovalTemplate::cond1Category(), CorrelationThreeBodyTemplate::cond1Index(), CorrelationTemplate::cond1Index(), CorrelationWithOverlapRemovalTemplate::cond1Index(), CorrelationThreeBodyTemplate::cond2Category(), CorrelationWithOverlapRemovalTemplate::cond2Category(), CorrelationThreeBodyTemplate::cond2Index(), CorrelationWithOverlapRemovalTemplate::cond2Index(), l1t::CondCalo, l1t::CondCorrelation, l1t::CondCorrelationThreeBody, l1t::CondCorrelationWithOverlapRemoval, l1t::CondEnergySum, l1t::CondExternal, l1t::CondMuon, l1t::CondMuonShower, l1t::CondNull, TriggerMenu::corCaloTemplate(), TriggerMenu::corEnergySumTemplate(), TriggerMenu::corMuonTemplate(), l1t::AlgorithmEvaluation::evaluateAlgorithm(), l1t::ConditionEvaluation::evaluateConditionStoreResult(), newFWLiteAna::found, l1t::GlobalScales::getScalesName(), l1t::AlgorithmEvaluation::gtAlgoCombinationVector(), l1t::AlgorithmEvaluation::gtAlgoResult(), TriggerMenu::gtAlgorithmMap(), TriggerMenu::gtConditionMap(), TriggerMenu::gtScales(), LogDebug, LogTrace, l1t::AlgorithmEvaluation::operandTokenVector(), CalibrationSummaryClient_cfi::otype, print(), l1t::MuonShowerCondition::print(), l1t::MuCondition::print(), l1t::EnergySumCondition::print(), l1t::ExternalCondition::print(), l1t::CorrCondition::print(), l1t::CaloCondition::print(), l1t::CorrThreeBodyCondition::print(), l1t::CorrWithOverlapRemovalCondition::print(), l1t::AlgorithmEvaluation::print(), GlobalObjectMap::print(), GlobalObjectMap::setAlgoBitNumber(), GlobalObjectMap::setAlgoGtlResult(), GlobalObjectMap::setAlgoName(), l1t::CorrCondition::setScales(), l1t::CorrThreeBodyCondition::setScales(), l1t::CorrWithOverlapRemovalCondition::setScales(), l1t::ConditionEvaluation::setVerbosity(), AlCaHLTBitMon_QueryRunRegistry::string, GlobalObjectMap::swapCombinationVector(), GlobalObjectMap::swapObjectTypeVector(), and GlobalObjectMap::swapOperandTokenVector().

                                                 {
  const std::vector<ConditionMap>& conditionMap = m_l1GtMenu->gtConditionMap();
  const AlgorithmMap& algorithmMap = m_l1GtMenu->gtAlgorithmMap();
  const GlobalScales& gtScales = m_l1GtMenu->gtScales();
  const std::string scaleSetName = gtScales.getScalesName();
  LogDebug("L1TGlobal") << " L1 Menu Scales -- Set Name: " << scaleSetName;

  // Reset AlgBlk for this bx
  m_uGtAlgBlk.reset();
  m_algInitialOr = false;
  m_algPrescaledOr = false;
  m_algIntermOr = false;
  m_algFinalOr = false;
  m_algFinalOrVeto = false;

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

  // Comment out for now
  const std::vector<std::vector<CaloTemplate>>& corrCalo = m_l1GtMenu->corCaloTemplate();

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

  LogDebug("L1TGlobal") << "Size corrMuon " << corrMuon.size() << "\nSize corrCalo " << corrCalo.size()
                        << "\nSize corrSums " << corrEnergySum.size();

  // -----------------------------------------------------
  // Loop over condition maps (one map per condition chip),
  // then loop over conditions in the map and
  // 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++;

    AlgorithmEvaluation::ConditionEvaluationMap& cMapResults = m_conditionResultMaps[iChip];

    for (CItCond itCond = itCondOnChip->begin(); itCond != itCondOnChip->end(); itCond++) {
      // evaluate condition
      switch ((itCond->second)->condCategory()) {
        case CondMuon: {
          // BLW Not sure what to do with this for now
          const int ifMuEtaNumberBits = 0;

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

          muCondition->setVerbosity(m_verbosity);

          muCondition->evaluateConditionStoreResult(iBxInEvent);

          // BLW COmment out for now
          cMapResults[itCond->first] = muCondition;

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

            LogTrace("L1TGlobal") << myCout.str();
          }
          //delete muCondition;

        } break;
        case CondMuonShower: {
          MuonShowerCondition* muShowerCondition = new MuonShowerCondition(itCond->second, this, nrL1MuShower);

          muShowerCondition->setVerbosity(m_verbosity);

          muShowerCondition->evaluateConditionStoreResult(iBxInEvent);

          cMapResults[itCond->first] = muShowerCondition;

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

            edm::LogWarning("L1TGlobal") << "MuonShowerCondition " << myCout.str();
          }
          //delete muShowerCondition;

        } break;
        case CondCalo: {
          // BLW Not sure w hat to do with this for now
          const int ifCaloEtaNumberBits = 0;

          CaloCondition* caloCondition =
              new CaloCondition(itCond->second, this, nrL1EG, nrL1Jet, nrL1Tau, ifCaloEtaNumberBits);

          caloCondition->setVerbosity(m_verbosity);

          caloCondition->evaluateConditionStoreResult(iBxInEvent);

          cMapResults[itCond->first] = caloCondition;

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

            LogTrace("L1TGlobal") << myCout.str();
          }
          //                    delete caloCondition;

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

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

          cMapResults[itCond->first] = eSumCondition;

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

            LogTrace("L1TGlobal") << myCout.str();
          }
          //                    delete eSumCondition;

        } break;

        case CondExternal: {
          ExternalCondition* extCondition = new ExternalCondition(itCond->second, this);

          extCondition->setVerbosity(m_verbosity);
          extCondition->evaluateConditionStoreResult(iBxInEvent);

          cMapResults[itCond->first] = extCondition;

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

            LogTrace("L1TGlobal") << myCout.str();
          }
          //                    delete extCondition;

        } break;
        case CondCorrelation: {
          // get first the sub-conditions
          const CorrelationTemplate* corrTemplate = static_cast<const CorrelationTemplate*>(itCond->second);
          const GtConditionCategory cond0Categ = corrTemplate->cond0Category();
          const GtConditionCategory cond1Categ = corrTemplate->cond1Category();
          const int cond0Ind = corrTemplate->cond0Index();
          const int cond1Ind = corrTemplate->cond1Index();

          const GlobalCondition* cond0Condition = nullptr;
          const GlobalCondition* cond1Condition = nullptr;

          // maximum number of objects received for evaluation of l1t::Type1s condition
          int cond0NrL1Objects = 0;
          int cond1NrL1Objects = 0;
          LogDebug("L1TGlobal") << " cond0NrL1Objects" << cond0NrL1Objects << "  cond1NrL1Objects  "
                                << cond1NrL1Objects;

          switch (cond0Categ) {
            case CondMuon: {
              cond0Condition = &((corrMuon[iChip])[cond0Ind]);
            } break;
            case CondCalo: {
              cond0Condition = &((corrCalo[iChip])[cond0Ind]);
            } break;
            case CondEnergySum: {
              cond0Condition = &((corrEnergySum[iChip])[cond0Ind]);
            } break;
            default: {
              // do nothing, should not arrive here
            } break;
          }

          switch (cond1Categ) {
            case CondMuon: {
              cond1Condition = &((corrMuon[iChip])[cond1Ind]);
            } break;
            case CondCalo: {
              cond1Condition = &((corrCalo[iChip])[cond1Ind]);
            } break;
            case CondEnergySum: {
              cond1Condition = &((corrEnergySum[iChip])[cond1Ind]);
            } break;
            default: {
              // do nothing, should not arrive here
            } break;
          }

          CorrCondition* correlationCond = new CorrCondition(itCond->second, cond0Condition, cond1Condition, this);

          correlationCond->setVerbosity(m_verbosity);
          correlationCond->setScales(&gtScales);
          correlationCond->evaluateConditionStoreResult(iBxInEvent);

          cMapResults[itCond->first] = correlationCond;

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

            LogTrace("L1TGlobal") << myCout.str();
          }

          //        delete correlationCond;

        } break;
        case CondCorrelationThreeBody: {
          // get first the sub-conditions
          const CorrelationThreeBodyTemplate* corrTemplate =
              static_cast<const CorrelationThreeBodyTemplate*>(itCond->second);
          const GtConditionCategory cond0Categ = corrTemplate->cond0Category();
          const GtConditionCategory cond1Categ = corrTemplate->cond1Category();
          const GtConditionCategory cond2Categ = corrTemplate->cond2Category();
          const int cond0Ind = corrTemplate->cond0Index();
          const int cond1Ind = corrTemplate->cond1Index();
          const int cond2Ind = corrTemplate->cond2Index();

          const GlobalCondition* cond0Condition = nullptr;
          const GlobalCondition* cond1Condition = nullptr;
          const GlobalCondition* cond2Condition = nullptr;

          // maximum number of objects received for evaluation of l1t::Type1s condition
          int cond0NrL1Objects = 0;
          int cond1NrL1Objects = 0;
          int cond2NrL1Objects = 0;
          LogDebug("L1TGlobal") << "  cond0NrL1Objects  " << cond0NrL1Objects << "  cond1NrL1Objects  "
                                << cond1NrL1Objects << "  cond2NrL1Objects  " << cond2NrL1Objects;
          if (cond0Categ == CondMuon) {
            cond0Condition = &((corrMuon[iChip])[cond0Ind]);
          } else {
            LogDebug("L1TGlobal") << "No muon0 to evaluate three-body correlation condition";
          }
          if (cond1Categ == CondMuon) {
            cond1Condition = &((corrMuon[iChip])[cond1Ind]);
          } else {
            LogDebug("L1TGlobal") << "No muon1 to evaluate three-body correlation condition";
          }
          if (cond2Categ == CondMuon) {
            cond2Condition = &((corrMuon[iChip])[cond2Ind]);
          } else {
            LogDebug("L1TGlobal") << "No muon2 to evaluate three-body correlation condition";
          }

          CorrThreeBodyCondition* correlationThreeBodyCond =
              new CorrThreeBodyCondition(itCond->second, cond0Condition, cond1Condition, cond2Condition, this);

          correlationThreeBodyCond->setVerbosity(m_verbosity);
          correlationThreeBodyCond->setScales(&gtScales);
          correlationThreeBodyCond->evaluateConditionStoreResult(iBxInEvent);
          cMapResults[itCond->first] = correlationThreeBodyCond;

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

            LogTrace("L1TGlobal") << myCout.str();
          }
          //              delete correlationThreeBodyCond;
        } break;

        case CondCorrelationWithOverlapRemoval: {
          // get first the sub-conditions
          const CorrelationWithOverlapRemovalTemplate* corrTemplate =
              static_cast<const CorrelationWithOverlapRemovalTemplate*>(itCond->second);
          const GtConditionCategory cond0Categ = corrTemplate->cond0Category();
          const GtConditionCategory cond1Categ = corrTemplate->cond1Category();
          const GtConditionCategory cond2Categ = corrTemplate->cond2Category();
          const int cond0Ind = corrTemplate->cond0Index();
          const int cond1Ind = corrTemplate->cond1Index();
          const int cond2Ind = corrTemplate->cond2Index();

          const GlobalCondition* cond0Condition = nullptr;
          const GlobalCondition* cond1Condition = nullptr;
          const GlobalCondition* cond2Condition = nullptr;

          // maximum number of objects received for evaluation of l1t::Type1s condition
          int cond0NrL1Objects = 0;
          int cond1NrL1Objects = 0;
          int cond2NrL1Objects = 0;
          LogDebug("L1TGlobal") << " cond0NrL1Objects" << cond0NrL1Objects << "  cond1NrL1Objects  " << cond1NrL1Objects
                                << "  cond2NrL1Objects  " << cond2NrL1Objects;

          switch (cond0Categ) {
            case CondMuon: {
              cond0Condition = &((corrMuon[iChip])[cond0Ind]);
            } break;
            case CondCalo: {
              cond0Condition = &((corrCalo[iChip])[cond0Ind]);
            } break;
            case CondEnergySum: {
              cond0Condition = &((corrEnergySum[iChip])[cond0Ind]);
            } break;
            default: {
              // do nothing, should not arrive here
            } break;
          }

          switch (cond1Categ) {
            case CondMuon: {
              cond1Condition = &((corrMuon[iChip])[cond1Ind]);
            } break;
            case CondCalo: {
              cond1Condition = &((corrCalo[iChip])[cond1Ind]);
            } break;
            case CondEnergySum: {
              cond1Condition = &((corrEnergySum[iChip])[cond1Ind]);
            } break;
            default: {
              // do nothing, should not arrive here
            } break;
          }

          switch (cond2Categ) {
            case CondMuon: {
              cond2Condition = &((corrMuon[iChip])[cond2Ind]);
            } break;
            case CondCalo: {
              cond2Condition = &((corrCalo[iChip])[cond2Ind]);
            } break;
            case CondEnergySum: {
              cond2Condition = &((corrEnergySum[iChip])[cond2Ind]);
            } break;
            default: {
              // do nothing, should not arrive here
            } break;
          }

          CorrWithOverlapRemovalCondition* correlationCondWOR =
              new CorrWithOverlapRemovalCondition(itCond->second, cond0Condition, cond1Condition, cond2Condition, this);

          correlationCondWOR->setVerbosity(m_verbosity);
          correlationCondWOR->setScales(&gtScales);
          correlationCondWOR->evaluateConditionStoreResult(iBxInEvent);

          cMapResults[itCond->first] = correlationCondWOR;

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

            LogTrace("L1TGlobal") << myCout.str();
          }

          //        delete correlationCondWOR;

        } break;
        case CondNull: {
          // do nothing

        } break;
        default: {
          // do nothing

        } break;
      }
    }
  }

  // -----------------------
  // Loop over algorithm map
  // -----------------------
  // Empty vector for object maps - filled during loop
  std::vector<GlobalObjectMap> objMapVec;
  if (produceL1GtObjectMapRecord && (iBxInEvent == 0))
    objMapVec.reserve(numberPhysTriggers);

  for (CItAlgo itAlgo = algorithmMap.begin(); itAlgo != algorithmMap.end(); itAlgo++) {
    AlgorithmEvaluation gtAlg(itAlgo->second);
    gtAlg.evaluateAlgorithm((itAlgo->second).algoChipNumber(), m_conditionResultMaps);

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

    LogDebug("L1TGlobal") << " ===> for iBxInEvent = " << iBxInEvent << ":\t algBitName = " << itAlgo->first
                          << ",\t algBitNumber = " << algBitNumber << ",\t algResult = " << algResult;

    if (algResult) {
      //            m_gtlAlgorithmOR.set(algBitNumber);
      m_uGtAlgBlk.setAlgoDecisionInitial(algBitNumber, algResult);
      m_algInitialOr = true;
    }

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

      LogTrace("L1TGlobal") << myCout.str();
    }

    // object maps only for BxInEvent = 0
    if (produceL1GtObjectMapRecord && (iBxInEvent == 0)) {
      std::vector<L1TObjectTypeInCond> otypes;
      for (auto iop = gtAlg.operandTokenVector().begin(); iop != gtAlg.operandTokenVector().end(); ++iop) {
        //cout << "INFO:  operand name:  " << iop->tokenName << "\n";
        int found = 0;
        L1TObjectTypeInCond otype;
        for (auto imap = conditionMap.begin(); imap != conditionMap.end(); imap++) {
          auto match = imap->find(iop->tokenName);

          if (match != imap->end()) {
            found = 1;
            //cout << "DEBUG: found match for " << iop->tokenName << " at " << match->first << "\n";

            otype = match->second->objectType();

            for (auto itype = otype.begin(); itype != otype.end(); itype++) {
              //cout << "type:  " << *itype << "\n";
            }
          }
        }
        if (!found) {
          edm::LogWarning("L1TGlobal") << "\n Failed to find match for operand token " << iop->tokenName << "\n";
        } else {
          otypes.push_back(otype);
        }
      }

      // set object map
      GlobalObjectMap objMap;

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

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

        LogTrace("L1TGlobal") << myCout1.str();
      }

      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<AlgorithmEvaluation::ConditionEvaluationMap>::iterator itCondOnChip = m_conditionResultMaps.begin();
       itCondOnChip != m_conditionResultMaps.end();
       itCondOnChip++) {
    for (AlgorithmEvaluation::ItEvalMap itCond = itCondOnChip->begin(); itCond != itCondOnChip->end(); itCond++) {
      delete itCond->second;
      itCond->second = nullptr;
    }
  }
}

setBxFirst()

void GlobalBoard::setBxFirst

(

int

bx

)

Definition at line 103 of file GlobalBoard.cc.

References nano_mu_digi_cff::bx.

{ m_bxFirst_ = bx; }

setBxLast()

void GlobalBoard::setBxLast

(

int

bx

)

Definition at line 105 of file GlobalBoard.cc.

References nano_mu_digi_cff::bx.

{ m_bxLast_ = bx; }

setResetPSCountersEachLumiSec()

void l1t::GlobalBoard::setResetPSCountersEachLumiSec ( bool  val )

inline

Definition at line 199 of file GlobalBoard.h.

References m_resetPSCountersEachLumiSec, and heppy_batch::val.

{ m_resetPSCountersEachLumiSec = val; }

setSemiRandomInitialPSCounters()

void l1t::GlobalBoard::setSemiRandomInitialPSCounters ( bool  val )

inline

Definition at line 200 of file GlobalBoard.h.

References m_semiRandomInitialPSCounters, and heppy_batch::val.

{ m_semiRandomInitialPSCounters = val; }

setVerbosity()

void l1t::GlobalBoard::setVerbosity ( const int  verbosity )

inline

Definition at line 203 of file GlobalBoard.h.

References m_verbosity, and verbosity.

{ m_verbosity = verbosity; }

Member Data Documentation

m_algFinalOr

bool l1t::GlobalBoard::m_algFinalOr

private

Definition at line 258 of file GlobalBoard.h.

m_algFinalOrVeto

bool l1t::GlobalBoard::m_algFinalOrVeto

private

Definition at line 259 of file GlobalBoard.h.

m_algInitialOr

bool l1t::GlobalBoard::m_algInitialOr

private

Definition at line 255 of file GlobalBoard.h.

m_algIntermOr

bool l1t::GlobalBoard::m_algIntermOr

private

Definition at line 256 of file GlobalBoard.h.

m_algPrescaledOr

bool l1t::GlobalBoard::m_algPrescaledOr

private

Definition at line 257 of file GlobalBoard.h.

m_boardEventCount

unsigned int l1t::GlobalBoard::m_boardEventCount

private

Definition at line 262 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_bxFirst_

int l1t::GlobalBoard::m_bxFirst_

private

Definition at line 236 of file GlobalBoard.h.

m_bxLast_

int l1t::GlobalBoard::m_bxLast_

private

Definition at line 237 of file GlobalBoard.h.

m_candL1EG

BXVector<const l1t::L1Candidate*>* l1t::GlobalBoard::m_candL1EG

private

Definition at line 225 of file GlobalBoard.h.

Referenced by getCandL1EG().

m_candL1EtSum

BXVector<const l1t::EtSum*>* l1t::GlobalBoard::m_candL1EtSum

private

Definition at line 228 of file GlobalBoard.h.

Referenced by getCandL1EtSum().

m_candL1External

BXVector<const GlobalExtBlk*>* l1t::GlobalBoard::m_candL1External

private

Definition at line 229 of file GlobalBoard.h.

Referenced by getCandL1External().

m_candL1Jet

BXVector<const l1t::L1Candidate*>* l1t::GlobalBoard::m_candL1Jet

private

Definition at line 227 of file GlobalBoard.h.

Referenced by getCandL1Jet().

m_candL1Mu

BXVector<const l1t::Muon*>* l1t::GlobalBoard::m_candL1Mu

private

Definition at line 223 of file GlobalBoard.h.

Referenced by getCandL1Mu().

m_candL1MuShower

BXVector<std::shared_ptr<l1t::MuonShower> >* l1t::GlobalBoard::m_candL1MuShower

private

Definition at line 224 of file GlobalBoard.h.

Referenced by getCandL1MuShower().

m_candL1Tau

BXVector<const l1t::L1Candidate*>* l1t::GlobalBoard::m_candL1Tau

private

Definition at line 226 of file GlobalBoard.h.

Referenced by getCandL1Tau().

m_conditionResultMaps

std::vector<AlgorithmEvaluation::ConditionEvaluationMap> l1t::GlobalBoard::m_conditionResultMaps

private

Definition at line 245 of file GlobalBoard.h.

m_currentLumi

unsigned int l1t::GlobalBoard::m_currentLumi

private

Definition at line 247 of file GlobalBoard.h.

m_gtlAlgorithmOR

std::bitset<GlobalAlgBlk::maxPhysicsTriggers> l1t::GlobalBoard::m_gtlAlgorithmOR

private

Definition at line 239 of file GlobalBoard.h.

Referenced by getAlgorithmOR(), and GlobalBoard().

m_gtlDecisionWord

std::bitset<GlobalAlgBlk::maxPhysicsTriggers> l1t::GlobalBoard::m_gtlDecisionWord

private

Definition at line 240 of file GlobalBoard.h.

Referenced by getDecisionWord(), and GlobalBoard().

m_isDebugEnabled

bool l1t::GlobalBoard::m_isDebugEnabled

private

Definition at line 252 of file GlobalBoard.h.

m_l1CaloGeometry

const L1CaloGeometry* l1t::GlobalBoard::m_l1CaloGeometry

private

Definition at line 213 of file GlobalBoard.h.

m_l1CaloGeometryCacheID

unsigned long long l1t::GlobalBoard::m_l1CaloGeometryCacheID

private

Definition at line 214 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_l1GtMenu

const TriggerMenu* l1t::GlobalBoard::m_l1GtMenu

private

Definition at line 209 of file GlobalBoard.h.

m_l1GtMenuCacheID

unsigned long long l1t::GlobalBoard::m_l1GtMenuCacheID

private

Definition at line 210 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_l1MuTriggerScales

const L1MuTriggerScales* l1t::GlobalBoard::m_l1MuTriggerScales

private

Definition at line 216 of file GlobalBoard.h.

m_l1MuTriggerScalesCacheID

unsigned long long l1t::GlobalBoard::m_l1MuTriggerScalesCacheID

private

Definition at line 217 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_prescaleCounterAlgoTrig

std::vector<std::vector<PrescaleCounter> > l1t::GlobalBoard::m_prescaleCounterAlgoTrig

private

Definition at line 298 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_resetPSCountersEachLumiSec

bool l1t::GlobalBoard::m_resetPSCountersEachLumiSec = false

private

Definition at line 269 of file GlobalBoard.h.

Referenced by setResetPSCountersEachLumiSec().

m_semiRandomInitialPSCounters

bool l1t::GlobalBoard::m_semiRandomInitialPSCounters = false

private

Definition at line 272 of file GlobalBoard.h.

Referenced by setSemiRandomInitialPSCounters().

m_singlestep

constexpr size_t l1t::GlobalBoard::m_singlestep = 100

staticprivate

Definition at line 277 of file GlobalBoard.h.

Referenced by l1t::GlobalBoard::PrescaleCounter::PrescaleCounter().

m_uGtAlgBlk

GlobalAlgBlk l1t::GlobalBoard::m_uGtAlgBlk

private

Definition at line 242 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_uGtBoardNumber

int l1t::GlobalBoard::m_uGtBoardNumber

private

Definition at line 265 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_uGtFinalBoard

bool l1t::GlobalBoard::m_uGtFinalBoard

private

Definition at line 266 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_verbosity

int l1t::GlobalBoard::m_verbosity

private

verbosity level

Definition at line 251 of file GlobalBoard.h.

Referenced by setVerbosity().