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, std::string_view 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 54 of file ChainGroup.h.

Member Typedef Documentation

const_iterator

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

Definition at line 64 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 795 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 421 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->has_l2() && 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" || ch->level()=="EF") { // && !ch->has_l2() - implied
        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 194 of file ChainGroup.h.

{ return m_cgm; }

cgm() [2/2]

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

inlineprivate

Definition at line 193 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 356 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 323 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,
		std::string_view	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 733 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 585 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 495 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 509 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 480 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 525 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 563 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 475 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 415 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 226 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 334 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 351 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.has_l2() && 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" || chain.level()=="EF"){ // && !chain.has_l2() - implied
      result = result && L1Result(getLowerName(chain.chain_name()),condition);
  
    } else {
 
      ATH_MSG_ERROR("Unknown chain level " << chain.level() << " cannot do 'enforceLogicalFlow'");
    }
 
  }
 
  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 213 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 313 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 266 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->has_l2() && 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" || ch->level()=="EF") { // && !ch->has_l2() - implied
      RESULT = RESULT | L1Bits(getLowerName(ch->chain_name()));
 
    } else {
      ATH_MSG_ERROR("Unknown chain level " << ch->level() << " cannot look at lower level results to compute isPassedBitsForEach");
    }
 
    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 198 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 249 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 382 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& thisItem : convertStringToVector(item)) {
      if(L1Result(thisItem,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 168 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 155 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 599 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
        std::regex compiled(pat);
 
        for(TrigConf::HLTChain* ch : *confChains) {
           if ( std::regex_match(ch->chain_name().c_str(), compiled) ) {
              m_confChains.push_back(ch);
           }
        }
 
        for(TrigConf::TriggerItem* item : *confItems) {
           if ( std::regex_match(item->name().c_str(), 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 56 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 188 of file ChainGroup.h.

m_confChains

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

private

Definition at line 183 of file ChainGroup.h.

m_confItems

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

private

Definition at line 184 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 190 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 181 of file ChainGroup.h.

m_prescale

float Trig::ChainGroup::m_prescale {0}

private

Definition at line 203 of file ChainGroup.h.

{0};

---

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

• ChainGroup.h
• ChainGroup.cxx