HLT Namespace Reference

It used to be useful piece of code for replacing actual SG with other store of similar functionality In fact it used to be more like interface adapter for ARA objects access, nevertheless since the ARA project is gone it is only an unnecessary extra layer. More...

Namespaces
namespace	MET
namespace	StringSerializer
namespace	TrigNavTools
namespace	TypeInformation

Classes
struct	Action
struct	AuxInit
class	BaseHolder
class	Chain
	This class represents one chain of signatures, i.e. More...
class	CombinationGenerator
class	CombinationIterator
class	ComboIterator
	Iterator used to loop over multi-particle combinations. More...
class	ComboIteratorBase
	Base class for iterator used to loop over multi-particle combinations. More...
class	ComboIteratorTopo
struct	ConfigJetEThreshold
	modifed ConfigThreshold to incorporate the JetEnergy type More...
struct	ConfigThreshold
	Generic structure representing one LVL1 threshold which is used in all LVL1 RoIs. More...
class	EMTauRoI
	Concrete EMTau class (from templated HLRoI class). More...
class	ErrorCode
	The definition of error codes in HLT. More...
struct	FeatureContainerInit
class	FullHolderFactory
class	HLTExtraData
	Class representing the HLT extra payload stored in HLT::HLTResult::getExtras() More...
class	HLTResult
	HLT::HLTResult is sumarising result of trigger decision evaluation (online/offline) It contains basically 3 parts: More...
class	HLTResult_p1
class	HLTResultByteStreamCnv
	Gaudi bytestream Converter for the HLTResult class. More...
class	HLTResultByteStreamTool
class	HLTResultCnv_p1
class	HLTResultMT
	A container class for data required to build online output from HLT. More...
class	HLTResultMTByteStreamCnv
	ByteStream converter for HLTResultMT. More...
class	HLTRoI
	Generic (templated) class for the RoI classes, it contains a vector of the configured ConfigThresholds. More...
class	HLTSrcIdMap
	this class provides conversion between Lower level Source ID to higher level source ID for HLT ByteStream fragments. More...
class	Identifier
class	ILvl1ResultAccessTool
	this class provides the interface to the Lvl1 result access tool. More...
struct	ITrigHolderFactory
class	JetEnergyRoI
	Concrete JetEnergy class (from templated HLRoI class). More...
class	LoopThread
	Helper class to manage a long-running thread (duration of event loop) More...
class	Lvl1ResultAccessTool
	This tool is used to handle all LVL1 results in a coherent way, taking the LVL1 configuration into account to fill the raw bits with more meaningful data. More...
class	MuonRoI
	Concrete MuonRoI class (from templated HLRoI class). More...
class	Navigation
	The Navigation class, organizes TriggerElements into the tree structure. More...
class	NavigationCore
	The NavigationCore class, adds on top of the TrigNavStructure the EDM read-only handling. More...
class	NestedUniqueCombinationGenerator
	An ensemble of UniqueCombinationGenerator API description. More...
struct	Reason
struct	RegisterAuxType
struct	RegisterFeatureContainerTypes
class	RobRequestInfo
class	StandaloneNavigation
struct	SteeringInternalReason
class	TriggerElement
	TriggerElement is the basic ingreedient of the interface between HLT algorithms and the navigation It holds navigation links by itself but they are not exposed. More...
class	TriggerElementFactory
	The factory of TriggerElements Creation in controlled way. More...
class	TrigHolderStructure
class	TrigNavStructure
class	TypedHolder
	doubly templated class interfacing access to feature containers in StoreGate. More...
class	TypedHolder< TrigRoiDescriptor, TrigRoiDescriptorCollection >
class	TypelessHolder
class	TypeMaps
	Type registration of holder, proxies and name/CLID mappings. More...
class	UniqueCombinationGenerator
	Generator of unique combinations (no indices are repeated) API description. More...

Typedefs
typedef StoreGateSvc	AccessProxy
typedef uint32_t	teid_type
typedef uint16_t	sub_index_type
typedef uint32_t	index_type
typedef uint32_t	class_id_type
typedef std::vector< HLT::TriggerElement * >	TEVec
typedef uint32_t	te_id_type
typedef std::variant< sub_index_type, std::string >	index_or_label_type
typedef std::vector< size_t >	Index1DVec
	Unique combinations for case when one can not repeat the index (i.e.
typedef std::vector< Index1DVec >	Index2DVec
typedef std::vector< HLT::Identifier >	IDVec
typedef std::set< HLT::Identifier >	IDSet

Enumerations
enum	JetRoIType {   Unknown , JetRoI , ForwardJetRoI , JetEtRoI ,   TotalEtRoI , MissingEtRoI , METSignificanceRoI , MissingOrTotalEtRoI }
enum	ChainStatus { ChainInvalid =0 , ConfigOnlyChain , ChainOK }
enum	HLTLevel { L2 = 0 , EF , HLT , UNKNOWN }
enum class	OnlineErrorCode : uint32_t {   UNCLASSIFIED = 0 , BEFORE_NEXT_EVENT = 1 , CANNOT_RETRIEVE_EVENT = 2 , NO_EVENT_INFO = 3 ,   SCHEDULING_FAILURE = 4 , CANNOT_ACCESS_SLOT = 5 , PROCESSING_FAILURE = 6 , NO_HLT_RESULT = 7 ,   OUTPUT_BUILD_FAILURE = 8 , OUTPUT_SEND_FAILURE = 9 , AFTER_RESULT_SENT = 10 , COOL_UPDATE = 11 ,   TIMEOUT = 12 , RESULT_TRUNCATION = 13 , MISSING_CTP_FRAGMENT = 14 , BAD_CTP_FRAGMENT = 15 ,   SCHEDULER_POP_FAILURE = 16 }

Functions
MsgStream &	operator<< (MsgStream &m, const Navigation &nav)
MsgStream &	operator<< (MsgStream &m, const NavigationCore &nav)
MsgStream &	operator<< (MsgStream &, const Chain &)
	Overload of << operator for both, MsgStream and std::ostream.
std::ostream &	operator<< (std::ostream &, const Chain &)
	Overload of << operator for both, MsgStream and std::ostream.
std::string	strErrorCode (const ErrorCode code)
int	getErrorCodePosFromStr (const std::string &ec)
void	reportErrorCode (ErrorCode &e1, ErrorCode e2)
void	swap (HLTExtraData &, HLTExtraData &)
void	swap (HLTResult &lhs, HLTResult &rhs)
constexpr std::string_view	OnlineErrorCodeToString (const OnlineErrorCode code)
std::ostream &	operator<< (std::ostream &os, const HLT::OnlineErrorCode code)
constexpr bool	isEventProcessingErrorCode (const OnlineErrorCode code)
template<class CONTAINER>
TrigPassBits *	makeTrigPassBits (const CONTAINER *cont)
template<class T, class CONTAINER>
void	markPassing (TrigPassBits *bits, const T *obj, const CONTAINER *container)
	Set the bit for the object in the associated bits object.
template<class T, class CONTAINER>
bool	isPassing (const TrigPassBits *bits, const T *obj, const CONTAINER *container)
	Check the bit for the object in the associated bits object.
template<class CONTAINER>
TrigPassFlags *	makeTrigPassFlags (const CONTAINER *cont, const unsigned int flagSize)
template<class T, class CONTAINER>
void	setFlagBit (TrigPassFlags *flags, const T *obj, const CONTAINER *container, const unsigned int bitPosition, const bool bitValue=true)
	Set bit of the flag at index position for a given TrigPassFlags object.
template<class T, class CONTAINER>
void	setFlag (TrigPassFlags *flags, const T *obj, const CONTAINER *container, const std::vector< bool > &flag)
	Set the flag at index position.
template<class T, class CONTAINER>
bool	getFlagBit (const TrigPassFlags *flags, const T *obj, const CONTAINER *container, const unsigned int position, const unsigned int bitPosition)
	Returns the bit 'bitPosition' of the flag at index position.
template<class T, class CONTAINER>
const std::vector< bool > &	getFlag (const TrigPassFlags *flags, const T *obj, const CONTAINER *container, const size_t position)
	Returns the flag at index position.
template<typename T>
std::vector< bool >	AsFlag (T flag_t, const size_t size)
template<typename T>
T	FlagAs (const std::vector< bool > &flag)
void	elementsInUniqueCombinations (const Index2DVec &indices, std::set< size_t > &participants, const std::function< bool(const Index1DVec &)> &filter)
void	findUniqueCombinations (const Index2DVec &indices, std::vector< std::vector< size_t > > &combinations, const std::function< bool(const Index1DVec &)> &filter=[](const Index1DVec &){ return true;})
	Creates unique combinations of elements.

Variables
template<class FEATURE, class CONTAINER>
const FeatureContainerInit< FEATURE, CONTAINER >	RegisterFeatureContainerTypes< FEATURE, CONTAINER >::s
template<class TYPE>
const AuxInit< TYPE >	RegisterAuxType< TYPE >::s

Detailed Description

It used to be useful piece of code for replacing actual SG with other store of similar functionality In fact it used to be more like interface adapter for ARA objects access, nevertheless since the ARA project is gone it is only an unnecessary extra layer.

An trigger identifier class, used to provide mapping fromt the human readable IDs to efficienct unsigned ints.

Helper functions to be used by the Hypo algorithms.

Classes used to provide static Trigger EDM list.

The polimorphic dispatch only created unnecessary overhead.

This code is from Scott Snyder

Typedef Documentation

AccessProxy

typedef StoreGateSvc HLT::AccessProxy

Definition at line 17 of file AccessProxy.h.

class_id_type

typedef uint32_t HLT::class_id_type

Definition at line 11 of file Trigger/TrigEvent/TrigNavStructure/Root/Types.h.

IDSet

typedef std::set<HLT::Identifier> HLT::IDSet

Definition at line 56 of file TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h.

IDVec

typedef std::vector<HLT::Identifier> HLT::IDVec

Definition at line 55 of file TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h.

Index1DVec

typedef std::vector<size_t> HLT::Index1DVec

Unique combinations for case when one can not repeat the index (i.e.

for N same-object kind of triggers)

Function find all elements of the decisions which take part in succesfull unique combinations The combinations are formed from the content of each of the "indices" subvector. The index never repeats in the combination.

• decsions - stores indices of objects which succesfully pass selection
• participants - set of indices which contribute to any valid combination found (useful tor marking passing RoIs)
• filter - additional combinations filter (can be used to implement additional constraint on the objects) Another approach would be to make a generator object like above, we shall see which approach works better.

Definition at line 139 of file TrigCompositeUtils/TrigCompositeUtils/Combinators.h.

Index2DVec

typedef std::vector< Index1DVec > HLT::Index2DVec

Definition at line 140 of file TrigCompositeUtils/TrigCompositeUtils/Combinators.h.

index_or_label_type

typedef std::variant<sub_index_type,std::string> HLT::index_or_label_type

Definition at line 16 of file Trigger/TrigEvent/TrigNavStructure/TrigNavStructure/Types.h.

index_type

typedef uint32_t HLT::index_type

Definition at line 10 of file Trigger/TrigEvent/TrigNavStructure/Root/Types.h.

sub_index_type

typedef uint16_t HLT::sub_index_type

Definition at line 9 of file Trigger/TrigEvent/TrigNavStructure/Root/Types.h.

te_id_type

typedef uint32_t HLT::te_id_type

Definition at line 11 of file Trigger/TrigEvent/TrigNavStructure/TrigNavStructure/Types.h.

teid_type

typedef uint32_t HLT::teid_type

Definition at line 8 of file Trigger/TrigEvent/TrigNavStructure/Root/Types.h.

TEVec

typedef std::vector<HLT::TriggerElement*> HLT::TEVec

Definition at line 14 of file ComboIterator.h.

Enumeration Type Documentation

ChainStatus

enum HLT::ChainStatus

Enumerator
ChainInvalid
ConfigOnlyChain
ChainOK

Definition at line 51 of file Chain.h.

{ ChainInvalid=0, ConfigOnlyChain, ChainOK };

HLTLevel

enum HLT::HLTLevel

Enumerator
L2
EF
HLT
UNKNOWN

Definition at line 173 of file Trigger/TrigEvent/TrigSteeringEvent/TrigSteeringEvent/Enums.h.

{ L2 = 0, EF, HLT, UNKNOWN };

JetRoIType

enum HLT::JetRoIType

Enumerator
Unknown
JetRoI
ForwardJetRoI
JetEtRoI
TotalEtRoI
MissingEtRoI
METSignificanceRoI
MissingOrTotalEtRoI

Definition at line 28 of file Lvl1ItemsAndRoIs.h.

{ Unknown, JetRoI, ForwardJetRoI, JetEtRoI, TotalEtRoI, MissingEtRoI, METSignificanceRoI, MissingOrTotalEtRoI }; 

OnlineErrorCode

enum class HLT::OnlineErrorCode : uint32_t

strong

Enumerator
UNCLASSIFIED
BEFORE_NEXT_EVENT
CANNOT_RETRIEVE_EVENT
NO_EVENT_INFO
SCHEDULING_FAILURE
CANNOT_ACCESS_SLOT
PROCESSING_FAILURE
NO_HLT_RESULT
OUTPUT_BUILD_FAILURE
OUTPUT_SEND_FAILURE
AFTER_RESULT_SENT
COOL_UPDATE
TIMEOUT
RESULT_TRUNCATION
MISSING_CTP_FRAGMENT
BAD_CTP_FRAGMENT
SCHEDULER_POP_FAILURE

Definition at line 15 of file OnlineErrorCode.h.

                             : uint32_t {
    UNCLASSIFIED          = 0,
    BEFORE_NEXT_EVENT     = 1,
    CANNOT_RETRIEVE_EVENT = 2,
    NO_EVENT_INFO         = 3,
    SCHEDULING_FAILURE    = 4,
    CANNOT_ACCESS_SLOT    = 5,
    PROCESSING_FAILURE    = 6,
    NO_HLT_RESULT         = 7,
    OUTPUT_BUILD_FAILURE  = 8,
    OUTPUT_SEND_FAILURE   = 9,
    AFTER_RESULT_SENT     = 10,
    COOL_UPDATE           = 11,
    TIMEOUT               = 12,
    RESULT_TRUNCATION     = 13,
    MISSING_CTP_FRAGMENT  = 14,
    BAD_CTP_FRAGMENT      = 15,
    SCHEDULER_POP_FAILURE = 16,
  };

Function Documentation

AsFlag()

template<typename T>

std::vector< bool > HLT::AsFlag	(	T	flag_t,
		const size_t	size )

Definition at line 153 of file TrigPassFlags.h.

                                                       {  // T should be an unsigned type, otherwise this will give a compilation warning
      if(size>8*sizeof(T)) // check of T has at list 'size' bits
         throw std::runtime_error("AsFlag(): type T has less bits than required by 'size'");
      if(flag_t >= ( ((unsigned long long)1)<<size)  ) // check of T has at least 'size' bits (with 'size' bits '1<<size' is the lowest number I can not represent.)
         throw std::runtime_error("AsFlag(): the flag is larger then bits available");
 
 
      std::vector<bool> flag(size);
      int mask = 0x01;
      for(size_t idx=0; idx<size; ++idx, mask<<=1)
         flag[idx] = (flag_t&mask)!=0;
      return flag;
   }

elementsInUniqueCombinations()

void HLT::elementsInUniqueCombinations	(	const Index2DVec &	indices,
		std::set< size_t > &	participants,
		const std::function< bool(const Index1DVec &)> &	filter )

Definition at line 155 of file Combinators.cxx.

                                                                                                                                                    {
    const auto handle = [&](const Index1DVec& combination ) {  for ( auto el: combination ) participants.insert(participants.begin(), el); };
    combMaker( indices, handle, filter );
  }

findUniqueCombinations()

void HLT::findUniqueCombinations	(	const Index2DVec &	indices,
		std::vector< std::vector< size_t > > &	combinations,
		const std::function< bool(const Index1DVec &)> &	filter = [](const Index1DVec &){ return true;} )

Creates unique combinations of elements.

• combinations - all calid combinations For desciption

  See also

  elementsInUnuqueCombinations, this method is different as it exposes all combinations formed

Definition at line 160 of file Combinators.cxx.

                                                                                                                                                             {
    auto handle = [&](const Index1DVec& combination ) {  combinations.push_back( combination ); };
    combMaker( indices, handle, filter );
  }

FlagAs()

template<typename T>

T HLT::FlagAs

(

const std::vector< bool > &

flag

)

Definition at line 168 of file TrigPassFlags.h.

                                         {
      if(8*sizeof(T)<flag.size()) // check of T has enough bits to represent flag
         throw std::runtime_error("FlagAs(): the flag size does not fit into the requested type");
      T v = 0;
      int mask = 0x01;
      for(size_t idx=0; idx<flag.size(); ++idx, mask<<=1)
         if(flag[idx]) v += mask;
      return v;
   }

getErrorCodePosFromStr()

int HLT::getErrorCodePosFromStr

(

const std::string &

ec

)

Definition at line 105 of file Enums.cxx.

                                                   {
  std::istringstream ss(ec);
 
  std::string actionStr;
  std::string reasonStr;
  std::string steeringStr;
 
  // parse input
  ss >> actionStr  >> steeringStr >> reasonStr;
 
 
  Action::Code actionCode = getActionFromString(actionStr);
  
  if ( actionCode == Action::UNSPECIFIED_ ) 
    return -1;
  
  Reason::Code reasonCode = getReasonFromString(reasonStr);
  if ( reasonCode == Reason::UNSPECIFIED_ )
    return -1;
  
 
  SteeringInternalReason::Code steeringCode = getSteeringInternalReasonFromString(steeringStr);
  if ( steeringCode == SteeringInternalReason::UNSPECIFIED_ )
    return -1;
  
  return ErrorCode(actionCode, reasonCode, steeringCode );
}

getFlag()

template<class T, class CONTAINER>

const std::vector< bool > & HLT::getFlag	(	const TrigPassFlags *	flags,
		const T *	obj,
		const CONTAINER *	container,
		const size_t	position )

Returns the flag at index position.

Definition at line 145 of file TrigPassFlags.h.

                                                                                                                              {
      typename CONTAINER::const_iterator i = std::find(container->begin(), container->end(), obj);
      if ( i != container->end() )
         return flags->getFlag(i-container->begin(),position);
      throw std::runtime_error("The CONTAINER passed does not match the CONTAINER that created the TrigPassFlags");
   }

getFlagBit()

template<class T, class CONTAINER>

bool HLT::getFlagBit	(	const TrigPassFlags *	flags,
		const T *	obj,
		const CONTAINER *	container,
		const unsigned int	position,
		const unsigned int	bitPosition )

Returns the bit 'bitPosition' of the flag at index position.

Definition at line 134 of file TrigPassFlags.h.

                                                                                                                                                     {
      typename CONTAINER::const_iterator i = std::find(container->begin(), container->end(), obj);
      if ( i != container->end() )
         return flags->getFlagBit(i-container->begin(),position, bitPosition);
      throw std::runtime_error("The CONTAINER passed does not match the CONTAINER that created the TrigPassFlags");
   }

isEventProcessingErrorCode()

bool HLT::isEventProcessingErrorCode ( const OnlineErrorCode code )

constexpr

Returns

true if code corresponds to an issue with event data or in processing algorithms, false if code corresponds to a failure of an online framework component

Definition at line 70 of file OnlineErrorCode.h.

                                                                        {
    switch (code) {
      case OnlineErrorCode::PROCESSING_FAILURE:
      case OnlineErrorCode::TIMEOUT:
      case OnlineErrorCode::RESULT_TRUNCATION:
      case OnlineErrorCode::MISSING_CTP_FRAGMENT:
      case OnlineErrorCode::BAD_CTP_FRAGMENT:
        return true;
      default:
        return false;
    }
  }

isPassing()

template<class T, class CONTAINER>

bool HLT::isPassing	(	const TrigPassBits *	bits,
		const T *	obj,
		const CONTAINER *	container )

Check the bit for the object in the associated bits object.

Definition at line 82 of file Trigger/TrigEvent/TrigSteeringEvent/TrigSteeringEvent/TrigPassBits.h.

                                                                                       {      
    typename CONTAINER::const_iterator i = std::find(container->begin(), container->end(), obj);
    if ( i != container->end() ) 
      return bits->isPassing(i-container->begin());
    else
      throw std::runtime_error("When checking that object passed the trigger found object not from container");
    return false;
  }

makeTrigPassBits()

template<class CONTAINER>

TrigPassBits * HLT::makeTrigPassBits

(

const CONTAINER *

cont

)

Definition at line 57 of file Trigger/TrigEvent/TrigSteeringEvent/TrigSteeringEvent/TrigPassBits.h.

                                                        {
    return new TrigPassBits(cont->size(), (const void*)cont );
  }

makeTrigPassFlags()

template<class CONTAINER>

TrigPassFlags * HLT::makeTrigPassFlags	(	const CONTAINER *	cont,
		const unsigned int	flagSize )

Definition at line 96 of file TrigPassFlags.h.

                                                                                       {
      return new TrigPassFlags(cont->size(), flagSize, (const void*)cont );
   }

markPassing()

template<class T, class CONTAINER>

void HLT::markPassing	(	TrigPassBits *	bits,
		const T *	obj,
		const CONTAINER *	container )

Set the bit for the object in the associated bits object.

The helper function should be used in the HLT algorithms instead of the raw TrigPassBits accessors.

Definition at line 69 of file Trigger/TrigEvent/TrigSteeringEvent/TrigSteeringEvent/TrigPassBits.h.

                                                                                     {    
    typename CONTAINER::const_iterator i = std::find(container->begin(), container->end(), obj);
    if ( i != container->end() ) 
      bits->markPassing(i-container->begin(), container); 
    else
      throw std::runtime_error("When marking object as passing the trigger found object not from container");
  }

OnlineErrorCodeToString()

std::string_view HLT::OnlineErrorCodeToString ( const OnlineErrorCode code )

constexpr

Definition at line 39 of file OnlineErrorCode.h.

                                                                               {
    switch (code) {
      OnlineErrorCodeSwitchCase(UNCLASSIFIED);
      OnlineErrorCodeSwitchCase(BEFORE_NEXT_EVENT);
      OnlineErrorCodeSwitchCase(CANNOT_RETRIEVE_EVENT);
      OnlineErrorCodeSwitchCase(NO_EVENT_INFO);
      OnlineErrorCodeSwitchCase(SCHEDULING_FAILURE);
      OnlineErrorCodeSwitchCase(CANNOT_ACCESS_SLOT);
      OnlineErrorCodeSwitchCase(PROCESSING_FAILURE);
      OnlineErrorCodeSwitchCase(NO_HLT_RESULT);
      OnlineErrorCodeSwitchCase(OUTPUT_BUILD_FAILURE);
      OnlineErrorCodeSwitchCase(OUTPUT_SEND_FAILURE);
      OnlineErrorCodeSwitchCase(AFTER_RESULT_SENT);
      OnlineErrorCodeSwitchCase(COOL_UPDATE);
      OnlineErrorCodeSwitchCase(TIMEOUT);
      OnlineErrorCodeSwitchCase(RESULT_TRUNCATION);
      OnlineErrorCodeSwitchCase(MISSING_CTP_FRAGMENT);
      OnlineErrorCodeSwitchCase(BAD_CTP_FRAGMENT);
      OnlineErrorCodeSwitchCase(SCHEDULER_POP_FAILURE);
      default: return "UNDEFINED_OnlineErrorCode"; break;
    }
  }

operator<<() [1/5]

MsgStream & HLT::operator<<	(	MsgStream &	msg,
		const Chain &	c )

Overload of << operator for both, MsgStream and std::ostream.

Definition at line 144 of file Chain.cxx.

{
  c.print(msg);
  return msg;
}

operator<<() [2/5]

MsgStream & HLT::operator<<	(	MsgStream &	m,
		const Navigation &	nav )

Definition at line 168 of file Navigation.cxx.

                                                                 {
  m << (NavigationCore&)nav;
  return m;
}

operator<<() [3/5]

MsgStream & HLT::operator<<	(	MsgStream &	m,
		const NavigationCore &	nav )

Definition at line 52 of file NavigationCore.cxx.

                                                                     {
  std::string str;
  nav.printASCIIArt(str);
  
  m << str;
  return m;
}

operator<<() [4/5]

std::ostream & HLT::operator<<	(	std::ostream &	os,
		const Chain &	c )

Overload of << operator for both, MsgStream and std::ostream.

Definition at line 139 of file Chain.cxx.

{
  c.print(os);
  return os;
}

operator<<() [5/5]

std::ostream & HLT::operator<< ( std::ostream & os, const HLT::OnlineErrorCode code )

inline

Definition at line 62 of file OnlineErrorCode.h.

                                                                                {
    return os << HLT::OnlineErrorCodeToString(code);
  }

reportErrorCode()

void HLT::reportErrorCode	(	ErrorCode &	e1,
		ErrorCode	e2 )

setFlag()

template<class T, class CONTAINER>

void HLT::setFlag	(	TrigPassFlags *	flags,
		const T *	obj,
		const CONTAINER *	container,
		const std::vector< bool > &	flag )

Set the flag at index position.

Parameters

obj	trigger object to which the flag corresponds
container	container of trigger objects (same pointer as given in the constructor)
flag	value of the flag (use helper functions to convert from int or long to vector<bool>)

Definition at line 121 of file TrigPassFlags.h.

                                                                                                               {
      typename CONTAINER::const_iterator i = std::find(container->begin(), container->end(), obj);
      if ( i != container->end() ) 
         flags->setFlag(i-container->begin(), flag, container); 
      else
         throw std::runtime_error("The CONTAINER passed does not match the CONTAINER that created the TrigPassFlags");
   }

setFlagBit()

template<class T, class CONTAINER>

void HLT::setFlagBit	(	TrigPassFlags *	flags,
		const T *	obj,
		const CONTAINER *	container,
		const unsigned int	bitPosition,
		const bool	bitValue = true )

Set bit of the flag at index position for a given TrigPassFlags object.

Definition at line 105 of file TrigPassFlags.h.

                                                                                                                                                {
      typename CONTAINER::const_iterator i = std::find(container->begin(), container->end(), obj);
      if ( i != container->end() ) 
         flags->setFlagBit(i-container->begin(), bitPosition, bitValue, container); 
      else
         throw std::runtime_error("The CONTAINER passed does not match the CONTAINER that created the TrigPassFlags");
   }

strErrorCode()

std::string HLT::strErrorCode

(

const ErrorCode

code

)

Definition at line 99 of file Enums.cxx.

                                                {
  return ""+strAction(code.action())
    + " " + strSteeringInternalReason(code.steeringInternalReason())
    + " " + strReason(code.reason()) ;
}

swap() [1/2]

void HLT::swap	(	HLTExtraData &	lhs,
		HLTExtraData &	rhs )

Definition at line 76 of file HLTExtraData.cxx.

{
  using std::swap;
  
  swap(lhs.appName, rhs.appName);
  swap(lhs.statusCode, rhs.statusCode);
  swap(lhs.anonymous, rhs.anonymous);
  // default m_stringSerializer is good for every object
}

swap() [2/2]

void HLT::swap	(	HLTResult &	lhs,
		HLTResult &	rhs )

Definition at line 667 of file HLTResult.cxx.

{
  using std::swap;
  
  swap(lhs.m_headerResult, rhs.m_headerResult);
  swap(lhs.m_chainsResult, rhs.m_chainsResult);
  swap(lhs.m_navigationResult, rhs.m_navigationResult);
  swap(lhs.m_navigationResult_DSonly, rhs.m_navigationResult_DSonly);
  swap(lhs.m_extras, rhs.m_extras);
  swap(lhs.m_id_name, rhs.m_id_name);
  swap(lhs.m_id_name_DSonly, rhs.m_id_name_DSonly);
  swap(lhs.m_modID_id_name, rhs.m_modID_id_name);
  swap(lhs.m_navigationResultCuts, rhs.m_navigationResultCuts);
  swap(lhs.m_navigationResultCuts_DSonly, rhs.m_navigationResultCuts_DSonly);
}

Variable Documentation

RegisterAuxType< TYPE >::s

template<class TYPE>

const AuxInit<TYPE> HLT::RegisterAuxType< TYPE >::s

Definition at line 54 of file NavigationInit.h.

RegisterFeatureContainerTypes< FEATURE, CONTAINER >::s

template<class FEATURE, class CONTAINER>

const FeatureContainerInit<FEATURE, CONTAINER> HLT::RegisterFeatureContainerTypes< FEATURE, CONTAINER >::s

Definition at line 39 of file NavigationInit.h.