L1GtUtils::LogicalExpressionL1Results Class Reference

#include <L1GtUtils.h>

Public Member Functions
const std::vector< std::pair< std::string, bool > > &	decisionsAfterMask ()
const std::vector< std::pair< std::string, bool > > &	decisionsBeforeMask ()
const std::vector< std::pair< std::string, int > > &	errorCodes (const edm::Event &)
const std::vector< L1GtLogicParser::OperandToken > &	expL1Triggers ()
	list of triggers in the logical expression, trigger decisions, prescale factors and masks, error codes More...
bool	isValid ()
	return true if the logical expression is syntactically correct More...
	LogicalExpressionL1Results (const std::string &, L1GtUtils &)
	constructor(s) More...
const int	logicalExpressionRunUpdate (const edm::Run &, const edm::EventSetup &)
	keep the logical expression given in the previous run More...
const int	logicalExpressionRunUpdate (const edm::Run &, const edm::EventSetup &, const std::string &)
const std::vector< std::pair< std::string, int > > &	prescaleFactors ()
const std::vector< std::pair< std::string, int > > &	triggerMasks ()
	~LogicalExpressionL1Results ()
	destructor More...

Private Member Functions
bool	initialize ()
void	l1Results (const edm::Event &iEvent)
void	reset (const std::vector< std::pair< std::string, bool > > &) const
	reset for each L1 trigger the value from pair.second More...
void	reset (const std::vector< std::pair< std::string, int > > &) const

Private Attributes
std::vector< std::pair< std::string, bool > >	m_decisionsAfterMask
std::vector< std::pair< std::string, bool > >	m_decisionsBeforeMask
std::vector< std::pair< std::string, int > >	m_errorCodes
bool	m_expBitsTechTrigger
	flag true, if the logical expression is built from technical trigger bits More...
std::vector< L1GtLogicParser::OperandToken >	m_expL1Triggers
size_t	m_expL1TriggersSize
std::vector< L1GtUtils::TriggerCategory >	m_expTriggerCategory
	trigger category for each L1 trigger in the logical expression More...
std::vector< bool >	m_expTriggerInMenu
int	m_l1ConfCode
	code for L1 trigger configuration More...
L1GtUtils &	m_l1GtUtils
bool	m_l1ResultsAlreadyCalled
	set to true if the method l1Results was called once More...
std::string	m_logicalExpression
	private members as input parameters More...
std::vector< std::pair< std::string, int > >	m_prescaleFactors
std::vector< std::pair< std::string, int > >	m_triggerMasks
bool	m_validL1Configuration
	true if valid L1 configuration - if not, reset all quantities and return More...
bool	m_validLogicalExpression
	true if the logical expression uses accepted L1GtLogicParser operators More...

Detailed Description

Definition at line 157 of file L1GtUtils.h.

Constructor & Destructor Documentation

LogicalExpressionL1Results()

L1GtUtils::LogicalExpressionL1Results::LogicalExpressionL1Results ( const std::string &  expression, L1GtUtils &  l1GtUtils  )

explicit

constructor(s)

trigger decisions, prescale factors and masks from GT record(s)

Definition at line 1790 of file L1GtUtils.cc.

    :
 
      m_logicalExpression(expression),
 
      m_l1GtUtils(l1GtUtils),
 
      m_l1ConfCode(-1),
 
      m_validL1Configuration(false),
 
      m_validLogicalExpression(false),
 
      m_l1ResultsAlreadyCalled(false),
 
      m_expL1TriggersSize(0),
 
      m_expBitsTechTrigger(false) {
  initialize();
}

References initialize().

~LogicalExpressionL1Results()

L1GtUtils::LogicalExpressionL1Results::~LogicalExpressionL1Results

(

)

destructor

Definition at line 1812 of file L1GtUtils.cc.

                                                                 {
  // empty
}

Member Function Documentation

decisionsAfterMask()

const std::vector< std::pair< std::string, bool > > & L1GtUtils::LogicalExpressionL1Results::decisionsAfterMask

(

)

Definition at line 2016 of file L1GtUtils.cc.

                                                                                                    {
  // throw an exception if the result is not computed once per event - user usage error
  if (!m_l1ResultsAlreadyCalled) {
    throw cms::Exception("FailModule")
        << "\nUsage error: "
        << "\n  Method 'errorCodes' must be called in the event loop before attempting to use this method.\n"
        << std::endl;
  }
 
  return m_decisionsAfterMask;
}

References Exception.

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore().

decisionsBeforeMask()

const std::vector< std::pair< std::string, bool > > & L1GtUtils::LogicalExpressionL1Results::decisionsBeforeMask

(

)

Definition at line 2004 of file L1GtUtils.cc.

                                                                                                     {
  // throw an exception if the result is not computed once per event - user usage error
  if (!m_l1ResultsAlreadyCalled) {
    throw cms::Exception("FailModule")
        << "\nUsage error: "
        << "\n  Method 'errorCodes' must be called in the event loop before attempting to use this method.\n"
        << std::endl;
  }
 
  return m_decisionsBeforeMask;
}

References Exception.

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore().

errorCodes()

const std::vector< std::pair< std::string, int > > & L1GtUtils::LogicalExpressionL1Results::errorCodes

(

const edm::Event &

iEvent

)

Definition at line 2052 of file L1GtUtils.cc.

                            {
  m_l1ResultsAlreadyCalled = false;
 
  // if not a valid L1 configuration, reset all quantities and return
  if (!m_validL1Configuration) {
    reset(m_decisionsBeforeMask);
    reset(m_decisionsAfterMask);
    reset(m_prescaleFactors);
    reset(m_triggerMasks);
    reset(m_errorCodes);
 
    m_l1ResultsAlreadyCalled = true;
    return m_errorCodes;
  }
 
  l1Results(iEvent);
 
  m_l1ResultsAlreadyCalled = true;
 
  return m_errorCodes;
}

References iEvent, L1GtUtils::l1Results(), and reset().

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore().

expL1Triggers()

const std::vector<L1GtLogicParser::OperandToken>& L1GtUtils::LogicalExpressionL1Results::expL1Triggers ( )

inline

list of triggers in the logical expression, trigger decisions, prescale factors and masks, error codes

Definition at line 180 of file L1GtUtils.h.

{ return m_expL1Triggers; }

References m_expL1Triggers.

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore().

initialize()

bool L1GtUtils::LogicalExpressionL1Results::initialize ( void  )

private

parse the logical expression, initialize the private members to required size such that one can just reset them

Definition at line 1816 of file L1GtUtils.cc.

                                                     {
  // get the vector of triggers corresponding to the logical expression
  // check also the logical expression - add/remove spaces if needed
 
  try {
    L1GtLogicParser m_l1AlgoLogicParser = L1GtLogicParser(m_logicalExpression);
 
    // list of L1 triggers from the logical expression
    m_expL1Triggers = m_l1AlgoLogicParser.operandTokenVector();
    m_expL1TriggersSize = m_expL1Triggers.size();
 
    m_validLogicalExpression = true;
 
  } catch (cms::Exception& ex) {
    m_validLogicalExpression = false;
 
    edm::LogWarning("L1GtUtils") << ex;
    edm::LogWarning("L1GtUtils") << ex.what();
    edm::LogWarning("L1GtUtils") << ex.explainSelf();
  }
 
  // try to convert the string representing each L1 trigger to bit number,
  //   to check if the logical expression is constructed from bit numbers
  // trade-off: cache it here, irrespective of the expression
  //   when the conversion fails (normally for the first seed,
  //   if not expression of technical trigger bits), stop and
  //   set m_expBitsTechTrigger to false
 
  m_expBitsTechTrigger = true;
 
  for (size_t iTrig = 0; iTrig < m_expL1TriggersSize; ++iTrig) {
    const std::string& bitString = (m_expL1Triggers[iTrig]).tokenName;
    std::istringstream bitStream(bitString);
    int bitInt;
 
    if ((bitStream >> bitInt).fail()) {
      m_expBitsTechTrigger = false;
 
      break;
    }
 
    (m_expL1Triggers[iTrig]).tokenNumber = bitInt;
  }
 
  // resize and fill
  m_decisionsBeforeMask.resize(m_expL1TriggersSize);
  m_decisionsAfterMask.resize(m_expL1TriggersSize);
  m_prescaleFactors.resize(m_expL1TriggersSize);
  m_triggerMasks.resize(m_expL1TriggersSize);
  m_errorCodes.resize(m_expL1TriggersSize);
  m_expTriggerCategory.resize(m_expL1TriggersSize);
  m_expTriggerInMenu.resize(m_expL1TriggersSize);
 
  LogDebug("L1GtUtils") << std::endl;
  LogTrace("L1GtUtils") << "\nLogical expression\n  " << m_logicalExpression << "\n has " << m_expL1TriggersSize
                        << " L1 triggers" << std::endl;
  for (size_t iTrig = 0; iTrig < m_expL1TriggersSize; ++iTrig) {
    const std::string& trigNameOrAlias = (m_expL1Triggers[iTrig]).tokenName;
    LogTrace("L1GtUtils") << "  " << trigNameOrAlias << std::endl;
 
    (m_decisionsBeforeMask[iTrig]).first = trigNameOrAlias;
    (m_decisionsBeforeMask[iTrig]).second = false;
 
    (m_decisionsAfterMask[iTrig]).first = trigNameOrAlias;
    (m_decisionsAfterMask[iTrig]).second = false;
 
    (m_prescaleFactors[iTrig]).first = trigNameOrAlias;
    (m_prescaleFactors[iTrig]).second = -1;
 
    (m_triggerMasks[iTrig]).first = trigNameOrAlias;
    (m_triggerMasks[iTrig]).second = -1;
 
    (m_errorCodes[iTrig]).first = trigNameOrAlias;
    (m_errorCodes[iTrig]).second = -1;
 
    m_expTriggerCategory[iTrig] = L1GtUtils::AlgorithmTrigger;
 
    m_expTriggerInMenu[iTrig] = false;
  }
  LogTrace("L1GtUtils") << std::endl;
 
  return true;
}

References L1GtUtils::AlgorithmTrigger, cms::Exception::explainSelf(), dqmdumpme::first, LogDebug, LogTrace, L1GtLogicParser::operandTokenVector(), edm::second(), AlCaHLTBitMon_QueryRunRegistry::string, and cms::Exception::what().

Referenced by LogicalExpressionL1Results().

isValid()

bool L1GtUtils::LogicalExpressionL1Results::isValid ( void  )

inline

return true if the logical expression is syntactically correct

Definition at line 169 of file L1GtUtils.h.

{ return m_validLogicalExpression; }

References m_validLogicalExpression.

Referenced by ntupleDataFormat._Object::_checkIsValid(), L1GtAnalyzer::beginRun(), and core.AutoHandle.AutoHandle::ReallyLoad().

l1Results()

void L1GtUtils::LogicalExpressionL1Results::l1Results ( const edm::Event &  iEvent )

private

Definition at line 2089 of file L1GtUtils.cc.

                                                                          {
  // reset the vectors before filling them
  reset(m_decisionsBeforeMask);
  reset(m_decisionsAfterMask);
  reset(m_prescaleFactors);
  reset(m_triggerMasks);
  reset(m_errorCodes);
 
  // initialization of actual values for each trigger
  bool decisionBeforeMaskValue = false;
  bool decisionAfterMaskValue = false;
  int prescaleFactorValue = -1;
  int triggerMaskValue = -1;
  int errorCode = -1;
 
  LogDebug("L1GtUtils") << std::endl;
  LogTrace("L1GtUtils") << "\nLogical expression\n  " << m_logicalExpression << std::endl;
 
  // for each trigger, if it is in the L1 menu, get the prescale factor and trigger mask
 
  for (size_t iTrig = 0; iTrig < m_expL1TriggersSize; ++iTrig) {
    const std::string& trigNameOrAlias = (m_expL1Triggers[iTrig]).tokenName;
 
    if (m_expTriggerInMenu[iTrig]) {
      errorCode = m_l1GtUtils.l1Results(iEvent,
                                        trigNameOrAlias,
                                        decisionBeforeMaskValue,
                                        decisionAfterMaskValue,
                                        prescaleFactorValue,
                                        triggerMaskValue);
 
      if (errorCode != 0) {
        // error while retrieving the results
        //    for this trigger: set prescale factor to -1, trigger mask to -1
 
        decisionBeforeMaskValue = false;
        decisionAfterMaskValue = false;
        prescaleFactorValue = -1;
        triggerMaskValue = -1;
      }
 
    } else {
      // no trigger name or trigger alias in the menu, no bits:
      //    for this trigger: set prescale factor to -1, set the error code
 
      decisionBeforeMaskValue = false;
      decisionAfterMaskValue = false;
      prescaleFactorValue = -1;
      triggerMaskValue = -1;
      errorCode = m_l1ConfCode + 1;
    }
 
    LogTrace("L1GtUtils") << "\n" << trigNameOrAlias << ":" << std::endl;
 
    (m_decisionsBeforeMask[iTrig]).second = decisionBeforeMaskValue;
    LogTrace("L1GtUtils") << "    decision before mask = " << decisionBeforeMaskValue << std::endl;
 
    (m_decisionsAfterMask[iTrig]).second = decisionAfterMaskValue;
    LogTrace("L1GtUtils") << "    decision after mask  = " << decisionAfterMaskValue << std::endl;
 
    (m_prescaleFactors[iTrig]).second = prescaleFactorValue;
    LogTrace("L1GtUtils") << "    prescale factor      = " << prescaleFactorValue << std::endl;
 
    (m_triggerMasks[iTrig]).second = triggerMaskValue;
    LogTrace("L1GtUtils") << "    trigger mask         = " << triggerMaskValue << std::endl;
 
    (m_errorCodes[iTrig]).second = errorCode;
    LogTrace("L1GtUtils") << "    error code           = " << errorCode << std::endl;
  }
 
  LogDebug("L1GtUtils") << std::endl;
}

References iEvent, LogDebug, LogTrace, reset(), edm::second(), and AlCaHLTBitMon_QueryRunRegistry::string.

logicalExpressionRunUpdate() [1/2]

const int L1GtUtils::LogicalExpressionL1Results::logicalExpressionRunUpdate	(	const edm::Run &	iRun,
		const edm::EventSetup &	evSetup
	)

keep the logical expression given in the previous run

Definition at line 1934 of file L1GtUtils.cc.

                                                                                                          {
  // check first that a valid L1 configuration was retrieved,
  // to prevent also calls before the L1 configuration retrieval
 
  // initialize error code and L1 configuration code
  int errorCode = 0;
  int l1ConfCode = 0;
 
  if (!(m_l1GtUtils.availableL1Configuration(errorCode, l1ConfCode))) {
    m_validL1Configuration = false;
    return errorCode;
  } else {
    m_validL1Configuration = true;
    m_l1ConfCode = l1ConfCode;
  }
 
  // check if the trigger (name of alias) from the logical expression are in the menu,
  // if names are used, set tokenNumber to the corresponding bit number
  // if technical trigger bits, set tokenName to the corresponding technical trigger name, if
  //   a technical trigger exists on that bit
  // for each trigger, set also the trigger category
 
  // initialization
  L1GtUtils::TriggerCategory trigCategory = L1GtUtils::AlgorithmTrigger;
  int bitNumber = -1;
 
  for (size_t iTrig = 0; iTrig < m_expL1TriggersSize; ++iTrig) {
    trigCategory = L1GtUtils::AlgorithmTrigger;
    bitNumber = -1;
    const std::string& trigNameOrAlias = (m_expL1Triggers[iTrig]).tokenName;
 
    if (!m_expBitsTechTrigger) {
      const bool triggerInMenu = m_l1GtUtils.l1AlgoTechTrigBitNumber(trigNameOrAlias, trigCategory, bitNumber);
 
      (m_expL1Triggers[iTrig]).tokenNumber = bitNumber;
      m_expTriggerCategory[iTrig] = trigCategory;
      m_expTriggerInMenu[iTrig] = triggerInMenu;
 
    } else {
      std::string aliasL1Trigger;
      std::string nameL1Trigger;
 
      trigCategory = L1GtUtils::TechnicalTrigger;
      bitNumber = (m_expL1Triggers[iTrig]).tokenNumber;
 
      const bool triggerInMenu =
          m_l1GtUtils.l1TriggerNameFromBit(bitNumber, trigCategory, aliasL1Trigger, nameL1Trigger);
 
      if (!triggerInMenu) {
        aliasL1Trigger = "Technical_trigger_bit_" + (m_expL1Triggers[iTrig]).tokenName + "_empty";
      }
 
      (m_expL1Triggers[iTrig]).tokenName = aliasL1Trigger;
      m_expTriggerCategory[iTrig] = trigCategory;
      m_expTriggerInMenu[iTrig] = triggerInMenu;
 
      // put the names of the technical triggers in the returned quantities
 
      (m_decisionsBeforeMask[iTrig]).first = aliasL1Trigger;
      (m_decisionsAfterMask[iTrig]).first = aliasL1Trigger;
      (m_prescaleFactors[iTrig]).first = aliasL1Trigger;
      (m_triggerMasks[iTrig]).first = aliasL1Trigger;
      (m_errorCodes[iTrig]).first = aliasL1Trigger;
    }
  }
 
  return errorCode;
}

References L1GtUtils::AlgorithmTrigger, L1TBPTX_cfi::bitNumber, dqmdumpme::first, AlCaHLTBitMon_QueryRunRegistry::string, and L1GtUtils::TechnicalTrigger.

logicalExpressionRunUpdate() [2/2]

const int L1GtUtils::LogicalExpressionL1Results::logicalExpressionRunUpdate	(	const edm::Run &	iRun,
		const edm::EventSetup &	evSetup,
		const std::string &	logicExpression
	)

update quantities related to the logical expression at the beginning of the run new logical expression, replacing the logical expression given the in previous run

Definition at line 1900 of file L1GtUtils.cc.

                                                                                                              {
  // initialize error code
  int errorCode = 0;
 
  // logical expression has changed - one must re-initialize all quantities related to the logical expression
  // and clear the vectors
 
  m_logicalExpression = logicExpression;
  m_validLogicalExpression = false;
 
  m_l1ResultsAlreadyCalled = false;
 
  m_expL1TriggersSize = 0;
  m_expBitsTechTrigger = false;
 
  //
  m_decisionsBeforeMask.clear();
  m_decisionsAfterMask.clear();
  m_prescaleFactors.clear();
  m_triggerMasks.clear();
  m_errorCodes.clear();
  m_expTriggerCategory.clear();
  m_expTriggerInMenu.clear();
 
  initialize();
 
  //
  errorCode = logicalExpressionRunUpdate(iRun, evSetup);
 
  return errorCode;
}

References initialize().

Referenced by L1GtAnalyzer::beginRun().

prescaleFactors()

const std::vector< std::pair< std::string, int > > & L1GtUtils::LogicalExpressionL1Results::prescaleFactors

(

)

Definition at line 2028 of file L1GtUtils.cc.

                                                                                                {
  // throw an exception if the result is not computed once per event - user usage error
  if (!m_l1ResultsAlreadyCalled) {
    throw cms::Exception("FailModule")
        << "\nUsage error: "
        << "\n  Method 'errorCodes' must be called in the event loop before attempting to use this method.\n"
        << std::endl;
  }
 
  return m_prescaleFactors;
}

References Exception.

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore().

reset() [1/2]

void L1GtUtils::LogicalExpressionL1Results::reset ( const std::vector< std::pair< std::string, bool > > &  _pairVector ) const

private

reset for each L1 trigger the value from pair.second

Definition at line 2075 of file L1GtUtils.cc.

                                                                                                             {
  std::vector<std::pair<std::string, bool> > pairVector = _pairVector;
  for (size_t iTrig = 0; iTrig < m_expL1TriggersSize; ++iTrig) {
    (pairVector[iTrig]).second = false;
  }
}

References edm::second().

reset() [2/2]

void L1GtUtils::LogicalExpressionL1Results::reset ( const std::vector< std::pair< std::string, int > > &  _pairVector ) const

private

Definition at line 2082 of file L1GtUtils.cc.

                                                                                                            {
  std::vector<std::pair<std::string, int> > pairVector = _pairVector;
  for (size_t iTrig = 0; iTrig < m_expL1TriggersSize; ++iTrig) {
    (pairVector[iTrig]).second = -1;
  }
}

References edm::second().

triggerMasks()

const std::vector< std::pair< std::string, int > > & L1GtUtils::LogicalExpressionL1Results::triggerMasks

(

)

Definition at line 2040 of file L1GtUtils.cc.

                                                                                             {
  // throw an exception if the result is not computed once per event - user usage error
  if (!m_l1ResultsAlreadyCalled) {
    throw cms::Exception("FailModule")
        << "\nUsage error: "
        << "\n  Method 'errorCodes' must be called in the event loop before attempting to use this method.\n"
        << std::endl;
  }
 
  return m_triggerMasks;
}

References Exception.

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore().

Member Data Documentation

m_decisionsAfterMask

std::vector<std::pair<std::string, bool> > L1GtUtils::LogicalExpressionL1Results::m_decisionsAfterMask

private

Definition at line 237 of file L1GtUtils.h.

m_decisionsBeforeMask

std::vector<std::pair<std::string, bool> > L1GtUtils::LogicalExpressionL1Results::m_decisionsBeforeMask

private

Definition at line 236 of file L1GtUtils.h.

m_errorCodes

std::vector<std::pair<std::string, int> > L1GtUtils::LogicalExpressionL1Results::m_errorCodes

private

Definition at line 240 of file L1GtUtils.h.

m_expBitsTechTrigger

bool L1GtUtils::LogicalExpressionL1Results::m_expBitsTechTrigger

private

flag true, if the logical expression is built from technical trigger bits

Definition at line 229 of file L1GtUtils.h.

m_expL1Triggers

std::vector<L1GtLogicParser::OperandToken> L1GtUtils::LogicalExpressionL1Results::m_expL1Triggers

private

Definition at line 222 of file L1GtUtils.h.

Referenced by expL1Triggers().

m_expL1TriggersSize

size_t L1GtUtils::LogicalExpressionL1Results::m_expL1TriggersSize

private

Definition at line 223 of file L1GtUtils.h.

m_expTriggerCategory

std::vector<L1GtUtils::TriggerCategory> L1GtUtils::LogicalExpressionL1Results::m_expTriggerCategory

private

trigger category for each L1 trigger in the logical expression

Definition at line 226 of file L1GtUtils.h.

m_expTriggerInMenu

std::vector<bool> L1GtUtils::LogicalExpressionL1Results::m_expTriggerInMenu

private

for each L1 trigger in the logical expression, true if the trigger is found in the current L1 menu

Definition at line 233 of file L1GtUtils.h.

m_l1ConfCode

int L1GtUtils::LogicalExpressionL1Results::m_l1ConfCode

private

code for L1 trigger configuration

Definition at line 211 of file L1GtUtils.h.

m_l1GtUtils

L1GtUtils& L1GtUtils::LogicalExpressionL1Results::m_l1GtUtils

private

Definition at line 205 of file L1GtUtils.h.

m_l1ResultsAlreadyCalled

bool L1GtUtils::LogicalExpressionL1Results::m_l1ResultsAlreadyCalled

private

set to true if the method l1Results was called once

Definition at line 220 of file L1GtUtils.h.

m_logicalExpression

std::string L1GtUtils::LogicalExpressionL1Results::m_logicalExpression

private

private members as input parameters

logical expression

Definition at line 203 of file L1GtUtils.h.

m_prescaleFactors

std::vector<std::pair<std::string, int> > L1GtUtils::LogicalExpressionL1Results::m_prescaleFactors

private

Definition at line 238 of file L1GtUtils.h.

m_triggerMasks

std::vector<std::pair<std::string, int> > L1GtUtils::LogicalExpressionL1Results::m_triggerMasks

private

Definition at line 239 of file L1GtUtils.h.

m_validL1Configuration

bool L1GtUtils::LogicalExpressionL1Results::m_validL1Configuration

private

true if valid L1 configuration - if not, reset all quantities and return

Definition at line 214 of file L1GtUtils.h.

m_validLogicalExpression

bool L1GtUtils::LogicalExpressionL1Results::m_validLogicalExpression

private

true if the logical expression uses accepted L1GtLogicParser operators

Definition at line 217 of file L1GtUtils.h.

Referenced by isValid().