Feature.h

Go to the documentation of this file.

// -*- c++ -*-
 
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGGER_DECISION_TOOL_Feature_H
#define TRIGGER_DECISION_TOOL_Feature_H
 
/**********************************************************************************
 * @Project:
 * @Package: TrigDecision
 * @class  : Feature
 *
 *
 * @author Nicolas Berger  <Nicolas.Berger@cern.ch>  - LAPP Annecy
 * @author Tomasz Bold     <tomasz.bold@cern.ch>     - UC Irvine, AGH-UST Krakow
 * @author Lukas Heinrich  <lukas.heinrich@cern.ch>  - NYU
 *
 ***********************************************************************************/
 
#include <string>
#include <set>
#include <type_traits>
 
#include "AsgMessaging/MsgStream.h"
 
#include "TrigNavStructure/TriggerElement.h"
#include "xAODTrigger/EmTauRoI.h"
#include "xAODTrigger/EmTauRoIContainer.h"
 
#include "xAODTrigger/MuonRoI.h"
#include "xAODTrigger/MuonRoIContainer.h"
 
#include "xAODTrigger/JetRoI.h"
#include "xAODTrigger/JetRoIContainer.h"
 
#include "TrigDecisionTool/TypelessFeature.h"
 
#if !defined(XAOD_STANDALONE) && !defined(XAOD_ANALYSIS) // Full Athena
#include "TrigStorageDefinitions/EDM_TypeInfo.h"
#endif
 
 
//forward declare ROI types used in is_storable_type use below
//it's important for this to happen outside of Trig 
//e.g. not in the std::is_same call directly a la 
// std::is_same<T,struct Muon_ROI>::value
//so that it does not end up to be a check on is_same<T,Trig::Muon_ROI> 
#if !defined(XAOD_STANDALONE) && !defined(XAOD_ANALYSIS) // Full Athena
class Muon_ROI;
class EmTau_ROI;
class Jet_ROI;
#endif
 
#include "xAODBase/IParticle.h"
 
namespace Trig {
  
  
  template<typename T> struct is_storable_type{
#if !defined(XAOD_STANDALONE) && !defined(XAOD_ANALYSIS) // Full Athena
    static const bool value = 
      !(
    std::is_same<T,Muon_ROI>::value  ||
    std::is_same<T,EmTau_ROI>::value ||
    std::is_same<T,Jet_ROI>::value ||
    std::is_same<T,xAOD::EmTauRoI>::value ||
    std::is_same<T,xAOD::MuonRoI>::value ||
    std::is_same<T,xAOD::JetRoI>::value  ||
    std::is_same<T,xAOD::IParticle>::value
    );
#else // AnalysisBase or AthAnalysis
    static const bool value = false;
#endif
  };
    
  template<typename T,bool> struct link_or_not;
  
 
#if !defined(XAOD_STANDALONE) && !defined(XAOD_ANALYSIS) // Full Athena
  template<typename T> struct link_or_not<T,true>{
    static const bool known =  IsKnownFeature<T>::value; //will cause compile error if not
    typedef typename Features2Container<T>::type container_type;
    typedef typename Features2LinkHelper<T,container_type>::type type;
  };
#endif
 
  struct ElementLink_is_not_available_for_non_storable_types{};
 
  template<typename T> struct link_or_not<T,false>{
    typedef ElementLink_is_not_available_for_non_storable_types type;
  };
 
  template<class T>
  class Feature {
  public:
    typedef T ValueType;
    typedef T* PointerType;
 
    #ifndef __GCCXML__
    typedef typename link_or_not<T,is_storable_type<T>::value >::type link_type;
    #endif
 
    Feature() 
      : m_feature((const T*)0), m_te(0), m_label(""), m_owned(false) { }
 
    Feature(const TypelessFeature& feat, const T* const feature) 
      : m_feature(feature), m_te(feat.te()),
    m_label(feat.label()), m_owned(false) { }
 
    Feature(const TypelessFeature& feat, const std::shared_ptr<const T>& feature) 
      : m_owning_feature(feature),
    m_feature(m_owning_feature.get()),
    m_te(feat.te()), m_label(feat.label()), m_owned(true) { }

    Feature(Feature&&) noexcept = default;

    Feature(const Feature&) = default;
 
    Feature& operator=(const Feature&) = default;
 
    Feature& operator=(Feature&&) = default;
    
    #ifndef __GCCXML__
    Feature(const T* feature, const HLT::TriggerElement* te, const std::string& label = "", const bool own = false, const link_type link = link_type()) 
      : m_feature(feature), m_te(te), m_label(label), m_owned(own), m_link(link) {
      //in Athena if we own this feature, it will be deleted by AnyTypeDeleter in CGM
      //so we're fine by just setting the non-owning ptr.
    }
    #endif

    ~Feature() {
    }

    operator const T*() const { return cptr(); }

    const T* cptr() const { return m_feature; }
    
    operator const HLT::TriggerElement*() const { return m_te; }

    const HLT::TriggerElement* te() const { return m_te; }

    // cppcheck-suppress returnByReference
    operator const std::string() const { return m_label; }

    const std::string& label() const { return m_label; }
    
    bool empty() const { return (!m_te || !m_feature); }
 
    bool owned() const { return m_owned; }
    
    #ifndef __GCCXML__
    link_type link() const {return m_link;}
    #endif
   
  private:
    std::shared_ptr<const T> m_owning_feature;
    const T* m_feature;
    const HLT::TriggerElement* m_te;
    std::string m_label;
    bool m_owned;   
    #ifndef __GCCXML__
    link_type m_link;
    #endif
  };
 

  template<class T>
  bool sameObject(const Feature<T>& a, const Feature<T>& b) {
    return a.cptr() == b.cptr();
  }
 
} // End of namespace
 
template<class T>
MsgStream& operator<< ( MsgStream& m, const Trig::Feature<T>& d ) {
  m << "TE id: " << d.te()->getId() << "obj ptr: " << d.cptr() 
    << " obj type: " << ClassID_traits<T>::typeName() << " label: " << d.label();
  return m;
}
#endif