l1t::GlobalBoard Class Reference

#include <GlobalBoard.h>

Classes
struct	PrescaleCounter

Public Member Functions
void	enableAXOScoreSaving (bool savescore)
void	fillAlgRecord (int iBxInEvent, std::unique_ptr< GlobalAlgBlkBxCollection > &uGtAlgRecord, int prescaleSet, int menuUUID, int firmwareUUID)
	Fill the Daq Records. More...
void	fillAXOScore (int iBxInEvent, std::unique_ptr< AXOL1TLScoreBxCollection > &AxoScoreRecord)
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 EtSum data list More...
const BXVector< const l1t::EtSum * > *	getCandL1EtSumZdc () const
	pointer to ZDC EtSum data list More...
const BXVector< const GlobalExtBlk * > *	getCandL1External () const
	pointer to External 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 float	getCICADAScore () const
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 edm::EDGetTokenT< BXVector< l1t::EtSum >> &, const edm::EDGetTokenT< BXVector< float >> &, const bool receiveEG, const int nrL1EG, const bool receiveTau, const int nrL1Tau, const bool receiveJet, const int nrL1Jet, const bool receiveEtSums, const bool receiveEtSumsZdc, const bool receiveCICADA)
	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	setCICADAScore (float val)
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 l1t::EtSum * > *	m_candL1EtSumZdc
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
float	m_cicadaScore = 0.0
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_saveAXOScore = false
bool	m_semiRandomInitialPSCounters = false
float	m_storedAXOScore = -999.0
GlobalAlgBlk	m_uGtAlgBlk
AXOL1TLScore	m_uGtAXOScore
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 57 of file GlobalBoard.h.

Constructor & Destructor Documentation

GlobalBoard()

GlobalBoard::GlobalBoard

(

)

Definition at line 69 of file GlobalBoard.cc.

References m_boardEventCount, m_gtlAlgorithmOR, m_gtlDecisionWord, m_l1CaloGeometryCacheID, m_l1GtMenuCacheID, m_l1MuTriggerScalesCacheID, m_prescaleCounterAlgoTrig, m_uGtAlgBlk, m_uGtAXOScore, m_uGtBoardNumber, m_uGtFinalBoard, AXOL1TLScore::reset(), 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_candL1EtSumZdc(new BXVector<const l1t::EtSum*>),
      m_candL1External(new BXVector<const GlobalExtBlk*>),
      m_currentLumi(0),
      m_isDebugEnabled(edm::isDebugEnabled()) {
  m_uGtAlgBlk.reset();
  m_uGtAXOScore.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 102 of file GlobalBoard.cc.

                             {
  delete m_candL1Mu;
  delete m_candL1MuShower;
  delete m_candL1EG;
  delete m_candL1Tau;
  delete m_candL1Jet;
  delete m_candL1EtSum;
  delete m_candL1EtSumZdc;
  delete m_candL1External;
}

Member Function Documentation

enableAXOScoreSaving()

void l1t::GlobalBoard::enableAXOScoreSaving ( bool  savescore )

inline

Definition at line 219 of file GlobalBoard.h.

References m_saveAXOScore.

{ m_saveAXOScore = savescore; }

fillAlgRecord()

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

Fill the Daq Records.

Definition at line 1191 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);
}

fillAXOScore()

void GlobalBoard::fillAXOScore	(	int	iBxInEvent,
		std::unique_ptr< AXOL1TLScoreBxCollection > &	AxoScoreRecord
	)

Definition at line 524 of file GlobalBoard.cc.

                                                                                                         {
  m_uGtAXOScore.reset();
  m_uGtAXOScore.setbxInEventNr((iBxInEvent & 0xF));

  //save stored condition score if Bx is zero, else set to 0
  float scorevalue = 0.0;
  if (iBxInEvent == 0) {
    scorevalue = m_storedAXOScore;
  }

  //set dataformat value
  m_uGtAXOScore.setAXOScore(scorevalue);
  AxoScoreRecord->push_back(iBxInEvent, m_uGtAXOScore);
}

getAlgorithmOR()

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

inline

return algorithm OR decision

Definition at line 154 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 163 of file GlobalBoard.h.

References m_candL1EG.

{ return m_candL1EG; }

getCandL1EtSum()

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

inline

pointer to EtSum data list

Definition at line 172 of file GlobalBoard.h.

References m_candL1EtSum.

{ return m_candL1EtSum; }

getCandL1EtSumZdc()

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

inline

pointer to ZDC EtSum data list

Definition at line 175 of file GlobalBoard.h.

References m_candL1EtSumZdc.

{ return m_candL1EtSumZdc; }

getCandL1External()

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

inline

pointer to External data list

Definition at line 178 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 166 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 157 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 160 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 169 of file GlobalBoard.h.

References m_candL1Tau.

{ return m_candL1Tau; }

getCICADAScore()

const float l1t::GlobalBoard::getCICADAScore ( ) const

inline

Definition at line 180 of file GlobalBoard.h.

References m_cicadaScore.

{ return m_cicadaScore; }

getDecisionWord()

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

inline

return decision

Definition at line 151 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 118 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_candL1EtSumZdc->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 1272 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 1283 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 1264 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 edm::EDGetTokenT< BXVector< l1t::EtSum >> &	sumZdcInputToken,
		const edm::EDGetTokenT< BXVector< float >> &	CICADAInputToken,
		const bool	receiveEG,
		const int	nrL1EG,
		const bool	receiveTau,
		const int	nrL1Tau,
		const bool	receiveJet,
		const int	nrL1Jet,
		const bool	receiveEtSums,
		const bool	receiveEtSumsZdc,
		const bool	receiveCICADA
	)

receive data from Global Muon Trigger

Definition at line 144 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 ";
  }

  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: Input tag for the BXVector<l1t::EGamma> collection"
                                     << "\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: Input tag for the BXVector<l1t::Tau> collection"
                                     << "\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: Input tag for the BXVector<l1t::Jet> collection"
                                     << "\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: Input tag for the BXVector<l1t::EtSum> collection"
                                     << "\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 EtSum objects 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 EtSum objects in bx
      }    //end loop over Bx
    }
  }

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

    if (!etSumData.isValid()) {
      if (m_verbosity) {
        edm::LogWarning("L1TGlobal") << "\nWarning: Input tag for the ZDC Energy Sums collection"
                                     << "\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;

        for (std::vector<l1t::EtSum>::const_iterator etsum = etSumData->begin(i); etsum != etSumData->end(i); ++etsum) {
          (*m_candL1EtSumZdc).push_back(i, &(*etsum));
        }
      }  //end loop over Bx
    }
  }
  if (receiveCICADA) {
    edm::Handle<BXVector<float>> cicadaScoreHandle;
    iEvent.getByToken(CICADAInputToken, cicadaScoreHandle);
    if (not cicadaScoreHandle.isValid()) {
      if (m_verbosity) {
        edm::LogWarning("L1Tglobal") << "\nWarning: Input tag for the CICADA score"
                                     << "\nrequested in configuration, but not found in the event.\n"
                                     << "\nSetting score to 0.0";
      }
      setCICADAScore(0.0);
    } else if (cicadaScoreHandle->isEmpty(0)) {
      if (m_verbosity) {
        edm::LogWarning("L1Tglobal")
            << "\nWarning: CICADA score had a valid input tag, but an empty BX collection"
            << "\nThe CICADA score will be filled with 0.0 to prevent any failure of uGT emulation";
      }
      setCICADAScore(0.0);
    } else {
      setCICADAScore(cicadaScoreHandle->at(
          0,
          0));  //CICADA emulation will only provide a central BX, and one value. Unpacking may have more values, but that can't be guaranteed.
    }
  }
}

receiveExternalData()

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

Definition at line 487 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: Input tag for the BXVector<GlobalExtBlk> collection"
                                     << "\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 376 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: Input tag for the BXVector<l1t::Muon> collection"
                                     << "\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 423 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: Input tag for the BXVector<l1t::MuonShower> collection"
                                     << "\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 1214 of file GlobalBoard.cc.

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

  m_uGtAlgBlk.reset();

  //reset AXO score
  m_storedAXOScore = -999.0;
  m_uGtAXOScore.reset();

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

resetCalo()

void GlobalBoard::resetCalo

(

)

Definition at line 1243 of file GlobalBoard.cc.

                               {
  m_candL1EG->clear();
  m_candL1Tau->clear();
  m_candL1Jet->clear();
  m_candL1EtSum->clear();
  m_candL1EtSumZdc->clear();
  m_cicadaScore = 0.0;

  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_candL1EtSumZdc->setBXRange(m_bxFirst_, m_bxLast_);
}

resetExternal()

void GlobalBoard::resetExternal

(

)

Definition at line 1258 of file GlobalBoard.cc.

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

resetMu()

void GlobalBoard::resetMu

(

)

Definition at line 1231 of file GlobalBoard.cc.

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

resetMuonShower()

void GlobalBoard::resetMuonShower

(

)

Definition at line 1237 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 1070 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 540 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::CondAXOL1TL, l1t::CondCalo, l1t::CondCICADA, l1t::CondCorrelation, l1t::CondCorrelationThreeBody, l1t::CondCorrelationWithOverlapRemoval, l1t::CondEnergySum, l1t::CondEnergySumZdc, 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::AXOL1TLCondition::getScore(), l1t::AlgorithmEvaluation::gtAlgoCombinationVector(), l1t::AlgorithmEvaluation::gtAlgoResult(), TriggerMenu::gtAlgorithmMap(), TriggerMenu::gtConditionMap(), TriggerMenu::gtScales(), LogDebug, LogTrace, l1t::AlgorithmEvaluation::operandTokenVector(), CalibrationSummaryClient_cfi::otype, print(), l1t::CICADACondition::print(), l1t::AXOL1TLCondition::print(), l1t::MuonShowerCondition::print(), l1t::EnergySumCondition::print(), l1t::ExternalCondition::print(), l1t::EnergySumZdcCondition::print(), l1t::MuCondition::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();

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

          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 CondEnergySumZdc: {
          EnergySumZdcCondition* eSumZdcCondition = new EnergySumZdcCondition(itCond->second, this);

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

          cMapResults[itCond->first] = eSumZdcCondition;

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

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

        } break;
        case CondAXOL1TL: {
          AXOL1TLCondition* axol1tlCondition = new AXOL1TLCondition(itCond->second, this);

          axol1tlCondition->setVerbosity(m_verbosity);

          axol1tlCondition->evaluateConditionStoreResult(iBxInEvent);

          cMapResults[itCond->first] = axol1tlCondition;

          //for optional software-only saving of axol1tl score
          //m_storedAXOScore < 0.0 ensures only sets once per condition if score not default of -999
          if (m_saveAXOScore && m_storedAXOScore < 0.0) {
            m_storedAXOScore = axol1tlCondition->getScore();
          }

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

            edm::LogWarning("L1TGlobal") << "axol1tlCondition " << myCout.str();
          }
          //delete axol1tlCCondition;

        } break;
        case CondCICADA: {
          CICADACondition* cicadaCondition = new CICADACondition(itCond->second, this);

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

          cMapResults[itCond->first] = cicadaCondition;

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

            edm::LogWarning("L1TGlobal") << "cicadaCondition " << myCout.str();
          }
        } 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 subconditions
          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 subconditions
          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 subconditions
          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 114 of file GlobalBoard.cc.

References nano_mu_digi_cff::bx.

{ m_bxFirst_ = bx; }

setBxLast()

void GlobalBoard::setBxLast

(

int

bx

)

Definition at line 116 of file GlobalBoard.cc.

References nano_mu_digi_cff::bx.

{ m_bxLast_ = bx; }

setCICADAScore()

void l1t::GlobalBoard::setCICADAScore ( float  val )

inline

Definition at line 214 of file GlobalBoard.h.

References m_cicadaScore, and heppy_batch::val.

{ m_cicadaScore = val; }

setResetPSCountersEachLumiSec()

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

inline

Definition at line 211 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 212 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 217 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 282 of file GlobalBoard.h.

m_algFinalOrVeto

bool l1t::GlobalBoard::m_algFinalOrVeto

private

Definition at line 283 of file GlobalBoard.h.

m_algInitialOr

bool l1t::GlobalBoard::m_algInitialOr

private

Definition at line 279 of file GlobalBoard.h.

m_algIntermOr

bool l1t::GlobalBoard::m_algIntermOr

private

Definition at line 280 of file GlobalBoard.h.

m_algPrescaledOr

bool l1t::GlobalBoard::m_algPrescaledOr

private

Definition at line 281 of file GlobalBoard.h.

m_boardEventCount

unsigned int l1t::GlobalBoard::m_boardEventCount

private

Definition at line 286 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_bxFirst_

int l1t::GlobalBoard::m_bxFirst_

private

Definition at line 253 of file GlobalBoard.h.

m_bxLast_

int l1t::GlobalBoard::m_bxLast_

private

Definition at line 254 of file GlobalBoard.h.

m_candL1EG

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

private

Definition at line 241 of file GlobalBoard.h.

Referenced by getCandL1EG().

m_candL1EtSum

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

private

Definition at line 244 of file GlobalBoard.h.

Referenced by getCandL1EtSum().

m_candL1EtSumZdc

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

private

Definition at line 245 of file GlobalBoard.h.

Referenced by getCandL1EtSumZdc().

m_candL1External

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

private

Definition at line 246 of file GlobalBoard.h.

Referenced by getCandL1External().

m_candL1Jet

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

private

Definition at line 243 of file GlobalBoard.h.

Referenced by getCandL1Jet().

m_candL1Mu

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

private

Definition at line 239 of file GlobalBoard.h.

Referenced by getCandL1Mu().

m_candL1MuShower

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

private

Definition at line 240 of file GlobalBoard.h.

Referenced by getCandL1MuShower().

m_candL1Tau

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

private

Definition at line 242 of file GlobalBoard.h.

Referenced by getCandL1Tau().

m_cicadaScore

float l1t::GlobalBoard::m_cicadaScore = 0.0

private

Definition at line 256 of file GlobalBoard.h.

Referenced by getCICADAScore(), and setCICADAScore().

m_conditionResultMaps

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

private

Definition at line 269 of file GlobalBoard.h.

m_currentLumi

unsigned int l1t::GlobalBoard::m_currentLumi

private

Definition at line 271 of file GlobalBoard.h.

m_gtlAlgorithmOR

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

private

Definition at line 258 of file GlobalBoard.h.

Referenced by getAlgorithmOR(), and GlobalBoard().

m_gtlDecisionWord

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

private

Definition at line 259 of file GlobalBoard.h.

Referenced by getDecisionWord(), and GlobalBoard().

m_isDebugEnabled

bool l1t::GlobalBoard::m_isDebugEnabled

private

Definition at line 276 of file GlobalBoard.h.

m_l1CaloGeometry

const L1CaloGeometry* l1t::GlobalBoard::m_l1CaloGeometry

private

Definition at line 229 of file GlobalBoard.h.

m_l1CaloGeometryCacheID

unsigned long long l1t::GlobalBoard::m_l1CaloGeometryCacheID

private

Definition at line 230 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_l1GtMenu

const TriggerMenu* l1t::GlobalBoard::m_l1GtMenu

private

Definition at line 225 of file GlobalBoard.h.

m_l1GtMenuCacheID

unsigned long long l1t::GlobalBoard::m_l1GtMenuCacheID

private

Definition at line 226 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_l1MuTriggerScales

const L1MuTriggerScales* l1t::GlobalBoard::m_l1MuTriggerScales

private

Definition at line 232 of file GlobalBoard.h.

m_l1MuTriggerScalesCacheID

unsigned long long l1t::GlobalBoard::m_l1MuTriggerScalesCacheID

private

Definition at line 233 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_prescaleCounterAlgoTrig

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

private

Definition at line 322 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_resetPSCountersEachLumiSec

bool l1t::GlobalBoard::m_resetPSCountersEachLumiSec = false

private

Definition at line 293 of file GlobalBoard.h.

Referenced by setResetPSCountersEachLumiSec().

m_saveAXOScore

bool l1t::GlobalBoard::m_saveAXOScore = false

private

Definition at line 266 of file GlobalBoard.h.

Referenced by enableAXOScoreSaving().

m_semiRandomInitialPSCounters

bool l1t::GlobalBoard::m_semiRandomInitialPSCounters = false

private

Definition at line 296 of file GlobalBoard.h.

Referenced by setSemiRandomInitialPSCounters().

m_singlestep

constexpr size_t l1t::GlobalBoard::m_singlestep = 100

staticprivate

Definition at line 301 of file GlobalBoard.h.

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

m_storedAXOScore

float l1t::GlobalBoard::m_storedAXOScore = -999.0

private

Definition at line 265 of file GlobalBoard.h.

m_uGtAlgBlk

GlobalAlgBlk l1t::GlobalBoard::m_uGtAlgBlk

private

Definition at line 261 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_uGtAXOScore

AXOL1TLScore l1t::GlobalBoard::m_uGtAXOScore

private

Definition at line 264 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_uGtBoardNumber

int l1t::GlobalBoard::m_uGtBoardNumber

private

Definition at line 289 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_uGtFinalBoard

bool l1t::GlobalBoard::m_uGtFinalBoard

private

Definition at line 290 of file GlobalBoard.h.

Referenced by GlobalBoard().

m_verbosity

int l1t::GlobalBoard::m_verbosity

private

verbosity level

Definition at line 275 of file GlobalBoard.h.

Referenced by setVerbosity().