/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/TrigDecisionTool/TrigDecisionTool/Combination.h

// -*- c++ -*-
#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 "boost/foreach.hpp"
#include <vector>

#include "xAODBase/IParticle.h"
#include "xAODBase/IParticleContainer.h"

#if defined(ASGTOOL_ATHENA) && !defined(XAOD_ANALYSIS)
#include "TrigDecisionTool/FeatureCollectAthena.h"
#endif

#include "TrigDecisionTool/FeatureCollectStandalone.h"

class HltNaviChecker;

namespace Trig {

  class CacheGlobalMemory;

  class Combination 
  {  
  public:

    Combination();

    Combination(const std::vector<HLT::TriggerElement*>& tes, const Trig::CacheGlobalMemory* cgm);


    const 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>
     const 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;
    bool operator<(const Combination& other) const;
    

  private:
    friend class ::HltNaviChecker;

    // helper functionality for collect using traits class to determine how to access
    // the navigation

    HLT::TrigNavStructure* navigation() const;

    std::vector<const HLT::TriggerElement*> m_tes;
    const Trig::CacheGlobalMemory* m_cgm;
  };
} // EOF namespace Trig




template <class T>
const 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(ASGTOOL_ATHENA) && !defined(XAOD_ANALYSIS)
  BOOST_FOREACH( const HLT::TriggerElement* te, m_tes )
    FeatureAccessImpl::collect<T>(te, data, label, condition, teName, navigation());
  BOOST_FOREACH( Feature<T>& f, data ) {
    if ( f.owned() ) {
      m_cgm->deleteAtTheEndOfEvent( const_cast<T*>( 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;
}



MsgStream& operator<< ( MsgStream& m, const Trig::Combination& c );


#endif

---