TrigNavStructure.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef TRIGNAVSTRUCTURE_TRIGNAVSTRUCTURE_H
#define TRIGNAVSTRUCTURE_TRIGNAVSTRUCTURE_H
 
#include <vector>
#include <mutex>
 
#include "AsgTools/SlotSpecificObj.h"
#include "CxxUtils/checker_macros.h"
#include "TrigNavStructure/TriggerElement.h"
#include "TrigNavStructure/TriggerElementFactory.h"
#include "TrigNavStructure/BaseHolder.h"
 
#include "TrigNavStructure/TrigHolderStructure.h"
 
namespace HLTNavDetails {
  // RAII trick to fill sizes at the exit of the function
  // at construction the extra word is reserved and the current size remembered
  // at destruction the current size is filled at the previously reserved index
  struct FillSize {
    std::vector<uint32_t>& m_output;
    size_t m_index;
    FillSize(std::vector<uint32_t>& o)
      : m_output(o), m_index(m_output.size()) {
      m_output.push_back(0);
    }
    ~FillSize() {
      m_output[m_index]  = m_output.size();
    }
  };
}
 
namespace HLT {
  class TrigNavStructure {
  public:
    
    virtual ~TrigNavStructure();
 
    virtual void reset(bool inFinalize = false);
 
    TriggerElement* getInitialNode();
    const TriggerElement* getInitialNode() const;
 
    TriggerElement* addRoINode( TriggerElement* initial );
 
    static const std::vector<TriggerElement*>& getRoINodes( const TriggerElement* somenode );
 
    TriggerElement* addNode( TriggerElement* seed, unsigned int id );
 
    TriggerElement* addNode( std::vector<TriggerElement* >& seeds, unsigned int id, bool ghost=false, bool nofwd=false );
 
    static const std::vector<TriggerElement*>& getDirectPredecessors( const TriggerElement* te );
 
    static const std::vector<TriggerElement*>& getDirectSuccessors( const TriggerElement* te );
 
    static const TriggerElement* getSuccessor( const TriggerElement* te, unsigned int id );
 
    static bool isInitialNode( const TriggerElement* te );
 
    static bool isRoINode( const TriggerElement* te );
 
    static bool isTerminalNode( const TriggerElement* te );
 
 
    void printASCIIArt( std::string& str, const TriggerElement* te = 0, int offset = 0 ) const;
 
    bool serializeTEs( std::vector<uint32_t>& output ) const;
    bool deserializeTEs( std::vector<uint32_t>::const_iterator& start, unsigned int totalSize);
 
    virtual bool serialize( std::vector<uint32_t>&) const = 0;
    virtual bool deserialize( const std::vector<uint32_t>&) = 0;
 
    TriggerElement::FeatureAccessHelper getFeature(const TriggerElement* te, class_id_type clid, const index_or_label_type& index_or_label) const;
 
 
    TriggerElement::FeatureAccessHelper getFeatureRecursively(const TriggerElement* startTE, class_id_type clid,
                                  const index_or_label_type& index_or_label, const TriggerElement*& sourceTE) const;
 
 
    void getAllRoIThresholdTEs( std::vector< TriggerElement* >& output ) const;
 
    void getAll( std::vector< TriggerElement* >& output, const bool activeOnly = true ) const;
 
    std::vector<TriggerElement*>& getAllTEs();
 
    const std::vector<TriggerElement*>& getAllTEs() const;
 
    void getAllOfType( const te_id_type id, std::vector< TriggerElement* >& output,  const bool activeOnly = true ) const;    
 
 
 
    unsigned int countAllOfType( const te_id_type id, const bool activeOnly = true ) const;
 
    static bool haveCommonRoI( const TriggerElement* te1,  const TriggerElement* te2 );
 
    static bool haveDistinctRoI(const TriggerElement* te1, const TriggerElement* te2 );
 
    static bool haveAllCommonRoIs ( const HLT::TriggerElement* te1, const HLT::TriggerElement* te2 );
 
    static bool haveCommonSeed( const TriggerElement* te1, const TriggerElement* te2 );
 
    static bool haveDistinctSeed( const TriggerElement* te1, const TriggerElement* te2 );
 
    static bool increasingOrderByTEId( const TriggerElement* te1, const TriggerElement* te2 );
    static bool decreasingOrderByTEId( const TriggerElement* te1, const TriggerElement* te2 );
 
    static bool hasIdFromTheSet( const TriggerElement* te, std::vector<unsigned int> ids );
 
    static inline bool isNotActive( const TriggerElement* te ) { return !te->getActiveState(); }
 
    static inline bool isTopological( const TriggerElement* te) { return (getDirectPredecessors(te).size() > 1 ? true : false); }
 
    static bool isCompatibleTree(const TriggerElement* te1, const TriggerElement* te2 );
 
 
    
    bool propagateDeactivation(const TrigNavStructure* nav);
 
 
 
    bool combine(std::vector<unsigned int>& types,
                 std::vector< std::vector<TriggerElement*> >& output,
                 unsigned int maxResults = 1000, bool onlyActive = true);
 
    bool overlaps(const TriggerElement* t1, const TriggerElement* t2) const;
 
    bool overlaps(const TriggerElement* t1, const std::vector<TriggerElement*>& teVec) const;
 
 
    bool getTopologicallySpannedBy( const TriggerElement* te, const std::vector<unsigned int>& types,
                    std::vector<const TriggerElement*>& children, const bool activeOnly = true ) const;
 
    unsigned int copyAllFeatures( const TriggerElement* sourceTE, TriggerElement* destTE);
 
    const BaseHolder* getHolder(const TriggerElement::FeatureAccessHelper& fea) const;
 
    sub_index_type subType(class_id_type clid, const index_or_label_type& sti_or_label) const;
    std::string label(class_id_type clid, const index_or_label_type& sti_or_label) const;
 
 
    virtual bool getFeatureAccessors( const TriggerElement* te, class_id_type clid,
                      const index_or_label_type& index_or_label,
                      bool only_single_feature,
                          TriggerElement::FeatureVec& features,
                          bool travel_backward_recursively,
                          const TriggerElement*& source = m_unspecifiedTE, 
                          std::string& sourcelabel  = m_unspecifiedLabel) const;
  protected:
 
    virtual bool getFeatureAccessorsSingleTE( const TriggerElement* te, class_id_type clid,
                          const index_or_label_type& index_or_label,
                          bool only_single_feature,
                          TriggerElement::FeatureVec& features,
                          const TriggerElement*& source,
                          std::string& sourcelabel ) const ;
    
    
    //method to see if feature matches by clid and either index or label
    bool matchFeature(const TriggerElement::FeatureAccessHelper& fea, class_id_type clid,  const index_or_label_type& index_or_label) const;
 
    void fillSameRoIRelation ( TriggerElement* roi, TriggerElement* te );
 
    bool addOneLevel(std::vector< std::vector<TriggerElement*> >& currentCombs,
                     std::vector< std::vector<std::pair<unsigned int, unsigned int> > >& currentIdxs,
                     unsigned int type,
                     std::vector< std::vector<TriggerElement*> >& newCombs,
                     std::vector< std::vector<std::pair<unsigned int, unsigned int> > >& newIdxs,
                     unsigned int maxResults = 1000, bool onlyActive = 1);
 
 
    TriggerElementFactory& getFactory() { return *m_factory; }
    TrigHolderStructure& getHolderStorage() { return *m_holderstorage; }
    std::recursive_mutex& getMutex() { return s_rmutex; }
 
    const TriggerElementFactory& getFactory() const { return *m_factory; }
    const TrigHolderStructure& getHolderStorage() const { return *m_holderstorage; }
    std::recursive_mutex& getMutex() const { return s_rmutex; }
 
    static const TriggerElement* m_unspecifiedTE ATLAS_THREAD_SAFE;
    static std::string m_unspecifiedLabel ATLAS_THREAD_SAFE;
 
  private:
 
    SG::SlotSpecificObj<TriggerElementFactory> m_factory;                     
    SG::SlotSpecificObj<TrigHolderStructure> m_holderstorage;                 
 
    static std::recursive_mutex s_rmutex;
 
  };
} // end of HLT namespace
 
#endif // TRIGNAVSTRUCTURE_TRIGNAVSTRUCTURE_H