TrigNavStructure/TrigNavStructure/TriggerElement.h

Go to the documentation of this file.

// -*- c++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGNAVSTRUCTURE_TRIGGERELEMENT_H
#define TRIGNAVSTRUCTURE_TRIGGERELEMENT_H
 
#include <map>
#include <vector>
#include <string>
#include <stdint.h>
#include <ostream>
 
 
#include "TrigNavStructure/Types.h"
namespace HLT {

  class TriggerElement {
  public:
    
    TriggerElement();
    TriggerElement( te_id_type id, bool ghost, bool nofwd=false);
    ~TriggerElement();

    //    void reset();

    inline te_id_type getId() const { return m_id; }

    inline bool getActiveState() const { return m_state & activeState; }

    void setActiveState( bool state );
 
    inline bool ghost() const { return m_state & ghostState; }
    bool getGhostState() const { return m_state & ghostState; }
    void setGhostState( bool t = true); 
 
    void setTransient(bool t = true) { m_transient = t; }
    bool transient() { return m_transient; }
 
 
    void setErrorState(bool state = true);
 
    inline bool getErrorState() const { return m_state & errorState; }

    class ObjectIndex {
    public:
      
      ObjectIndex();
 
      ObjectIndex(sub_index_type subType, index_type begin, index_type end); 
      sub_index_type subTypeIndex() const;  
      index_type objectsBegin() const;   
      index_type objectsEnd() const;   
      bool isSameOrWithin ( const ObjectIndex* idx) const; 
      void updateBeginAndEnd( index_type begin, index_type end);
      bool operator<(const ObjectIndex& obj) const;
 
      void serialize(std::vector<uint32_t>& output) const;
      void deserialize( std::vector<uint32_t>::const_iterator& inputIt);
 
      void setSubTypeIndex(sub_index_type idx) { m_subTypeIndex = idx; }
      bool valid() const;
      bool operator==(const ObjectIndex& rhs) const {
    if (m_subTypeIndex != rhs.m_subTypeIndex || m_objIndexBegin != rhs.m_objIndexBegin 
        || m_objIndexEnd != rhs.m_objIndexEnd)
      return false;
    return true;
      }
      bool operator!=(const ObjectIndex& rhs) const {
    return ! (*this == rhs);
      }
 
    private:
      sub_index_type m_subTypeIndex;           
      index_type m_objIndexBegin;          
      index_type m_objIndexEnd;            
    };
 
 
 
 

    enum Relation {
      sameRoIRelation,             
      seedsRelation,               
      seededByRelation             
    };

    inline const std::vector<TriggerElement*>& getRelated( Relation rel ) const {
      auto it = m_relations.find (rel);
      if (it != m_relations.end()) {
        return it->second;
      }
      static const std::vector<TriggerElement*> dumvec;
      return dumvec;
    }
 
    enum States { 
      activeState = 0x1,          
      ghostState  = 0x2,          
      nofwdState  = 0x4,          
      errorState  = 0x8           
    };
 
    std::map<Relation, std::vector<TriggerElement*> > m_relations;   

    void relate( TriggerElement* te, Relation r );

    void relate( const std::vector<TriggerElement*>& tes, Relation r );
 
    static unsigned int enquireId( std::vector<uint32_t>::const_iterator& inputIt );

    void serialize( std::vector<uint32_t>& output, const std::map<TriggerElement*, uint16_t>& keys, const TriggerElement* previous ) const;

    void deserialize( std::vector<uint32_t>::const_iterator& inputIt, const std::map<uint16_t, TriggerElement*>& keys, const TriggerElement* previous );
 
 

    class FeatureAccessHelper {      
    public:
      FeatureAccessHelper() 
    : m_CLID(0), m_forget(false) {}
 
      FeatureAccessHelper( class_id_type clid, ObjectIndex index, bool forget=false) 
    : m_CLID(clid), m_index(index),m_forget(forget) {}
 
      //FeatureAccessHelper( unsigned int clid, const ObjectIndex& index, bool forget=false) //!< the only constructor
      //    : m_CLID(clid), m_index(index),m_forget(forget) {}
 
      //method needed for navigation rewiring (AOD->xAOD)
      void setCLIDandIndex(class_id_type clid, sub_index_type idx){
    m_CLID = clid;
    m_index.setSubTypeIndex(idx);
      }
      inline class_id_type getCLID() const {return m_CLID;}     
      inline const ObjectIndex& getIndex() const {return m_index;}   
 
      inline void setForget( bool value = true ) { m_forget = value; }  
      inline bool forget() const { return m_forget; }          
      friend std::ostream& operator<<( std::ostream& o, const FeatureAccessHelper& f ) {
    o << " CLID:" << f.m_CLID 
      << " idx:" << f.m_index.subTypeIndex() 
      << ":" << f.m_index.objectsBegin() 
      << ":" << f.m_index.objectsEnd()   << std::dec;
    return o;
      }
      bool operator==(const FeatureAccessHelper& rhs) const {
    if (m_CLID != rhs.m_CLID || m_index != rhs.m_index)
      return false;
    return true;
      }
      
      bool valid() const { return m_CLID != invalid_class_id and m_index.valid(); }
 
    private:
      class_id_type m_CLID;        
      ObjectIndex   m_index;  
      bool          m_forget; 
    };
    typedef std::vector< FeatureAccessHelper > FeatureVec;

    const std::vector< FeatureAccessHelper >& getFeatureAccessHelpers() const { return m_uses; }
    std::vector< FeatureAccessHelper >& getFeatureAccessHelpers() { return m_uses; }

    void addFeature( class_id_type clid, const ObjectIndex& index, bool forget=false );
    void addFeature( const FeatureAccessHelper& f);
 
    
    const std::vector<FeatureAccessHelper>& getPreviousFeatures() const {return m_prev; }
    std::vector<FeatureAccessHelper>& getPreviousFeatures() {return m_prev; }
    //    void appendFeaturesKeyPrint(const std::vector<FeatureAccessHelper>& k);
 
  private:
    unsigned int m_state;        
    te_id_type m_id;                
    bool m_transient;            
    std::vector< FeatureAccessHelper > m_uses; 
    std::vector< FeatureAccessHelper > m_prev; 
    
  };
} // eof namespace
 
#endif //TRIGNAVSTRUCTURE_TRIGGERELEMENT_H