Trig::ChainGroup Class Reference

#include <ChainGroup.h>

Inheritance diagram for Trig::ChainGroup:

Collaboration diagram for Trig::ChainGroup:

Public Types
typedef std::vector< std::string >::const_iterator	const_iterator

Public Member Functions
	ChainGroup (const std::vector< std::string > &triggerNames, Trig::CacheGlobalMemory &parent)
	~ChainGroup ()=default
const Trig::ChainGroup &	operator+ (const Trig::ChainGroup &rhs)
bool	operator== (const Trig::ChainGroup &rhs)
bool	operator!= (const Trig::ChainGroup &rhs)
void	addAlias (const std::string &alias)
	adds alias (sort understandabel name) to the group
bool	isPassed (unsigned int condition=TrigDefs::Physics) const
	tells if chain group passed
std::vector< bool >	isPassedForEach (unsigned int condition=TrigDefs::Physics) const
	return vector with isPassed decision for each chain
float	getPrescale (unsigned int condition=TrigDefs::Physics) const
	returns prescale factor for chain group with single chain in returns real prescale factor for real chain group composed of many prescaled chains returns 1 if at least one chain is unprescaled
std::vector< std::string >	getListOfTriggers () const
std::vector< std::string >	getListOfStreams () const
std::vector< std::string >	getListOfGroups () const
std::vector< std::string >	getListOfThresholds () const
std::vector< std::string >	getListOfSignatures () const
std::vector< std::vector< std::string > >	getListOfTriggerElements () const
std::vector< std::vector< TrigConf::HLTTriggerElement * > >	getHLTTriggerElements () const
unsigned int	isPassedBits () const
	returns bits (OR ed) of the chain group Meaning of the returned bits can be understood by using masks defined in TrigDefs
std::vector< unsigned int >	isPassedBitsForEach () const
	return result of isPassedBits for each chain in the group
HLT::ErrorCode	error () const
	returns most severe error in the chains composing that chain group for L1 it is just OK If there is suspicion that there are other problems in the CG one needs to loop over chains and check each of them.
const FeatureContainer	features (unsigned int condition=TrigDefs::Physics) const
	returns all features related to given chain group of HLT chains or L1 items Note: This does not yet work for L1_FJ..., i.e.
template<class CONTAINER>
std::vector< TrigCompositeUtils::LinkInfo< CONTAINER > >	features (const asg::EventStoreType *eventStore, const SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > &HLTSummaryKeyIn, unsigned int condition=TrigDefs::Physics, const std::string &containerSGKey="", const unsigned int featureCollectionMode=TrigDefs::lastFeatureOfType, const std::string &navElementLinkKey=TrigCompositeUtils::featureString(), const int restrictToLegIndex=-1) const
	returns typed features related to given chain group of HLT chains or L1 items Note: This is a RUN 3 (and on) function.
const std::vector< std::string > &	patterns () const
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Private Member Functions
bool	isPassed (const TrigConf::HLTChain &chain, unsigned int condition) const
bool	isCorrelatedL1items (const std::string &item) const
float	correlatedL1Prescale (const std::string &item) const
float	calculatePrescale (unsigned int condition=TrigDefs::Physics)
void	appendFeatures (std::vector< std::vector< HLT::TriggerElement * > > &tes, FeatureContainer &fc) const
const std::vector< std::string > &	names () const
	names of triggers within chain group
bool	HLTResult (const std::string &chain, unsigned int condition) const
bool	L1Result (const std::string &item, unsigned int condition) const
unsigned int	HLTBits (const std::string &chain, const std::string &level, const TrigCompositeUtils::DecisionIDContainer &passExpress) const
unsigned int	L1Bits (const std::string &item) const
float	HLTPrescale (const std::string &chain, unsigned int condition) const
float	L1Prescale (const std::string &item, unsigned int condition) const
std::string	getLowerName (const std::string &EFname) const
const Trig::CacheGlobalMemory &	cgm_assert () const
const Trig::CacheGlobalMemory &	cgm () const
Trig::CacheGlobalMemory &	cgm ()
void	update (const TrigConf::HLTChainList *confChains, const TrigConf::ItemContainer *confItems, TrigDefs::Group prop=TrigDefs::Group::Default)
ChainGroup &	operator= (const ChainGroup &)

Private Attributes
std::vector< std::string >	m_patterns
	patterns with which the CG was constructed
std::vector< const TrigConf::HLTChain * >	m_confChains
std::vector< const TrigConf::TriggerItem * >	m_confItems
Trig::CacheGlobalMemory &	m_cgm
std::vector< std::string >	m_names
	names of trigger derived from patterns & current configuration
float	m_prescale {0}

Static Private Attributes
static asg::AsgTool *s_logger	ATLAS_THREAD_SAFE {nullptr}

Friends
class	CacheGlobalMemory

Detailed Description

Definition at line 51 of file ChainGroup.h.

Member Typedef Documentation

const_iterator

typedef std::vector<std::string>::const_iterator Trig::ChainGroup::const_iterator

Definition at line 61 of file ChainGroup.h.

Constructor & Destructor Documentation

ChainGroup()

Trig::ChainGroup::ChainGroup	(	const std::vector< std::string > &	triggerNames,
		Trig::CacheGlobalMemory &	parent )

Definition at line 41 of file ChainGroup.cxx.

  :
  m_patterns(triggerNames),
  m_cgm(parent)
{}

~ChainGroup()

Trig::ChainGroup::~ChainGroup ( )

default

Member Function Documentation

addAlias()

void Trig::ChainGroup::addAlias

(

const std::string &

alias

)

adds alias (sort understandabel name) to the group

Definition at line 66 of file ChainGroup.cxx.

                                                    {
  cgm().createChainGroup(patterns(),alias);
}

appendFeatures()

void Trig::ChainGroup::appendFeatures ( std::vector< std::vector< HLT::TriggerElement * > > & tes, Trig::FeatureContainer & fc ) const

private

Definition at line 788 of file ChainGroup.cxx.

                                                                                                                    {
 
  // appends (combinations of) TriggerElements to FeatureContainer
  if (tes.empty()) // ComboIterator::isValid would return true in this case
    return;
 
  HLT::ComboIterator combination(tes, cgm_assert().navigation());
  while (combination.isValid()) {
    fc.addWithChecking(Combination(*combination, &cgm_assert()));
 
    ATH_MSG_VERBOSE(" adding combination" << Combination(*combination, &cgm_assert()));
 
    ++combination;
  }
}

calculatePrescale()

float Trig::ChainGroup::calculatePrescale ( unsigned int condition = TrigDefs::Physics )

private

Definition at line 413 of file ChainGroup.cxx.

{
  bool singleTrigger = (m_confChains.size()+m_confItems.size()==1);
  
  for ( const TrigConf::HLTChain* ch : m_confChains ) {
    
    const std::string& hltChainName = ch->chain_name();
    float chainRESULT = HLTPrescale(hltChainName,condition);
    
    if (condition & TrigDefs::enforceLogicalFlow) {
      // enforceLogicalFlow
      if (ch->level()=="EF") {
        const std::string& hltChainNameL2 = getLowerName(hltChainName);
        const std::string& l1ItemName     = getLowerName(hltChainNameL2);
        chainRESULT *= HLTPrescale(hltChainNameL2,condition);
        chainRESULT *= L1Prescale(l1ItemName,condition);
        if(l1ItemName.find(',')!=std::string::npos) singleTrigger=false;
    
      } else if (ch->level()=="L2") {
        const std::string& l1ItemName       = getLowerName(hltChainName);
        chainRESULT *= L1Prescale(l1ItemName,condition);
        if(l1ItemName.find(',')!=std::string::npos) singleTrigger=false;
 
      } else if (ch->level()=="HLT") {
        const std::string& l1ItemName       = getLowerName(hltChainName);
        chainRESULT *= L1Prescale(l1ItemName,condition);
        if(l1ItemName.find(',')!=std::string::npos and !isCorrelatedL1items(l1ItemName) ) singleTrigger=false;
      }
    }
 
    if (singleTrigger) return chainRESULT;  // for a single trigger we are done
 
    const bool UNPRESCALED = (fabs(chainRESULT-1.0)<1e-5);
 
    if (UNPRESCALED) return 1.0; // any unprescaled trigger and we are done too
  }
 
 
  for ( const TrigConf::TriggerItem* item : m_confItems ) {
    const std::string& l1ItemName = item->name();
    const float itemRESULT = L1Prescale(l1ItemName, condition);
    if(l1ItemName.find(',')!=std::string::npos) singleTrigger=false;
 
    if (singleTrigger) return itemRESULT; // for a single trigger we are done
 
    const bool UNPRESCALED = (itemRESULT==1);
 
    if (UNPRESCALED) return 1.0; // any unprescaled trigger and we are done too
  }
 
  return 0.0; // multiple triggers and all are prescaled
}

cgm() [1/2]

Trig::CacheGlobalMemory & Trig::ChainGroup::cgm ( )

inlineprivate

Definition at line 191 of file ChainGroup.h.

{ return m_cgm; }

cgm() [2/2]

const Trig::CacheGlobalMemory & Trig::ChainGroup::cgm ( ) const

inlineprivate

Definition at line 190 of file ChainGroup.h.

{ return m_cgm; }

cgm_assert()

const Trig::CacheGlobalMemory & Trig::ChainGroup::cgm_assert ( ) const

private

Definition at line 70 of file ChainGroup.cxx.

                                                              {
  // thread-safe because assert_decision is locked
  auto nonconst_cgm ATLAS_THREAD_SAFE = const_cast<Trig::CacheGlobalMemory*>(&cgm());
  nonconst_cgm->assert_decision();
 
  return cgm();
}

correlatedL1Prescale()

float Trig::ChainGroup::correlatedL1Prescale ( const std::string & item ) const

private

Definition at line 348 of file ChainGroup.cxx.

                                                                      {
  if( (item == "L1_MU20,L1_MU21") || (item == "L1_MU21,L1_MU20") ) {
    //see discussion in ATR-16612
    auto l1mu20 = cgm().config_item("L1_MU20");
    if (l1mu20==nullptr) {
      ATH_MSG_WARNING("Configuration for the item L1_MU20 not known");
      return std::numeric_limits<float>::quiet_NaN();
    }
    float l1mu20ps = cgm().item_prescale(l1mu20->ctpId());
 
    auto l1mu21 = cgm().config_item("L1_MU21");
    if (l1mu21==nullptr) {
      ATH_MSG_WARNING("Configuration for the item L1_MU21 not known");
      return std::numeric_limits<float>::quiet_NaN();
    }
    float l1mu21ps = cgm().item_prescale(l1mu21->ctpId());
    
    if( (l1mu20ps  < 1.0) && (l1mu21ps < 1.0) ) return 0.0;
    if( (l1mu20ps  < 1.0) ) return l1mu21ps;
    if( (l1mu21ps  < 1.0) ) return l1mu20ps;
    if(l1mu20ps == 1.0) return 1.0;
    return 0.0;
  }
  return 0.0;
}

error()

HLT::ErrorCode Trig::ChainGroup::error

(

)

const

returns most severe error in the chains composing that chain group for L1 it is just OK If there is suspicion that there are other problems in the CG one needs to loop over chains and check each of them.

Definition at line 315 of file ChainGroup.cxx.

                                         {
  HLT::ErrorCode errorCode = HLT::OK;  
  for ( const TrigConf::HLTChain* ch : m_confChains ) {
    const HLT::Chain* fchain = cgm_assert().chain(ch->chain_name());
    if (fchain==nullptr) continue;
    HLT::ErrorCode ec = fchain->getErrorCode();
    errorCode = errorCode > ec ? errorCode : ec;
  }
  return errorCode;
}

features() [1/2]

template<class CONTAINER>

std::vector< TrigCompositeUtils::LinkInfo< CONTAINER > > Trig::ChainGroup::features	(	const asg::EventStoreType *	eventStore,
		const SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > &	HLTSummaryKeyIn,
		unsigned int	condition = TrigDefs::Physics,
		const std::string &	containerSGKey = "",
		const unsigned int	featureCollectionMode = TrigDefs::lastFeatureOfType,
		const std::string &	navElementLinkKey = TrigCompositeUtils::featureString(),
		const int	restrictToLegIndex = -1 ) const

returns typed features related to given chain group of HLT chains or L1 items Note: This is a RUN 3 (and on) function.

Parameters

[in]	eventStore	Event store pointer. To migrate to readHandles with the rest of the TDT soon
[in]	HLTSummaryKeyIn	SG Key to the navigation summary container
[in]	condition	Condition requirement. Only TrigDefs::Physics and TrigDefs::includeFailedDecisions are supported.
[in]	containerSGKey	Optional requirement to return only features within the specified container name. Not checked if not specified.
[in]	featureCollectionMode	For lastFeatureOfType, stop exploring each route through the navigation once one matching feature has been found.
[in]	navElementLinkKey	Optional name of element link as saved online. The "feature" link is enforced, others may have been added.
[in]	restrictToLegIndex	Optional index of a leg for mult-leg chains. Features will only be returned on the specified leg. Default is all legs.

Returns

Vector of LinkInfo, where each entry wraps an ElementLink to the feature, and the Decision object it came from.

features() [2/2]

const Trig::FeatureContainer Trig::ChainGroup::features

(

unsigned int

condition = TrigDefs::Physics

)

const

returns all features related to given chain group of HLT chains or L1 items Note: This does not yet work for L1_FJ..., i.e.

no features are returned for these items.

Definition at line 726 of file ChainGroup.cxx.

                                                     {
   using namespace ChainGroup_impl;
   FeatureContainer f(&cgm_assert());
 
   // this loop only applies to L2 and EF chain groups
   for (const TrigConf::HLTChain* ch : m_confChains) {
      const HLT::Chain* fchain = cgm_assert().chain(*ch);
      if (fchain) {
         collectCombinations(fchain->getConfigChain(), cgm_assert(), f, condition);
      }
   }
 
   // this part only applies to L1 chain groups
   std::vector< std::vector< HLT::TriggerElement*> > tes;
   std::vector< std::vector< HLT::TriggerElement*> >::iterator tesit;
 
   for(const TrigConf::TriggerItem* item : m_confItems) {
 
      std::set< std::string > threshold_names;
      std::stack<const TrigConf::TriggerItemNode*> nodes;
 
      nodes.push( item->topNode() );
 
      // collect unique list (= set) of threshold names for this item
      while (!nodes.empty()) {
         const TrigConf::TriggerItemNode* node = nodes.top();
         nodes.pop();
         if (node == nullptr)
            continue;
         if (node->isThreshold()) {
            if (node->triggerThreshold()) {
               // available if thresholds have been read in
               if (!node->triggerThreshold()->name().empty())
                  threshold_names.insert(node->triggerThreshold()->name());
            } else if (!node->thresholdName().empty()) {
               // fall back solution
               threshold_names.insert(node->thresholdName());
            }
         }
         for(TrigConf::TriggerItemNode* childnode : node->children()) {
            nodes.push(childnode);
         }
      }
 
      // collect corresponding TEs and add them using appendFeatures()
      tes.clear();
      tes.resize(threshold_names.size());   
      tesit = tes.begin();
      std::set< std::string >::iterator setstrit;
 
      for (setstrit = threshold_names.begin(); setstrit != threshold_names.end(); ++setstrit, ++tesit) {
         cgm_assert().navigation()->getAllOfType(TrigConf::HLTUtils::string2hash(*setstrit), *tesit, true);
      }
 
      appendFeatures(tes, f);    
   }
    
   ATH_MSG_DEBUG("features: features container size: "<< f.getCombinations().size());
   return f;
}

getHLTTriggerElements()

std::vector< std::vector< TrigConf::HLTTriggerElement * > > Trig::ChainGroup::getHLTTriggerElements

(

)

const

Definition at line 577 of file ChainGroup.cxx.

                                                                                                 {
 
  std::set< std::vector< TrigConf::HLTTriggerElement* > > tes;
 
  for( const TrigConf::HLTChain* ch : m_confChains ) {
    for ( const TrigConf::HLTSignature* s : ch->signatureList() ) {
      tes.insert(s->outputTEs());
    }
  }
  return {tes.begin(), tes.end()};
}

getListOfGroups()

vector< string > Trig::ChainGroup::getListOfGroups

(

)

const

Definition at line 487 of file ChainGroup.cxx.

                                      {
 
   vector< string > v;
 
   for( const TrigConf::HLTChain* ch : m_confChains )
      v.assign( ch->groups().begin(), ch->groups().end() );
 
   return v;
}

getListOfSignatures()

std::vector< std::string > Trig::ChainGroup::getListOfSignatures

(

)

const

Definition at line 501 of file ChainGroup.cxx.

                                                                 {
  std::set< std::string > sig;
  for ( const TrigConf::HLTChain* ch : m_confChains ) {
    for ( const TrigConf::HLTSignature* s : ch->signatureList() ) {
      sig.insert(s->label());
    }
  }
  return {sig.begin(), sig.end()};
}

getListOfStreams()

std::vector< std::string > Trig::ChainGroup::getListOfStreams

(

)

const

Definition at line 472 of file ChainGroup.cxx.

                                                              {
  std::set< std::string > streams;
  for ( const TrigConf::HLTChain* ch : m_confChains ) {
    for ( const TrigConf::HLTStreamTag* s : ch->streams() ) {
      streams.insert(s->stream());
    }
  }
  return {streams.begin(), streams.end()};
}

getListOfThresholds()

vector< string > Trig::ChainGroup::getListOfThresholds

(

)

const

Definition at line 517 of file ChainGroup.cxx.

                                          {
 
   set<string> s;   // using a set makes the items in the result vector unique
   std::stack<const TrigConf::TriggerItemNode*> nodes;
   const TrigConf::TriggerItemNode* node;
 
   for( const TrigConf::TriggerItem* item : m_confItems ) {
      nodes.push( item->topNode() );
      while (!nodes.empty()) {
         node = nodes.top(); nodes.pop();
         if (node == NULL)
            continue;
         if (node->isThreshold()) {
            if (node->triggerThreshold()) {
               // available if thresholds have been read in
               if (!node->triggerThreshold()->name().empty())
                  s.insert(node->triggerThreshold()->name());
            } else if (!node->thresholdName().empty()) {
               // fall back solution
               s.insert(node->thresholdName());
            }
         } else {
           for(TrigConf::TriggerItemNode* childnode : node->children()) {
               nodes.push(childnode);
            }
         }
      }
      // I am not using (*it)->topNode()->getAllThresholds() here, because it returns nothing when only ItemDef (and not the thresholds themselves) are defined
   }
 
   return {s.begin(), s.end()};
}

getListOfTriggerElements()

std::vector< std::vector< std::string > > Trig::ChainGroup::getListOfTriggerElements

(

)

const

Definition at line 555 of file ChainGroup.cxx.

                                                                                   {
 
  std::set< std::vector< std::string > > tes;
  std::vector< std::string > t;
 
  for( const TrigConf::HLTChain* ch : m_confChains ) {
    for ( const TrigConf::HLTSignature* s : ch->signatureList() ) {
      t.clear();
      for ( const TrigConf::HLTTriggerElement* te : s->outputTEs() ) {
        t.push_back( te->name());
      }
      tes.insert(t);
    }
  }
  return {tes.begin(), tes.end()};
}

getListOfTriggers()

std::vector< std::string > Trig::ChainGroup::getListOfTriggers

(

)

const

Definition at line 467 of file ChainGroup.cxx.

                                                               {
  return m_names;
}

getLowerName()

std::string Trig::ChainGroup::getLowerName ( const std::string & EFname ) const

private

Definition at line 160 of file ChainGroup.cxx.

                                                                  {
  if ( name.empty() )
    return name;
  const TrigConf::HLTChain* cchain = cgm().config_chain(name);
  if (cchain==nullptr){
    ATH_MSG_WARNING(" Lower chain name used by:  " << name << " is not in the configuration ");
    return "BAD NAME";
  }
  return cchain->lower_chain_name();
}

getPrescale()

float Trig::ChainGroup::getPrescale

(

unsigned int

condition = TrigDefs::Physics

)

const

returns prescale factor for chain group with single chain in returns real prescale factor for real chain group composed of many prescaled chains returns 1 if at least one chain is unprescaled

Definition at line 407 of file ChainGroup.cxx.

                                                              {
  if ( condition != TrigDefs::Physics )
    return 0.0;
  return m_prescale;
}

HLTBits()

unsigned int Trig::ChainGroup::HLTBits ( const std::string & chain, const std::string & level, const TrigCompositeUtils::DecisionIDContainer & passExpress ) const

private

Definition at line 221 of file ChainGroup.cxx.

                                                                                                                                                   {
  unsigned int chainRESULT = 0;
  if (chain.empty()) return chainRESULT;
  const HLT::Chain* fchain = cgm_assert().chain(chain);
  if (fchain==nullptr) return chainRESULT;
  if (level=="L2") {
    if (fchain->chainPassedRaw())  chainRESULT = chainRESULT | TrigDefs::L2_passedRaw;
    if (fchain->isPassedThrough()) chainRESULT = chainRESULT | TrigDefs::L2_passThrough;
    if (fchain->isPrescaled())     chainRESULT = chainRESULT | TrigDefs::L2_prescaled;
    if (fchain->isResurrected())   chainRESULT = chainRESULT | TrigDefs::L2_resurrected;
  } else {//L2EF merged use same EF bits
    if (fchain->chainPassedRaw())  chainRESULT = chainRESULT | TrigDefs::EF_passedRaw;
    if (fchain->isPassedThrough()) chainRESULT = chainRESULT | TrigDefs::EF_passThrough;
    if (fchain->isPrescaled())     chainRESULT = chainRESULT | TrigDefs::EF_prescaled;
    if (fchain->isResurrected())   chainRESULT = chainRESULT | TrigDefs::EF_resurrected;
 
    if (passExpress.count( HLT::Identifier(chain).numeric() ) == 1) {
      chainRESULT = chainRESULT | TrigDefs::Express_passed; 
    }
  }
  return chainRESULT;
}

HLTPrescale()

float Trig::ChainGroup::HLTPrescale ( const std::string & chain, unsigned int condition ) const

private

Definition at line 326 of file ChainGroup.cxx.

                                                                              {
  if (chain=="") return 0.;
 
  const TrigConf::HLTChain* fchain=cgm().config_chain(chain);
  if (fchain==0) { // this is error condition, we always need configuration of the chains in the chaon group!
    ATH_MSG_WARNING("Configuration for the chain: " << chain << " not known");
    return std::numeric_limits<float>::quiet_NaN();
  }
  float chainRESULT = fchain->prescale();
  
  if (chainRESULT < 1)
    chainRESULT = 0.;
    
  return chainRESULT;
}

HLTResult()

bool Trig::ChainGroup::HLTResult ( const std::string & chain, unsigned int condition ) const

private

Definition at line 78 of file ChainGroup.cxx.

                                                                                   {
  bool chainRESULT = false;
  if (chain.empty()) return chainRESULT;
  const HLT::Chain* fchain=cgm_assert().chain(chain);
  if (fchain==nullptr) return chainRESULT;
  
  
  bool RAW               = fchain->chainPassedRaw();
  const bool PASSTHROUGH = fchain->isPassedThrough();
  const bool PRESCALED   = fchain->isPrescaled();
  const bool RESURRECTED = fchain->isResurrected();
  
  // Resurrection overwrites the value in RAW but sets the RESURRECTED flag
  // we should therefore fix RAW appropriately
  if (~condition & TrigDefs::allowResurrectedDecision) {
    if (RESURRECTED) {
      RAW=false;
    }
  }
  //
  // Do we accept the result?
  //
  if (condition & TrigDefs::passedThrough) {
    if (PASSTHROUGH) {chainRESULT=true;}
  }
  if (condition & TrigDefs::requireDecision) {
    if (RAW && !PRESCALED) {chainRESULT=true;}
    if ( condition & TrigDefs::allowResurrectedDecision ) { // prescaling does not matter for RR (it runs in fact because of that
      if (RAW) {chainRESULT=true;}      
    }
 
  }
  // respects resurrection -- is this the appropriate behavior???
  if (condition & TrigDefs::eventAccepted) {
    if ( (RAW  && !PRESCALED) ||  PASSTHROUGH) {chainRESULT=true;}
  }
  ATH_MSG_DEBUG("ChainGroup::HLTResult Counter = " << std::setw(4) << fchain->getChainCounter()
        << " name = "  << fchain->getChainName()
        << " level = " << fchain->getConfigChain()->level()
        << " success (raw) = " << fchain->chainPassedRaw()
        << " pass-through = " << fchain->isPassedThrough()
        << " prescaled = " << fchain->isPrescaled()
        << " rerun = " << fchain->isResurrected()
        << " lastActiveStep = " << fchain->getChainStep()
        << " name = " << std::setw(35) << fchain->getChainName() 
        << " result = " << chainRESULT);
 
  return chainRESULT;
}

isCorrelatedL1items()

bool Trig::ChainGroup::isCorrelatedL1items ( const std::string & item ) const

private

Definition at line 343 of file ChainGroup.cxx.

                                                                    {
  if( (item == "L1_MU20,L1_MU21") || (item == "L1_MU21,L1_MU20") ) return true;
  return false;
}

isPassed() [1/2]

bool Trig::ChainGroup::isPassed ( const TrigConf::HLTChain & chain, unsigned int condition ) const

private

Definition at line 172 of file ChainGroup.cxx.

{
  bool result = HLTResult(chain.chain_name(),condition);
  if (result && (condition & TrigDefs::enforceLogicalFlow)) {
    // enforceLogicalFlow
    if (chain.level()=="EF") {
      const std::string& nexttwo = getLowerName(chain.chain_name());
      result = result && HLTResult(nexttwo,condition);
      result = result && L1Result(getLowerName(nexttwo),condition);
 
    } else if (chain.level()=="L2") {
      result = result && L1Result(getLowerName(chain.chain_name()),condition);
 
    } else if (chain.level()=="HLT"){
      result = result && L1Result(getLowerName(chain.chain_name()),condition);
    }
  }
 
  return result;
}

isPassed() [2/2]

bool Trig::ChainGroup::isPassed

(

unsigned int

condition = TrigDefs::Physics

)

const

tells if chain group passed

Parameters

conditions

is modifying the question

Definition at line 208 of file ChainGroup.cxx.

{
  if (condition & TrigDefs::Express_passed) {
    ATH_MSG_ERROR("Incorrect use of Express_passed bit. Please use isPassedBits() and test for TrigDefs::Express_passed in the returned bit-map.");
  }
 
  // True if any HLT or L1 item passed
  return ( std::any_of(m_confChains.cbegin(), m_confChains.cend(),
                       [&](const TrigConf::HLTChain* ch) {return isPassed(*ch, condition);}) ||
           std::any_of(m_confItems.cbegin(), m_confItems.cend(),
                       [&](const TrigConf::TriggerItem* item) {return L1Result(item->name(), condition);}) );
}

isPassedBits()

unsigned int Trig::ChainGroup::isPassedBits

(

)

const

returns bits (OR ed) of the chain group Meaning of the returned bits can be understood by using masks defined in TrigDefs

Definition at line 305 of file ChainGroup.cxx.

{
  const std::vector<unsigned int> all = isPassedBitsForEach();
  unsigned int result = 0;
  for (unsigned int r : all) {
    result = result | r;
  }
  return result;
}

isPassedBitsForEach()

std::vector< unsigned int > Trig::ChainGroup::isPassedBitsForEach

(

)

const

return result of isPassedBits for each chain in the group

Definition at line 261 of file ChainGroup.cxx.

{
  // This is for the express decision (R3 only), we read this directly from the navigation (not from bits)
  const SG::ReadHandleKey<TrigCompositeUtils::DecisionContainer>* navRHK = cgm().getRun3NavigationKeyPtr();
  TrigCompositeUtils::DecisionIDContainer passExpress;
  if (navRHK && !navRHK->empty()) {
    SG::ReadHandle<TrigCompositeUtils::DecisionContainer> navRH(*navRHK); // No good way to pass in the context here?
    if (navRH.isValid()) {
      const TrigCompositeUtils::Decision* expressTerminusNode = TrigCompositeUtils::getExpressTerminusNode(*navRH);
      if (expressTerminusNode) {
        TrigCompositeUtils::decisionIDs(expressTerminusNode, passExpress);
      }
    }
  }
 
  std::vector<unsigned int> all;
  all.reserve(m_confChains.size() + m_confItems.size());
 
  for ( const TrigConf::HLTChain* ch : m_confChains ) {
 
    unsigned int RESULT = HLTBits(ch->chain_name(), ch->level(), passExpress);
 
    if (ch->level()=="EF") {
      const std::string& nexttwo = getLowerName(ch->chain_name());
      RESULT = RESULT | HLTBits(nexttwo,"L2", passExpress);
      RESULT = RESULT | L1Bits(getLowerName(nexttwo));
      
    } else if (ch->level()=="L2") {
      RESULT = RESULT | L1Bits(getLowerName(ch->chain_name()));
      
    } else if (ch->level()=="HLT") {
      RESULT = RESULT | L1Bits(getLowerName(ch->chain_name()));
    }
 
    all.push_back(RESULT);
  }
 
  for ( const TrigConf::TriggerItem* item : m_confItems ) {
    all.push_back( L1Bits(item->name()) );
  }
 
  return all;
}

isPassedForEach()

std::vector< bool > Trig::ChainGroup::isPassedForEach

(

unsigned int

condition = TrigDefs::Physics

)

const

return vector with isPassed decision for each chain

Parameters

conditions

is modifying the question

The order of decisions is the same as in getListOfTriggers().

Definition at line 193 of file ChainGroup.cxx.

{
  std::vector<bool> result;
  result.reserve(m_confChains.size() + m_confItems.size());
 
  for (const TrigConf::HLTChain* ch : m_confChains) {
    result.push_back( isPassed(*ch, condition) );
  }
  for (const TrigConf::TriggerItem* item : m_confItems) {
    result.push_back( L1Result(item->name(), condition) );
  }
 
  return result;
}

L1Bits()

unsigned int Trig::ChainGroup::L1Bits ( const std::string & item ) const

private

Definition at line 244 of file ChainGroup.cxx.

                                                               {
  unsigned int r = 0;
  if (item.empty()) return r;
  if (item.find(',')!=std::string::npos) {
    for(const std::string& item : convertStringToVector(item)) {
      r |= L1Bits(item);
    }
    return r;
  }
  const LVL1CTP::Lvl1Item* fitem = cgm_assert().item(item);
  if (fitem==nullptr) return r;
  if (fitem->isPassedBeforePrescale()) r = r | TrigDefs::L1_isPassedBeforePrescale;
  if (fitem->isPassedAfterPrescale())  r = r | TrigDefs::L1_isPassedAfterPrescale;
  if (fitem->isPassedAfterVeto())      r = r | TrigDefs::L1_isPassedAfterVeto;
  return r;
}

L1Prescale()

float Trig::ChainGroup::L1Prescale ( const std::string & item, unsigned int condition ) const

private

Definition at line 374 of file ChainGroup.cxx.

                                                                            {
  if (item.empty()) return 0;
 
  if(item.find(',')==std::string::npos) {
    const TrigConf::TriggerItem* fitem=cgm().config_item(item);
    if (fitem==nullptr) {
      ATH_MSG_WARNING("Configuration for the item: " << item << " not known");
      return std::numeric_limits<float>::quiet_NaN();
    }
    // now we can;t access the prescale value because this information doe not come togehther as in HLT
    // we need to go to the cache of L1 items and get it from there  
    float itemprescale = cgm().item_prescale(fitem->ctpId());
    if ( itemprescale < 1) itemprescale = 0;
    return itemprescale;
  } else if(isCorrelatedL1items(item)) {
    return correlatedL1Prescale(item);
  } else {
    float minprescale=0;
    for(const std::string& item : convertStringToVector(item)) {
 
      const TrigConf::TriggerItem* fitem=cgm().config_item(item);
      if (fitem==nullptr) {
        ATH_MSG_WARNING("Configuration for the item: " << item << " not known");
        return std::numeric_limits<float>::quiet_NaN();
      }
      float itemprescale = cgm().item_prescale(fitem->ctpId());
      if ( itemprescale < 1) itemprescale = 0;
      minprescale = (minprescale&&(minprescale<itemprescale)?minprescale:itemprescale); // takes min, except the first time
    }
    return minprescale;
  }
}

L1Result()

bool Trig::ChainGroup::L1Result ( const std::string & item, unsigned int condition ) const

private

Definition at line 129 of file ChainGroup.cxx.

                                                                                 {
  bool r = false;
  if (item.empty()) return r;
  if (item.find(',')!=std::string::npos) {
    for(const std::string& item : convertStringToVector(item)) {
      if(L1Result(item,condition)) return true;
    }
    return false;
  }
  const LVL1CTP::Lvl1Item* fitem=cgm_assert().item(item);
  if (fitem==nullptr) {
    return r;
  }
  ATH_MSG_DEBUG(" success (raw) = " << fitem->isPassedBeforePrescale()
        << " prescaled = " << fitem->isPrescaled()
        << " vetoed = " << fitem->isVeto()
        << " name = " << std::setw(35) << fitem->name()); 
 
  r = fitem->isPassedAfterVeto();
 
  if (condition & TrigDefs::allowResurrectedDecision)
    r = fitem->isPassedBeforePrescale();
 
  //if (condition & TrigDefs::eventAccepted) 
  //  r = fitem->isPassedAfterVeto();
  //else
  //  r = fitem->isPassedBeforePrescale();
  return r;
}

msg() [1/2]

MsgStream & Trig::Logger::msg ( ) const

inlineinherited

Definition at line 29 of file Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/Logger.h.

                           {
      if (s_logger) return s_logger->msg();
      else throw std::runtime_error("TrigDecisionTool Logger not initialized.");
    }

msg() [2/2]

MsgStream & Trig::Logger::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 33 of file Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/Logger.h.

{ return msg() << lvl; }

msgLvl()

bool Trig::Logger::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 34 of file Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/Logger.h.

{ return s_logger && s_logger->msgLvl(lvl); }

names()

const std::vector< std::string > & Trig::ChainGroup::names ( ) const

inlineprivate

names of triggers within chain group

Definition at line 165 of file ChainGroup.h.

{return m_names;}

operator!=()

bool Trig::ChainGroup::operator!=

(

const Trig::ChainGroup &

rhs

)

Definition at line 62 of file ChainGroup.cxx.

                                                         {
  return !(*this==rhs);
}

operator+()

const Trig::ChainGroup & Trig::ChainGroup::operator+

(

const Trig::ChainGroup &

rhs

)

Definition at line 48 of file ChainGroup.cxx.

                                                                         {
  std::vector< std::string > v;
  v.resize(patterns().size()+rhs.patterns().size());
  merge(patterns().begin(), patterns().end(),
        rhs.patterns().begin(), rhs.patterns().end(),
        v.begin());
  return *(cgm().createChainGroup(v));
}

operator=()

ChainGroup & Trig::ChainGroup::operator= ( const ChainGroup & )

private

operator==()

bool Trig::ChainGroup::operator==

(

const Trig::ChainGroup &

rhs

)

Definition at line 58 of file ChainGroup.cxx.

                                                         {
  return Trig::keyWrap(names())==Trig::keyWrap(rhs.names());
}

patterns()

const std::vector< std::string > & Trig::ChainGroup::patterns ( ) const

inline

Definition at line 152 of file ChainGroup.h.

{return m_patterns;}

update()

void Trig::ChainGroup::update ( const TrigConf::HLTChainList * confChains, const TrigConf::ItemContainer * confItems, TrigDefs::Group prop = TrigDefs::Group::Default )

private

Definition at line 591 of file ChainGroup.cxx.

                                             {
 
   m_confChains.clear();
   m_confItems.clear();
   m_names.clear();
 
   // protect against genConf failure
   if (!(confChains && confItems) ) return;
 
   if (!CxxUtils::test(prop, TrigDefs::Group::NoRegex)) {
 
     for(const std::string& pat : m_patterns) {
        // find chains matching pattern
        boost::regex compiled(pat);
        boost::cmatch what;
 
        for(TrigConf::HLTChain* ch : *confChains) {
           if ( boost::regex_match(ch->chain_name().c_str(), what, compiled) ) {
              m_confChains.push_back(ch);
           }
        }
 
        for(TrigConf::TriggerItem* item : *confItems) {
           if ( boost::regex_match( item->name().c_str(), what, compiled) ) {
              m_confItems.push_back(item);
           }
        }
     }
   
   } else { // Do not parse as regex
 
     for(const std::string& what : m_patterns) {
 
        bool found_it = false;
 
        for(TrigConf::HLTChain* ch : *confChains) {
           if (ch->chain_name() == what) {
              m_confChains.push_back(ch);
              found_it = true;
              break;
           }
        }
 
        if (found_it) {
           continue;
        }
 
        for(TrigConf::TriggerItem* item : *confItems) {
           if (item->name() == what) {
              m_confItems.push_back(item);
              found_it = true;
              break;
           }
        }
 
        if (found_it) {
           continue;
        }
 
        ATH_MSG_WARNING("Explicitly requested '" << what << "' be added to a ChainGroup"
          << " but this item or chain could not be found in the menu");
     }
 
   } // parseAsRegex
 
   // Cache the names of all triggers
   m_names.reserve(m_confChains.size() + m_confItems.size());
   for (const TrigConf::HLTChain* ch : m_confChains)     m_names.push_back(ch->chain_name());
   for (const TrigConf::TriggerItem* item : m_confItems) m_names.push_back(item->name());
 
   m_prescale = calculatePrescale(TrigDefs::Physics);
}

Friends And Related Symbol Documentation

CacheGlobalMemory

friend class CacheGlobalMemory

friend

Definition at line 53 of file ChainGroup.h.

Member Data Documentation

ATLAS_THREAD_SAFE

asg::AsgTool* s_logger Trig::Logger::ATLAS_THREAD_SAFE {nullptr}

inlinestaticprivateinherited

Definition at line 38 of file Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/Logger.h.

{nullptr};

m_cgm

Trig::CacheGlobalMemory& Trig::ChainGroup::m_cgm

private

Definition at line 185 of file ChainGroup.h.

m_confChains

std::vector<const TrigConf::HLTChain*> Trig::ChainGroup::m_confChains

private

Definition at line 180 of file ChainGroup.h.

m_confItems

std::vector<const TrigConf::TriggerItem*> Trig::ChainGroup::m_confItems

private

Definition at line 181 of file ChainGroup.h.

m_names

std::vector< std::string > Trig::ChainGroup::m_names

private

names of trigger derived from patterns & current configuration

Definition at line 187 of file ChainGroup.h.

m_patterns

std::vector<std::string> Trig::ChainGroup::m_patterns

private

patterns with which the CG was constructed

Definition at line 178 of file ChainGroup.h.

m_prescale

float Trig::ChainGroup::m_prescale {0}

private

Definition at line 200 of file ChainGroup.h.

{0};

---

The documentation for this class was generated from the following files:

• ChainGroup.h
• ChainGroup.cxx