#include <FeatureContainer.h>

Collaboration diagram for Trig::FeatureContainer:

Classes
class	ordering_by_objects_attached
	helper class to support ordered set of features More...

Public Types
typedef std::vector< Combination >::const_iterator	combination_const_iterator
template<typename CONTAINER>
using	ELEMENT_OF = typename CONTAINER::base_value_type

Public Member Functions
	FeatureContainer (const CacheGlobalMemory *cgm=0)
	constructors, destructor
template<class T>
const std::vector< Trig::Feature< T > >	get (const std::string &label="", unsigned int condition=TrigDefs::Physics, const std::string &teName="") const
	returns flattened vector of Features of given type This method is in fact sullied by 3 arguments.
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
template<typename CONTAINER>
std::vector< Feature< ELEMENT_OF< CONTAINER > > >	elementFeature (const std::string &label="", unsigned int condition=TrigDefs::Physics, const std::string &teName="") const
template<typename CONTAINER>
std::vector< Feature< CONTAINER > >	containerFeature (const std::string &label="", unsigned int condition=TrigDefs::Physics, const std::string &teName="") const
template<typename CONTAINER>
std::vector< Feature< ELEMENT_OF< CONTAINER > > >	flattenedContainerFeature (const std::string &label="", unsigned int condition=TrigDefs::Physics, const std::string &teName="") const
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
	typeless version of get
template<class T>
TrigPassFlags	getFlags (const Trig::Feature< T > &f, const std::string &flagsLabel="") const
	access to TrigPassFlags for given trigger object or container in given TE
const std::vector< Trig::Combination > &	getCombinations () const
	gives back reference to combinations collected through append
void	addWithChecking (const Combination &newComb)
	add new combination to the container checking for overlap
void	append (const FeatureContainer &other)

Private Member Functions
const HLT::TrigNavStructure *	navigation () const

Private Attributes
std::vector< Trig::Combination >	m_combinations
	container preserving insertion order
std::unordered_set< Trig::Combination >	m_combinations_unique
	set for ensuring uniqueness in the above container
const Trig::CacheGlobalMemory *	m_cgm {nullptr}

Detailed Description

Definition at line 41 of file FeatureContainer.h.

Member Typedef Documentation

◆ combination_const_iterator

typedef std::vector<Combination>::const_iterator Trig::FeatureContainer::combination_const_iterator

Definition at line 45 of file FeatureContainer.h.

◆ ELEMENT_OF

template<typename CONTAINER>

using Trig::FeatureContainer::ELEMENT_OF = typename CONTAINER::base_value_type

Definition at line 70 of file FeatureContainer.h.

Constructor & Destructor Documentation

◆ FeatureContainer()

Trig::FeatureContainer::FeatureContainer ( const CacheGlobalMemory * cgm = 0 )

inline

constructors, destructor

Definition at line 48 of file FeatureContainer.h.

48: m_cgm(cgm) {}

Trig::FeatureContainer::m_cgm

const Trig::CacheGlobalMemory * m_cgm

Definition FeatureContainer.h:128

Member Function Documentation

◆ addWithChecking()

void Trig::FeatureContainer::addWithChecking ( const Combination & newComb )

add new combination to the container checking for overlap

Definition at line 19 of file FeatureContainer.cxx.

{
  /* Keep unique combinations and preserve insertion order to guarantee
     reproducibility. We achieve this by an additional set (faster than doing
     a linear search in the vector each time). */
  if (m_combinations_unique.insert(newComb).second) { // true if element was inserted (not known yet)
    m_combinations.push_back(newComb);
  }
}

◆ append()

void Trig::FeatureContainer::append ( const FeatureContainer & other )

Definition at line 29 of file FeatureContainer.cxx.

{  
  for(const Trig::Combination& comb : other.m_combinations)
    addWithChecking(comb);
}

◆ containerFeature()

template<typename CONTAINER>

std::vector< Feature< CONTAINER > > Trig::FeatureContainer::containerFeature	(	const std::string &	label = "",
		unsigned int	condition = TrigDefs::Physics,
		const std::string &	teName = "" ) const

inline

Definition at line 79 of file FeatureContainer.h.

                                                                                                                                                              {
      auto features = typelessGet(ClassID_traits<CONTAINER>::ID(),label,condition,teName);
      return FeatureAccessImpl::typedGet<CONTAINER,CONTAINER,CONTAINER>(features,navigation(),m_cgm->store());
    }

◆ elementFeature()

template<typename CONTAINER>

std::vector< Feature< ELEMENT_OF< CONTAINER > > > Trig::FeatureContainer::elementFeature	(	const std::string &	label = "",
		unsigned int	condition = TrigDefs::Physics,
		const std::string &	teName = "" ) const

inline

Definition at line 73 of file FeatureContainer.h.

                                                                                                                                                                         {
      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());
    }

◆ flattenedContainerFeature()

template<typename CONTAINER>

std::vector< Feature< ELEMENT_OF< CONTAINER > > > Trig::FeatureContainer::flattenedContainerFeature	(	const std::string &	label = "",
		unsigned int	condition = TrigDefs::Physics,
		const std::string &	teName = "" ) const

inline

Definition at line 85 of file FeatureContainer.h.

                                                                                                                                                                                    {
      auto features = typelessGet(ClassID_traits<CONTAINER>::ID(),label,condition,teName);
      return FeatureAccessImpl::typedGet<ELEMENT_OF<CONTAINER>,CONTAINER,CONTAINER>(features,navigation(),m_cgm->store());
    }

◆ get()

template<class T>

const std::vector< Trig::Feature< T > > Trig::FeatureContainer::get	(	const std::string &	label = "",
		unsigned int	condition = TrigDefs::Physics,
		const std::string &	teName = "" ) const

returns flattened vector of Features of given type This method is in fact sullied by 3 arguments.

One of them is type, another is object label and another is eventually TE name.

Parameters

label	is label assigned to feature at HLT algorithm
teName	is name of TE to which the object has to be attached (default is 0 and would suffice for most of applications)

Definition at line 151 of file FeatureContainer.h.

{
  if ( condition != TrigDefs::Physics && condition != TrigDefs::alsoDeactivateTEs ) {
    throw std::runtime_error("Only two flags can be supplied to features");
  }
 
  //std::cout << " in FC::get, after call to getCombinations(), now looping over them" << std::endl;
 
  std::set<Trig::Feature<T>, Trig::FeatureContainer::ordering_by_objects_attached > uniqnessHelper;
 
  
  for(const Trig::Combination& comb : m_combinations ) {
    //std::cout << "   ---- combination has size " << comb.tes().size() << " tes[0] " << comb.tes()[0] << std::endl;
    //  for (std::vector<Trig::Combination>::const_iterator it = m_combinations.begin(); it != m_combinations.end(); ++it){
    if (condition == TrigDefs::Physics) {
      if (!comb.active()) continue;
    }
    std::vector<Trig::Feature<T> > features = comb.get<T>(label, condition, teName);
 
    //typedef std::vector< Trig::Feature<T> > FTV;
    //typename FTV::const_iterator fIt;
    //for (fIt = features.begin(); fIt != features.end(); ++fIt ) {
    for(const Trig::Feature<T>& f :  std::views::reverse(features)) {      
      //std::cout << "in FC::get, insertion of feature " << std::endl;
      uniqnessHelper.insert(f);
 
    }
  }
 
  //std::cout << " in FC::get, at the end: uniqnessHelper size = " << uniqnessHelper.size() << std::endl;
 
  return std::vector<Trig::Feature<T> >(uniqnessHelper.begin(), uniqnessHelper.end());
 
}

◆ getCombinations()

const std::vector< Trig::Combination > & Trig::FeatureContainer::getCombinations ( ) const

inline

gives back reference to combinations collected through append

Definition at line 111 of file FeatureContainer.h.

111{ return m_combinations; }

◆ getFlags()

template<class T>

TrigPassFlags Trig::FeatureContainer::getFlags	(	const Trig::Feature< T > &	f,
		const std::string &	flagsLabel = "" ) const

access to TrigPassFlags for given trigger object or container in given TE

Parameters

f	is the Feature that holds the trigger object (container)
flagsLabel	is the label of the TrigPassFlags object

Definition at line 196 of file FeatureContainer.h.

                                                                                           {
 
  TrigPassFlags pf;
 
  // get the trigPassFlag (only works if the flags are created in the same TE as the objects
  const TrigPassFlags* flags(0);
  const HLT::TriggerElement* sourceTE(0);
  std::string sourceLabel;
 
  auto fullnavi = dynamic_cast<const HLT::NavigationCore*>(navigation());
 
  bool success = fullnavi->getRecentFeature(f.te(), flags, flagsLabel, sourceTE, sourceLabel);
 
  if(!success || !flags) // navigation failed or did not return a flags
    return pf;
 
    
  return FeatureAccessImpl::getFlags(f, flags, fullnavi);
 
}

◆ getIParticle()

std::vector< Trig::Feature< xAOD::IParticle > > Trig::FeatureContainer::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

inline

Definition at line 62 of file FeatureContainer.h.

                                                                                                                                                                                                                            {
      auto features = typelessGet(clid,label,condition,teName);
      return FeatureAccessImpl::typedGet<xAOD::IParticle,xAOD::IParticleContainer,xAOD::IParticleContainer>(features,
                                                                                                           navigation(),
                                                                                                           m_cgm->store(),
                                                                                                           container_name); 
    }

◆ navigation()

const HLT::TrigNavStructure * Trig::FeatureContainer::navigation ( ) const

private

Definition at line 37 of file FeatureContainer.cxx.

                                       {
  return m_cgm->navigation();
}

◆ typelessGet()

const std::vector< Trig::TypelessFeature > Trig::FeatureContainer::typelessGet	(	HLT::class_id_type	clid,
		const std::string &	label = "",
		unsigned int	condition = TrigDefs::Physics,
		const std::string &	teName = "" ) const

typeless version of get

Parameters

clid	must be pointing directly to stored type (no flattening supported)

Definition at line 92 of file FeatureContainer.cxx.

                                                                                                                                                                           {
  if ( condition != TrigDefs::Physics && condition != TrigDefs::alsoDeactivateTEs ) {
    throw std::runtime_error("Only two flags can be supplied to features");
  }
 
  std::set<Trig::TypelessFeature,::order_by_clid_and_index> uniqnessHelper;
  for(auto& comb : m_combinations ) {
    if (condition == TrigDefs::Physics) {
      if (!comb.active()) continue;
    }
 
    std::vector<Trig::TypelessFeature> features = comb.typelessGet(clid, label, condition, teName);
    for(auto& f : features) {      
      uniqnessHelper.insert(f);
    }
  }
  return std::vector<Trig::TypelessFeature>(uniqnessHelper.begin(), uniqnessHelper.end());
}

Member Data Documentation

◆ m_cgm

const Trig::CacheGlobalMemory* Trig::FeatureContainer::m_cgm {nullptr}

private

Definition at line 128 of file FeatureContainer.h.

128{nullptr};

◆ m_combinations

std::vector<Trig::Combination> Trig::FeatureContainer::m_combinations

private

container preserving insertion order

Definition at line 124 of file FeatureContainer.h.

◆ m_combinations_unique

std::unordered_set<Trig::Combination> Trig::FeatureContainer::m_combinations_unique

private

set for ensuring uniqueness in the above container

Definition at line 126 of file FeatureContainer.h.

The documentation for this class was generated from the following files:

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ combination_const_iterator

◆ ELEMENT_OF

Constructor & Destructor Documentation

◆ FeatureContainer()

Member Function Documentation

◆ addWithChecking()

◆ append()

◆ containerFeature()

◆ elementFeature()

◆ flattenedContainerFeature()

◆ get()

◆ getCombinations()

◆ getFlags()

◆ getIParticle()

◆ navigation()

◆ typelessGet()

Member Data Documentation

◆ m_cgm

◆ m_combinations

◆ m_combinations_unique