ChainGroup.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGGER_DECISION_TOOL_CHAIN_GROUP_H
#define TRIGGER_DECISION_TOOL_CHAIN_GROUP_H
 
/**********************************************************************************
 * @Project: TrigDecisionTool
 * @Package: TrigDecisionTool
 * @class  : ChainGroup
 *
 * @brief container to hold trigger chains
 *
 * @author Michael Begel  <michael.begel@cern.ch>  - Brookhaven National Laboratory
 * @author Joerg Stelzer  <Joerg.Stelzer@cern.ch>  - DESY
 * @author Tomasz Bold     <Tomasz.Bold@cern.ch>   - UC Irvine - AGH-UST Krakow
 *
 ***********************************************************************************/
 
 
 
#include "TrigDecisionInterface/Conditions.h"
#include "TrigDecisionInterface/GroupProperties.h"
#include "TrigDecisionTool/CacheGlobalMemory.h"
#include "TrigDecisionTool/FeatureContainer.h"
#include "TrigDecisionTool/Logger.h"
#include "TrigAnalysisHelpers/FeatureRequestDescriptor.h"
#include "TrigSteeringEvent/Enums.h"
#include "TrigCompositeUtils/TrigCompositeUtils.h"
 
#include <iterator>
#include <vector>
#include <string>
#include <string_view>
 
namespace HLT {
  class Chain;
}
 
namespace LVL1CTP {
  class Lvl1Item;
}
 
namespace TrigConf {
  class TriggerItem;
  class HLTChain;
  class HLTTriggerElement;
}
 
 
namespace Trig {
 
   class ChainGroup : public virtual Logger {
 
     friend class CacheGlobalMemory;
 
   public:
 
      ChainGroup(const std::vector< std::string >& triggerNames,
                 Trig::CacheGlobalMemory& parent);
      ~ChainGroup() = default;
 
      typedef std::vector<std::string>::const_iterator const_iterator;
      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);
 

      bool isPassed(unsigned int condition=TrigDefs::Physics) const;
      
      std::vector<bool> isPassedForEach(unsigned int condition=TrigDefs::Physics) const;

      float getPrescale(unsigned int condition=TrigDefs::Physics) const;
 
 
      std::vector< std::string > getListOfTriggers() const;  // cppcheck-suppress returnByReference; for consistency
      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;

      std::vector<unsigned int> isPassedBitsForEach() const;
 

      HLT::ErrorCode error() const;
 

      const FeatureContainer features(unsigned int condition = TrigDefs::Physics) const;
      
      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;
 
      // 
      const std::vector< std::string >& patterns() const {return m_patterns;}
   private:
 
      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 {return m_names;}
 
      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;
 
      std::vector<std::string> m_patterns;  
    
      std::vector<const TrigConf::HLTChain*>           m_confChains;
      std::vector<const TrigConf::TriggerItem*>        m_confItems;
 
#ifndef __REFLEX__
      // quick cache (external therefore reference) of the result per event
      Trig::CacheGlobalMemory&                       m_cgm;
#endif
      std::vector< std::string > m_names; 
 
      const Trig::CacheGlobalMemory& cgm_assert() const;
      const Trig::CacheGlobalMemory& cgm() const { return m_cgm; }
      Trig::CacheGlobalMemory& cgm() { return m_cgm; }
 
      // update the configuration
      void update(const TrigConf::HLTChainList* confChains,
                  const TrigConf::ItemContainer* confItems,
                  TrigDefs::Group prop = TrigDefs::Group::Default);
 
      ChainGroup& operator= (const ChainGroup&);
 
      float m_prescale{0};
 
   };
} // End of namespace
 
#include "ChainGroup.icc"
 
#endif