Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/Combination.h

Go to the documentation of this file.

// -*- c++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGGER_DECISION_TOOL_Combination_H
#define TRIGGER_DECISION_TOOL_Combination_H
 
/**********************************************************************************
 * @Project:
 * @Package: TrigDecision
 * @class  : TrigDecision
 *
 * @brief combination of TEs storage
 *
 * @author Nicolas Berger  <Nicolas.Berger@cern.ch>  - LAPP Annecy
 *
 ***********************************************************************************/
 
 
#include "TrigDecisionTool/Feature.h"
#include "TrigDecisionTool/TypelessFeature.h"
#include "TrigDecisionTool/Conditions.h"
#include "TrigDecisionTool/CacheGlobalMemory.h"
#include "TrigNavStructure/TrigNavStructure.h"
#include <vector>
 
#include "xAODBase/IParticle.h"
#include "xAODBase/IParticleContainer.h"
 
#if !defined(XAOD_STANDALONE) && !defined(XAOD_ANALYSIS) // Full athena
#include "TrigDecisionTool/FeatureCollectAthena.h"
#endif
 
#include "TrigDecisionTool/FeatureCollectStandalone.h"
 
#include "boost/container_hash/hash_fwd.hpp"
 
class HltNaviChecker;
 
namespace Trig {
 
  class CacheGlobalMemory;
 
  class Combination 
  {  
  public:
 
    Combination() = default;
 
    Combination(const std::vector<HLT::TriggerElement*>& tes, const Trig::CacheGlobalMemory* cgm);
 
 
    std::vector<Trig::TypelessFeature> typelessGet(HLT::class_id_type clid, const std::string& label = "", unsigned int condition = TrigDefs::Physics, const std::string & teName = "" ) const;
 
     template<class T>
     std::vector<Trig::Feature<T> > get(const std::string& label = "", unsigned int condition=TrigDefs::Physics, const std::string& teName = "") const;
 
    
    template<typename CONTAINER> using ELEMENT_OF = typename CONTAINER::base_value_type;
 
    std::vector<Trig::Feature<xAOD::IParticle> > getIParticle(HLT::class_id_type clid, const std::string& container_name, const std::string& label = "", unsigned int condition = TrigDefs::Physics, const std::string & teName = "" ) const{
      auto features = typelessGet(clid,label,condition,teName);
      return FeatureAccessImpl::typedGet<xAOD::IParticle,xAOD::IParticleContainer,xAOD::IParticleContainer>(features,
                                                        navigation(),
                                                        m_cgm->store(),
                                                        container_name); 
    }
 
    template<typename CONTAINER>
    std::vector<Feature<ELEMENT_OF<CONTAINER> > > elementFeature(const std::string& label = "", unsigned int condition = TrigDefs::Physics, const std::string& teName = "") const{
      auto features = typelessGet(ClassID_traits<ELEMENT_OF<CONTAINER> >::ID(),label,condition,teName);
      return FeatureAccessImpl::typedGet<ELEMENT_OF<CONTAINER>,ELEMENT_OF<CONTAINER>,CONTAINER>(features,navigation(),m_cgm->store());
    }
 
    template<typename CONTAINER>
    std::vector<Feature<CONTAINER> > containerFeature(const std::string& label = "", unsigned int condition = TrigDefs::Physics, const std::string& teName = "") const{
      auto features = typelessGet(ClassID_traits<CONTAINER>::ID(),label,condition,teName);
      return FeatureAccessImpl::typedGet<CONTAINER,CONTAINER,CONTAINER>(features,navigation(),m_cgm->store());
    }
 
    template<typename CONTAINER>
    std::vector<Feature<ELEMENT_OF<CONTAINER> > > flattenedContainerFeature(const std::string& label = "", unsigned int condition = TrigDefs::Physics, const std::string& teName = "") const{
      auto features = typelessGet(ClassID_traits<CONTAINER>::ID(),label,condition,teName);
      return FeatureAccessImpl::typedGet<ELEMENT_OF<CONTAINER>,CONTAINER,CONTAINER>(features,navigation(),m_cgm->store());
    }
 
    unsigned int size() const { return m_tes.size(); }
 
    bool active() const;
 
    const std::vector<const HLT::TriggerElement*>& tes() const {return m_tes; }
 
    template<class T> 
    void collect(const HLT::TriggerElement* te, std::vector<Trig::Feature<T> >& data, 
         const std::string& label, unsigned int condition, const std::string& teName) const;
 
    bool operator==(const Combination& other) const { return m_tes == other.m_tes; }
    bool operator<(const Combination& other) const {  return m_tes < other.m_tes; }
    
 
  private:
    friend class ::HltNaviChecker;
 
    // helper functionality for collect using traits class to determine how to access
    // the navigation
 
    const HLT::TrigNavStructure* navigation() const;
 
    std::vector<const HLT::TriggerElement*> m_tes;
    const Trig::CacheGlobalMemory* m_cgm{nullptr};
  };
} // EOF namespace Trig
 
 
template <class T>
std::vector<Trig::Feature<T> > Trig::Combination::get(const std::string& label, unsigned int condition, const std::string& teName) const
{
  std::vector<Feature<T> > data;
 
#if !defined(XAOD_STANDALONE) && !defined(XAOD_ANALYSIS) // Full athena
  for( const HLT::TriggerElement* te : m_tes )
    FeatureAccessImpl::collect<T>(te, data, label, condition, teName, navigation());
  for( Feature<T>& f : data ) {
    if ( f.owned() ) {
      m_cgm->deleteAtTheEndOfEvent( f.cptr() );
    }
  }  
#else
  std::cerr << "WARNING: Trig::Combination::get is only available in Athena proper" << std::endl;
  (void)label;
  (void)condition;
  (void)teName;
#endif
  return data;
}
 
namespace std {
  template <>
  struct hash<Trig::Combination>
  {
    std::size_t operator()(const Trig::Combination& comb) const {
      return boost::hash_range(comb.tes().begin(), comb.tes().end());
    }
  };
}
 
MsgStream& operator<< ( MsgStream& m, const Trig::Combination& c );
 
 
#endif