HLTSequence.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TrigConf_HLTSequence
#define TrigConf_HLTSequence
 
#include "TrigConfL1Data/TrigConfData.h"
 
#include <iosfwd>
#include <fstream>
#include <string>
#include <vector>
 
namespace TrigConf {
 
   class HLTSequence;
   class HLTTriggerElement;
   class DiffStruct;
   std::ostream & operator<<(std::ostream &, const HLTSequence &);

   class HLTSequence : public TrigConfData {
   public:

      HLTSequence();

      HLTSequence( const std::vector<HLTTriggerElement*>& inputTEs,
                   HLTTriggerElement* outputTE,
                   const std::vector<std::string>& algorithms);

      ~HLTSequence();
 
      // accessors
      std::vector<HLTTriggerElement*>& inputTEs() { return m_inputTEs;   } 
      HLTTriggerElement*               outputTE() { return m_outputTE;  } 
      std::vector<std::string>&        algorithms() { return m_algorithms; } 
      HLTTriggerElement*               topoStartTE() { return m_topoStartTE;} 
 
      const std::vector<HLTTriggerElement*>& inputTEs() const { return m_inputTEs;   } 
      const HLTTriggerElement*               outputTE()  const { return m_outputTE;   } 
      const std::vector<std::string>&        algorithms() const { return m_algorithms; } 
      const HLTTriggerElement*               topoStartTE() const { return m_topoStartTE; } 
      unsigned int                           hashId() const;
 
      void set_inputTEs   ( std::vector<HLTTriggerElement*>& inputTEs ) { m_inputTEs = inputTEs;   } 
      void set_outputTE   ( HLTTriggerElement* outputTE );
      void set_algorithms ( std::vector<std::string>& algorithms ) { m_algorithms = algorithms; } 
      void set_topoStartTE( HLTTriggerElement* te ) { m_topoStartTE = te; }         

      void print(const std::string& indent="", unsigned int detail=1) const;
      void writeXML(std::ofstream & xmlfile);
 
      std::string concise() const;
 
      void setL2(bool on=true) { set(); if(on) m_level |= 0x1; else m_level &= 0x6; }
      void setEF(bool on=true) { set(); if(on) m_level |= 0x2; else m_level &= 0x5; }
      void setHLT(bool on=true) { set(); if(on) m_level = 0x4; else m_level &= 0x3; }
 
      void reset() { m_level = 0x8; }
      bool inL2() const { return (m_level&0x1) != 0; }
      bool inEF() const { return (m_level&0x2) != 0; }
      bool inHLT() const { return (m_level&0x4) != 0; }
      bool isSet() const { return (m_level&0x8) == 0; }
 
      bool operator<(const HLTSequence& s) const {
         return name() < s.name();
      }
 
      DiffStruct* compareTo(const HLTSequence* o) const;
 
      // python
      std::string __str__() const;
 
   private:
 
      std::vector<HLTTriggerElement*> m_inputTEs;   
      HLTTriggerElement*              m_outputTE { nullptr };   
      std::vector<std::string>        m_algorithms; 
      HLTTriggerElement*              m_topoStartTE { nullptr }; 
 
      // bit 0 - L2 / bit 1 - EF / bit 2 - HLT / bit 3 - unset
      unsigned int            m_level { 0 };      
      void set() { m_level &= 0x7; }
                                             
      friend std::ostream & operator<<(std::ostream &, const HLTSequence &);
 
   };
 
}
 
#endif