HLT::HLTResult Class Reference

HLT::HLTResult is sumarising result of trigger decision evaluation (online/offline) It contains basically 3 parts: More...

#include <HLTResult.h>

Inheritance diagram for HLT::HLTResult:

Collaboration diagram for HLT::HLTResult:

Public Member Functions
	HLTResult ()
	constructor
	HLTResult (const HLTResult &)
	copy constructor
	HLTResult (HLTResult &&rhs)
	move ctor
HLTResult &	operator= (HLTResult rhs)
	unified assignement operator
	~HLTResult ()
	destructor
virtual bool	accepted () const
	reject or accept
virtual bool	error () const
	problems during processing
virtual uint32_t	error_bits () const
	bit flags to explain problems during processing
bool	serialize (std::vector< uint32_t > &output, const unsigned int mod_id)
bool	serialize (std::vector< uint32_t > &output)
	get the result of the processing as the raw vector of 32 bit unsigned integers
bool	serialize (uint32_t *&output, int &data_size, const int max_size=-1, const unsigned int mod_id=0)
bool	deserialize (const std::vector< uint32_t > &source)
	GenericResult::deserialize( const std::vector<uint32_t>& source )
bool	deserialize (uint32_t *source, const int data_size)
	GenericResult::deserialize( uint32_t* source, const int data_size )
uint32_t	getHLTResultClassVersion () const
	HLTResult version (set accessor is private)
uint32_t	getLvl1Id () const
	gets event number (Lvl1-id)
void	setLvl1Id (uint32_t id)
	sets event number (Lvl1-id)
bool	isAccepted () const
	gets HLT decision
void	setAccepted (bool acc)
	sets HLT decision
bool	isPassThrough () const
	forced-accepted (FA) event configuration the FA request(s) are set per chain and hlt level by the tigger configuration; isForcedAccepted() is set to true if a chain has been accepted owing to the FA mechanism; this is independent of whether the event would been accepted anyway by this chain where the FA has been applied
void	setPassThrough (bool fa)
	set passTrough flag
ErrorCode	getHLTStatus () const
	overall hlt status: if StatusCode::isFailure(), event should be discarded from physics stream (and, eg, send to debug stream) (StatusCode enums are: Failure=0, Success=1, Recoverable=2, see GaudiKernel/ StatusCode.h for more information)
void	setHLTStatus (ErrorCode hltStatus)
ErrorCode	getLvlConverterStatus () const
	overall hlt status: if StatusCode::isFailure(), event should be discarded from physics stream (and, eg, send to debug stream) (StatusCode enums are: Failure=0, Success=1, Recoverable=2, see GaudiKernel/ StatusCode.h for more information)
void	setLvlConverterStatus (ErrorCode status)
HLTLevel	getHLTLevel () const
	hlt level (L2 or EF)
void	setHLTLevel (HLTLevel hltLevel)
bool	isValid () const
	is the result valid
uint32_t	getNumOfSatisfiedSigs () const
	get number of satisfied signatures
void	setNumOfSatisfiedSigs (uint32_t sigs)
	sget number of satisfied signatures
void	setErrorCoordinates (unsigned int chainCounter=0, unsigned int step=0)
	sets the information about the error, namely chain in which the error happened and the step
void	getErrorCoordinates (unsigned int &chainCounter, unsigned int &step) const
	get error coordinates
bool	isCreatedOutsideHLT () const
	is HLTResult created externally, in PSC in example
void	setCreatedOutsideHLT (bool created)
void	setConfigSuperMasterKey (uint32_t key)
	sets the key of the menu which was used to trigger this event
uint32_t	getConfigSuperMasterKey () const
	gets the key of the menu which was used to trigger this event
void	setConfigPrescalesKey (uint32_t key)
	sets the key of the prescales config which was used to trigger this event
uint32_t	getConfigPrescalesKey () const
	gets the key of the prescales config which was used to trigger this event
bool	isHLTResultTruncated () const
	is serialized HLTResult truncated
void	setHLTResultTruncated (bool truncated)
const std::vector< uint32_t > &	getNavigationResult () const
	retrieve the sub-payloads (can be used to retrieve/write data)
const std::vector< uint32_t > &	getNavigationResult_DSonly () const
const std::vector< uint32_t > &	getChainResult () const
const std::vector< uint32_t > &	getExtras () const
std::vector< unsigned int > &	getNavigationResultCuts ()
	gets ref to the internal array holding places for safe navigation truncations
const std::vector< unsigned int > &	getNavigationResultCuts () const
std::vector< unsigned int > &	getNavigationResultCuts_DSonly ()
	gets ref to the internal array holding places for safe navigation truncations
const std::vector< unsigned int > &	getNavigationResultCuts_DSonly () const
std::vector< std::pair< CLID, std::string > > &	getNavigationResultIDName ()
	gets ref to the internal vector of pairs of CLID and collection name
const std::vector< std::pair< CLID, std::string > > &	getNavigationResultIDName () const
std::vector< std::pair< CLID, std::string > > &	getNavigationResultIDName_DSonly ()
	gets ref to the internal vector of pairs of CLID and collection name
const std::vector< std::pair< CLID, std::string > > &	getNavigationResultIDName_DSonly () const
std::vector< uint32_t > &	getNavigationResult ()
	gets ref to the internal array holding serialized navigation
std::vector< uint32_t > &	getNavigationResult_DSonly ()
	gets ref to the internal array holding serialized navigation
std::vector< uint32_t > &	getChainResult ()
	gets ref to the internal array holding serialized chains
std::vector< uint32_t > &	getExtras ()
std::map< unsigned int, std::set< std::pair< CLID, std::string > > > &	getScoutingMap ()
	methods to get and set the Scouting Map saved into HLTResult
const std::map< unsigned int, std::set< std::pair< CLID, std::string > > > &	getScoutingMap () const
void	setScoutingMap (const std::map< unsigned int, std::set< std::pair< CLID, std::string > > > &map_modid_clid_name)
HLTExtraData &	getExtraData ()
unsigned int	size () const
std::vector< unsigned int >	partSizes () const
bool	isEmpty () const
	true if result is empty
void	listOfModIDs (std::vector< unsigned int > &mod_ids) const
	map of satisfied signatures (needed by TriggerDecisionMaker) returns a vector of satisfied signatures for this event; it is a vector of pairs where first is signature ID, second is signature label(name).
std::vector< unsigned int >	listOfModIDs () const
	return the rob module ID vector

Private Types
enum	InitBits {   IndHLTResultClassVersion = 0 , IndEventNumber , IndHLTDecision , IndPassThrough ,   IndHLTStatus , IndLvlConverterStatus , IndHLTLevelInfo , IndNumOfSatisfiedSigs ,   IndErrorInChain , IndErrorInStep , IndCreatedOutsideHLT , IndHLTResultTruncated ,   IndConfigSuperMasterKey , IndConfigPrescalesKey , IndNumOfFixedBit }
	fixed bits; general trigger and status information More...
using	CutPairs = std::vector<std::pair<unsigned int, unsigned int>>
using	CutPairVecs = std::pair<CutPairs, CutPairs>

Private Member Functions
bool	serialize_regular (uint32_t *&output, int &data_size, int max_size)
bool	serialize_DS (uint32_t *&output, int &data_size, int max_size, unsigned int mod_id)
bool	serialize_bootstrap (uint32_t *&output, int &data_size, bool &truncating, int max_size, unsigned int estimated_size)
bool	serialize_body_regular (uint32_t *output, int &data_size, unsigned int umax_size, bool truncating) const
bool	serialize_body_DS (uint32_t *output, int &data_size, unsigned int max_size, unsigned int nav_size, const CutPairVecs &dscuts, bool truncating) const
bool	serialize_navigation_reg (uint32_t *output, int &data_size, unsigned int umax_size, bool truncating) const
bool	serialize_navigation_DS (uint32_t *output, int &data_size, unsigned int umax_size, unsigned int nav_size, const CutPairVecs &dscuts, bool truncating) const
void	updateExtras ()
unsigned int	estimateSize () const
	Estimate the size this HLTResult would ocuppy once serialized.
CutPairVecs	findDSCuts (unsigned int) const
	Find the pairs of cut points that mark the boundaries of DS collections for the given module id.
bool	unpackFromStorable (const std::vector< uint32_t > &raw)
	split the rawResult vector into rawPartialResult's

Static Private Member Functions
static unsigned int	calc_total_size_DS (unsigned int ds_nav_size)
	Calculate the size of a DS result, given the size of its navigation.

Private Attributes
std::vector< uint32_t >	m_headerResult
	the full payload, and sub-payloads
std::vector< uint32_t >	m_chainsResult
	storege of serialized chains
std::vector< uint32_t >	m_navigationResult
	storage of navigation (serialized also)
std::vector< uint32_t >	m_navigationResult_DSonly
	storage of navigation (serialized also) for DataScouting
std::vector< uint32_t >	m_extras
	extra storeage (which can be used to store some operational infos)
std::vector< std::pair< CLID, std::string > >	m_id_name
std::vector< std::pair< CLID, std::string > >	m_id_name_DSonly
std::map< unsigned int, std::set< std::pair< CLID, std::string > > >	m_modID_id_name
std::vector< unsigned int >	m_navigationResultCuts
std::vector< unsigned int >	m_navigationResultCuts_DSonly
HLTExtraData *	m_extraData
	object for m_extras deserialization (on demand)

Static Private Attributes
static const uint32_t	m_HLTResultClassVersion = 3
	the version of this HLTResult class

Friends
class	HLTResultCnv_p1
void	swap (HLTResult &lhs, HLTResult &rhs)

Detailed Description

HLT::HLTResult is sumarising result of trigger decision evaluation (online/offline) It contains basically 3 parts:

1. header word which are holding very basic ingormation line if event was accepted or error occurred
2. serialized trigger chains info
3. serialized navigation structure (eventually together with objects)

Definition at line 51 of file HLTResult.h.

Member Typedef Documentation

CutPairs

using HLT::HLTResult::CutPairs = std::vector<std::pair<unsigned int, unsigned int>>

private

Definition at line 372 of file HLTResult.h.

CutPairVecs

using HLT::HLTResult::CutPairVecs = std::pair<CutPairs, CutPairs>

private

Definition at line 373 of file HLTResult.h.

Member Enumeration Documentation

InitBits

enum HLT::HLTResult::InitBits

private

fixed bits; general trigger and status information

Enumerator
IndHLTResultClassVersion
IndEventNumber	event number (from EventInfo::EventID::event_number())
IndHLTDecision	HLT decision (== 0 if event has been rejected at HLT)
IndPassThrough	has the event been forced (passed through)
IndHLTStatus	HLT status corresponding to ErrorCode enums.
IndLvlConverterStatus	LvlConverter status corresponding to ErrorCode enums.
IndHLTLevelInfo	the HLT level
IndNumOfSatisfiedSigs	number of satisfied signatures
IndErrorInChain	chain ID in which the error occured, in normal conditions sbould be 0
IndErrorInStep	step number in which error occured, in normal conditions sbould be 0
IndCreatedOutsideHLT	also an error identifier
IndHLTResultTruncated	the serialize function could not fit everything into the given max data_size
IndConfigSuperMasterKey	configuration key for the menu
IndConfigPrescalesKey	configuration key for prescales
IndNumOfFixedBit	total number of fixed bits

Definition at line 355 of file HLTResult.h.

                  { IndHLTResultClassVersion = 0,
            IndEventNumber,        
            IndHLTDecision,        
            IndPassThrough,        
            IndHLTStatus,          
            IndLvlConverterStatus, 
            IndHLTLevelInfo,       
            IndNumOfSatisfiedSigs, 
            IndErrorInChain,       
            IndErrorInStep,        
            IndCreatedOutsideHLT,  
            IndHLTResultTruncated, 
            IndConfigSuperMasterKey, 
            IndConfigPrescalesKey,   
            IndNumOfFixedBit       
    };

Constructor & Destructor Documentation

HLTResult() [1/3]

HLTResult::HLTResult

(

)

constructor

Definition at line 24 of file HLTResult.cxx.

                     :
      m_extraData{nullptr}
{
  m_headerResult.resize(IndNumOfFixedBit);
  m_headerResult[IndHLTResultClassVersion]    = m_HLTResultClassVersion;
  //std::cerr << "HLTResult instantiated with version " << m_HLTResultClassVersion << std::endl; 
  // set all fixed bits, if there will be an error then they will be OK ??? mean showing an error
  setLvl1Id(0xffffffff);
  setAccepted(false);
 
  setHLTStatus(HLT::FATAL);
 
  setLvlConverterStatus(HLT::FATAL);
 
  setPassThrough(false);
 
  setHLTLevel(HLT::UNKNOWN);
 
  setNumOfSatisfiedSigs(0);
 
  setErrorCoordinates(0, 0xffffffff); // quite unique way of saying that this was not used
 
  setCreatedOutsideHLT(true);
 
  setHLTResultTruncated(false);
}

HLTResult() [2/3]

HLTResult::HLTResult

(

const HLTResult &

rhs

)

copy constructor

Definition at line 52 of file HLTResult.cxx.

  : m_headerResult{rhs.m_headerResult},
    m_chainsResult{rhs.m_chainsResult},
    m_navigationResult{rhs.m_navigationResult},
    m_navigationResult_DSonly{rhs.m_navigationResult_DSonly},
    m_extras{rhs.m_extras},
    m_id_name{rhs.m_id_name},
    m_id_name_DSonly{rhs.m_id_name_DSonly},
    m_modID_id_name{rhs.m_modID_id_name},
    m_navigationResultCuts{rhs.m_navigationResultCuts},
    m_navigationResultCuts_DSonly{rhs.m_navigationResultCuts_DSonly},
    m_extraData{rhs.m_extraData ? new HLTExtraData{*rhs.m_extraData} : nullptr}
{
}

HLTResult() [3/3]

HLTResult::HLTResult

(

HLTResult &&

rhs

)

move ctor

Definition at line 68 of file HLTResult.cxx.

  : HLTResult{}
{
  swap(*this, rhs);
}

~HLTResult()

HLTResult::~HLTResult

(

)

destructor

Definition at line 82 of file HLTResult.cxx.

                      {
  delete m_extraData;
}

Member Function Documentation

accepted()

virtual bool HLT::HLTResult::accepted ( ) const

inlinevirtual

reject or accept

Returns

true if event is accepted

Implements GenericResult.

Definition at line 65 of file HLTResult.h.

{ return isAccepted(); }

calc_total_size_DS()

unsigned int HLTResult::calc_total_size_DS ( unsigned int ds_nav_size )

staticprivate

Calculate the size of a DS result, given the size of its navigation.

Definition at line 271 of file HLTResult.cxx.

{
  static constexpr auto num_size_words = 3u;
  return num_size_words + IndNumOfFixedBit + ds_nav_size;
}

deserialize() [1/2]

bool HLTResult::deserialize ( const std::vector< uint32_t > & source )

virtual

GenericResult::deserialize( const std::vector<uint32_t>& source )

Implements GenericResult.

Definition at line 482 of file HLTResult.cxx.

                                                               {
  return unpackFromStorable(source);
}

deserialize() [2/2]

bool HLTResult::deserialize ( uint32_t * source, const int data_size )

virtual

GenericResult::deserialize( uint32_t* source, const int data_size )

Implements GenericResult.

Definition at line 487 of file HLTResult.cxx.

                                                                    {
  if (data_size == 0 ) return false;
  std::vector<uint32_t> rawResult(&source[0], &source[data_size]);
  return unpackFromStorable(rawResult);
}

error()

bool HLTResult::error ( ) const

virtual

problems during processing

Returns

true if there was an error during event processing

Implements GenericResult.

Definition at line 102 of file HLTResult.cxx.

                            {
  return (getHLTStatus().action() >= HLT::Action::ABORT_CHAIN) ? true : false; 
}

error_bits()

uint32_t HLTResult::error_bits ( ) const

virtual

bit flags to explain problems during processing

Returns

some bits are set if there was na error

Implements GenericResult.

Definition at line 106 of file HLTResult.cxx.

                                     {
  uint32_t bits = 0;
  // result of erros in previous levels (not correct previous level result)
  if (getLvlConverterStatus().action() != HLT::Action::CONTINUE)  bits |= 0x1;
  if (getLvlConverterStatus().steeringInternalReason()  == HLT::SteeringInternalReason::NO_LVL1_ITEMS)     bits |= 0x2;
  if (getLvlConverterStatus().steeringInternalReason()  == HLT::SteeringInternalReason::NO_LVL2_CHAINS)    bits |= 0x4;
  if (getLvlConverterStatus().steeringInternalReason()  == HLT::SteeringInternalReason::WRONG_HLT_RESULT)  bits |= 0x8;
  if (getLvlConverterStatus().steeringInternalReason()  == HLT::SteeringInternalReason::NO_HLT_RESULT)     bits |= 0x10;
 
  // result of erros in this level
  if (getHLTStatus().action() == HLT::Action::ABORT_JOB)             bits |= 0x100;
  if (getHLTStatus().action() == HLT::Action::ABORT_EVENT)           bits |= 0x200;
  if (getHLTStatus().action() == HLT::Action::ABORT_CHAIN)           bits |= 0x400;
  if (getHLTStatus().reason() == HLT::Reason::TIMEOUT)               bits |= 0x800;
  if (getHLTStatus().reason() == HLT::Reason::NAV_ERROR)             bits |= 0x1000;
  return bits;
}

estimateSize()

unsigned int HLTResult::estimateSize ( ) const

private

Estimate the size this HLTResult would ocuppy once serialized.

Definition at line 124 of file HLTResult.cxx.

                                           {
  return IndNumOfFixedBit
      + m_chainsResult.size() + 1      // size(one word) and payload
      + m_navigationResult.size() + 1
      + m_extras.size() + 1;
}

findDSCuts()

auto HLTResult::findDSCuts ( unsigned int mod_id ) const

private

Find the pairs of cut points that mark the boundaries of DS collections for the given module id.

Returns

A pair whose first element has the boundaries of collections found in the DS result and whose second element has the boundaries of collections found only in the regular result

Definition at line 243 of file HLTResult.cxx.

{
 
  auto cuts_dsonly = CutPairs{{0, m_navigationResultCuts_DSonly.at(1)}}; /* the
                              first cut pair contains the preamle for DS
                              navigation: {version, NavSize, TEsSize, NumTEs} */
  auto cuts_reg = CutPairs{}; // starts empty
 
  auto modid_coll_it = m_modID_id_name.find(mod_id);
  if(modid_coll_it != std::end(m_modID_id_name))
  {
    const auto& collections = modid_coll_it->second;
    find_cuts(collections,
              m_id_name_DSonly,
              {},
              m_navigationResultCuts_DSonly,
              cuts_dsonly); // cuts for collections only in the DS result
    find_cuts(collections,
              m_id_name,
              m_id_name_DSonly,
              m_navigationResultCuts,
              cuts_reg); // cuts for collections in the normal result
  }
 
  return std::make_pair(cuts_dsonly, cuts_reg);
}

getChainResult() [1/2]

std::vector< uint32_t > & HLT::HLTResult::getChainResult ( )

inline

gets ref to the internal array holding serialized chains

Definition at line 291 of file HLTResult.h.

{ return m_chainsResult; }

getChainResult() [2/2]

const std::vector< uint32_t > & HLT::HLTResult::getChainResult ( ) const

inline

Definition at line 252 of file HLTResult.h.

{ return m_chainsResult; }

getConfigPrescalesKey()

uint32_t HLTResult::getConfigPrescalesKey

(

)

const

gets the key of the prescales config which was used to trigger this event

Warning

This info was introduced in version 2 of HLTresult for former data this method returns 0

Definition at line 650 of file HLTResult.cxx.

                                                {
  if ( m_headerResult[IndHLTResultClassVersion] >=2 )
    return m_headerResult[IndConfigPrescalesKey];
  else
    return 0;      
}

getConfigSuperMasterKey()

uint32_t HLTResult::getConfigSuperMasterKey

(

)

const

gets the key of the menu which was used to trigger this event

Warning

This info was introduced in version 2 of HLTresult for former data this method returns 0

Definition at line 638 of file HLTResult.cxx.

                                                  {
  if ( m_headerResult[IndHLTResultClassVersion] >=2 )
    return m_headerResult[IndConfigSuperMasterKey];
  else
    return 0;
}

getErrorCoordinates()

void HLT::HLTResult::getErrorCoordinates ( unsigned int & chainCounter, unsigned int & step ) const

inline

get error coordinates

See also

setErrorCoordinates( unsigned int chainCounter, unsigned int step )

Definition at line 204 of file HLTResult.h.

                                                                                                   {
      chainCounter = m_headerResult[IndErrorInChain]; step = m_headerResult[IndErrorInStep]; }

getExtraData()

HLTExtraData & HLTResult::getExtraData

(

)

Definition at line 658 of file HLTResult.cxx.

{
  // On-demand deserialization of m_extras
  if (m_extraData==0) {
    m_extraData = new HLTExtraData(m_extras);
  }  
  return *m_extraData;
}

getExtras() [1/2]

std::vector< uint32_t > & HLT::HLTResult::getExtras ( )

inline

Definition at line 298 of file HLTResult.h.

{ return m_extras; }

getExtras() [2/2]

const std::vector< uint32_t > & HLT::HLTResult::getExtras ( ) const

inline

Definition at line 253 of file HLTResult.h.

{ return m_extras; }

getHLTLevel()

HLTLevel HLT::HLTResult::getHLTLevel ( ) const

inline

hlt level (L2 or EF)

Definition at line 173 of file HLTResult.h.

{ return (HLTLevel)m_headerResult[IndHLTLevelInfo]; }

getHLTResultClassVersion()

uint32_t HLT::HLTResult::getHLTResultClassVersion ( ) const

inline

HLTResult version (set accessor is private)

Definition at line 116 of file HLTResult.h.

{ return m_HLTResultClassVersion; }

getHLTStatus()

ErrorCode HLT::HLTResult::getHLTStatus ( ) const

inline

overall hlt status: if StatusCode::isFailure(), event should be discarded from physics stream (and, eg, send to debug stream) (StatusCode enums are: Failure=0, Success=1, Recoverable=2, see GaudiKernel/ StatusCode.h for more information)

Definition at line 158 of file HLTResult.h.

{ return  ErrorCode(m_headerResult[IndHLTStatus]); }

getLvl1Id()

uint32_t HLT::HLTResult::getLvl1Id ( ) const

inline

gets event number (Lvl1-id)

Definition at line 121 of file HLTResult.h.

{ return m_headerResult[IndEventNumber]; }

getLvlConverterStatus()

ErrorCode HLT::HLTResult::getLvlConverterStatus ( ) const

inline

overall hlt status: if StatusCode::isFailure(), event should be discarded from physics stream (and, eg, send to debug stream) (StatusCode enums are: Failure=0, Success=1, Recoverable=2, see GaudiKernel/ StatusCode.h for more information)

Definition at line 167 of file HLTResult.h.

{ return ErrorCode(m_headerResult[IndLvlConverterStatus]); }

getNavigationResult() [1/2]

std::vector< uint32_t > & HLT::HLTResult::getNavigationResult ( )

inline

gets ref to the internal array holding serialized navigation

Definition at line 281 of file HLTResult.h.

{ return m_navigationResult; }

getNavigationResult() [2/2]

const std::vector< uint32_t > & HLT::HLTResult::getNavigationResult ( ) const

inline

retrieve the sub-payloads (can be used to retrieve/write data)

Definition at line 250 of file HLTResult.h.

{ return m_navigationResult; }

getNavigationResult_DSonly() [1/2]

std::vector< uint32_t > & HLT::HLTResult::getNavigationResult_DSonly ( )

inline

gets ref to the internal array holding serialized navigation

Definition at line 286 of file HLTResult.h.

{ return m_navigationResult_DSonly; }

getNavigationResult_DSonly() [2/2]

const std::vector< uint32_t > & HLT::HLTResult::getNavigationResult_DSonly ( ) const

inline

Definition at line 251 of file HLTResult.h.

{ return m_navigationResult_DSonly; }

getNavigationResultCuts() [1/2]

std::vector< unsigned int > & HLT::HLTResult::getNavigationResultCuts ( )

inline

gets ref to the internal array holding places for safe navigation truncations

Definition at line 258 of file HLTResult.h.

{ return m_navigationResultCuts; }

getNavigationResultCuts() [2/2]

const std::vector< unsigned int > & HLT::HLTResult::getNavigationResultCuts ( ) const

inline

Definition at line 259 of file HLTResult.h.

{ return m_navigationResultCuts; }

getNavigationResultCuts_DSonly() [1/2]

std::vector< unsigned int > & HLT::HLTResult::getNavigationResultCuts_DSonly ( )

inline

gets ref to the internal array holding places for safe navigation truncations

Definition at line 264 of file HLTResult.h.

{ return m_navigationResultCuts_DSonly; }

getNavigationResultCuts_DSonly() [2/2]

const std::vector< unsigned int > & HLT::HLTResult::getNavigationResultCuts_DSonly ( ) const

inline

Definition at line 265 of file HLTResult.h.

{ return m_navigationResultCuts_DSonly; }

getNavigationResultIDName() [1/2]

std::vector< std::pair< CLID, std::string > > & HLT::HLTResult::getNavigationResultIDName ( )

inline

gets ref to the internal vector of pairs of CLID and collection name

Definition at line 270 of file HLTResult.h.

{ return m_id_name; }

getNavigationResultIDName() [2/2]

const std::vector< std::pair< CLID, std::string > > & HLT::HLTResult::getNavigationResultIDName ( ) const

inline

Definition at line 271 of file HLTResult.h.

{ return m_id_name; }

getNavigationResultIDName_DSonly() [1/2]

std::vector< std::pair< CLID, std::string > > & HLT::HLTResult::getNavigationResultIDName_DSonly ( )

inline

gets ref to the internal vector of pairs of CLID and collection name

Definition at line 275 of file HLTResult.h.

{ return m_id_name_DSonly; }

getNavigationResultIDName_DSonly() [2/2]

const std::vector< std::pair< CLID, std::string > > & HLT::HLTResult::getNavigationResultIDName_DSonly ( ) const

inline

Definition at line 276 of file HLTResult.h.

{ return m_id_name_DSonly; }

getNumOfSatisfiedSigs()

uint32_t HLT::HLTResult::getNumOfSatisfiedSigs ( ) const

inline

get number of satisfied signatures

Definition at line 185 of file HLTResult.h.

{ return m_headerResult[IndNumOfSatisfiedSigs]; }

getScoutingMap() [1/2]

std::map< unsigned int, std::set< std::pair< CLID, std::string > > > & HLT::HLTResult::getScoutingMap ( )

inline

methods to get and set the Scouting Map saved into HLTResult

Definition at line 303 of file HLTResult.h.

{return  m_modID_id_name;}

getScoutingMap() [2/2]

const std::map< unsigned int, std::set< std::pair< CLID, std::string > > > & HLT::HLTResult::getScoutingMap ( ) const

inline

Definition at line 304 of file HLTResult.h.

{return  m_modID_id_name;}

isAccepted()

bool HLT::HLTResult::isAccepted ( ) const

inline

gets HLT decision

Definition at line 131 of file HLTResult.h.

{ return (m_headerResult[IndHLTDecision] == 1 ? true : false); }

isCreatedOutsideHLT()

bool HLT::HLTResult::isCreatedOutsideHLT ( ) const

inline

is HLTResult created externally, in PSC in example

Definition at line 211 of file HLTResult.h.

{ return (m_headerResult[IndCreatedOutsideHLT] == 0 ? false: true); } // previously "hasBeenCreated"

isEmpty()

bool HLTResult::isEmpty

(

)

const

true if result is empty

Definition at line 626 of file HLTResult.cxx.

{
  return (m_chainsResult.empty() && m_navigationResult.empty());
}

isHLTResultTruncated()

bool HLT::HLTResult::isHLTResultTruncated ( ) const

inline

is serialized HLTResult truncated

Definition at line 242 of file HLTResult.h.

{ return (m_headerResult[IndHLTResultTruncated] == 0 ? false : true); }

isPassThrough()

bool HLT::HLTResult::isPassThrough ( ) const

inline

forced-accepted (FA) event configuration the FA request(s) are set per chain and hlt level by the tigger configuration; isForcedAccepted() is set to true if a chain has been accepted owing to the FA mechanism; this is independent of whether the event would been accepted anyway by this chain where the FA has been applied

Definition at line 146 of file HLTResult.h.

{ return m_headerResult[IndPassThrough]; }

isValid()

bool HLT::HLTResult::isValid ( ) const

inline

is the result valid

Returns

true if result was ever stuffed, this is to mark results taht were never filled in steeing

Definition at line 180 of file HLTResult.h.

{ return (getHLTLevel() != HLT::UNKNOWN); }

listOfModIDs() [1/2]

std::vector< unsigned int > HLTResult::listOfModIDs

(

)

const

return the rob module ID vector

Definition at line 93 of file HLTResult.cxx.

                                                     {
 
  std::vector<unsigned int> mod_ids;
  for (std::map<unsigned int, std::set<std::pair<CLID, std::string> > >::const_iterator map_it = m_modID_id_name.begin(); 
      map_it != m_modID_id_name.end(); ++map_it)
    mod_ids.push_back((*map_it).first);
  return mod_ids;
}

listOfModIDs() [2/2]

void HLTResult::listOfModIDs

(

std::vector< unsigned int > &

mod_ids

)

const

map of satisfied signatures (needed by TriggerDecisionMaker) returns a vector of satisfied signatures for this event; it is a vector of pairs where first is signature ID, second is signature label(name).

return the rob module ID vector. (fills up rod_mod_ids vector given by reference)

Warning

note that vector is not cleared

Definition at line 86 of file HLTResult.cxx.

                                                                  {
 
  for (std::map<unsigned int, std::set<std::pair<CLID, std::string> > >::const_iterator map_it = m_modID_id_name.begin(); 
      map_it != m_modID_id_name.end(); ++map_it)
    mod_ids.push_back((*map_it).first);
}

operator=()

HLTResult & HLTResult::operator=

(

HLTResult

rhs

)

unified assignement operator

Definition at line 75 of file HLTResult.cxx.

{
  swap(*this, rhs);
  return *this;
}

partSizes()

std::vector< unsigned int > HLTResult::partSizes

(

)

const

Definition at line 616 of file HLTResult.cxx.

                                                   {
  std::vector<unsigned int> sizes;
  sizes.reserve(4);
  sizes.push_back(m_headerResult.size());
  sizes.push_back(m_chainsResult.size());
  sizes.push_back(m_navigationResult.size());
  sizes.push_back(m_extras.size());
  return sizes;
}

serialize() [1/3]

bool HLTResult::serialize ( std::vector< uint32_t > & output )

inlinevirtual

get the result of the processing as the raw vector of 32 bit unsigned integers

Parameters

output

the place where to put the data

Returns

status of the operation

Implements GenericResult.

Definition at line 442 of file HLTResult.cxx.

{
  return serialize(output, /*mod_id*/ 0);
}

serialize() [2/3]

bool HLTResult::serialize	(	std::vector< uint32_t > &	output,
		const unsigned int	mod_id )

Definition at line 447 of file HLTResult.cxx.

{
  uint32_t * aux = nullptr;
  int data_size = 0;
 
  auto ret = serialize(aux, data_size, /*max_size*/ -1, mod_id);
  auto uptr = std::unique_ptr<uint32_t[]>{aux}; // takes care of deletion
 
  output.reserve(data_size);
  std::copy(aux, aux + data_size, std::back_inserter(output));
 
  return ret;
}

serialize() [3/3]

bool HLTResult::serialize ( uint32_t *& output, int & data_size, const int max_size = -1, const unsigned int mod_id = 0 )

inlinevirtual

Implements GenericResult.

Definition at line 463 of file HLTResult.cxx.

{
  return mod_id ? serialize_DS(output, data_size, max_size, mod_id)
                : serialize_regular(output, data_size, max_size);
}

serialize_body_DS()

bool HLTResult::serialize_body_DS ( uint32_t * output, int & data_size, unsigned int max_size, unsigned int nav_size, const CutPairVecs & dscuts, bool truncating ) const

private

Definition at line 389 of file HLTResult.cxx.

{
  if(static_cast<unsigned int>(data_size) < umax_size)
  { // still at least space for chains size
    output[data_size++] = 0; // no chains
    if(serialize_navigation_DS(output, data_size, umax_size, nav_size, dscuts,
                               truncating)
       && static_cast<unsigned int>(data_size) < umax_size)
    { // we managed to serialize without truncating and have at least 1word left
      output[data_size++] = 0; // no extras
      return true; // no truncation
    }
  }
 
  return false;
}

serialize_body_regular()

bool HLTResult::serialize_body_regular ( uint32_t * output, int & data_size, unsigned int umax_size, bool truncating ) const

inlineprivate

Definition at line 377 of file HLTResult.cxx.

{
  return serialize_indivisible(output, data_size, m_chainsResult, umax_size,
                               truncating) &&
         serialize_navigation_reg(output, data_size, umax_size, truncating) &&
         serialize_indivisible(output, data_size, m_extras, umax_size,
                               truncating);
}

serialize_bootstrap()

bool HLTResult::serialize_bootstrap ( uint32_t *& output, int & data_size, bool & truncating, int max_size, unsigned int estimated_size )

private

Definition at line 356 of file HLTResult.cxx.

{
  assert(!data_size);
  assert(!output);
 
  auto umax_size = static_cast<unsigned int>(max_size);
  output = new uint32_t[std::min(umax_size, estimated_size)];
 
  truncating = max_size >= 0 && estimated_size > umax_size;
  setHLTResultTruncated(truncating);
 
  // serialize header
  return serialize_indivisible(output, data_size, m_headerResult, umax_size,
                               truncating, /*first*/true);
}

serialize_DS()

bool HLTResult::serialize_DS ( uint32_t *& output, int & data_size, int max_size, unsigned int mod_id )

private

Definition at line 424 of file HLTResult.cxx.

{
  assert(mod_id);
 
  bool truncating{false};
  auto dscuts = findDSCuts(mod_id);
  auto navsize = calc_colls_size(dscuts.first) + calc_colls_size(dscuts.second);
 
  return serialize_bootstrap(output, data_size, truncating, max_size,
                             calc_total_size_DS(navsize)) &&
         serialize_body_DS(output, data_size, max_size, navsize, dscuts,
                           truncating);
}

serialize_navigation_DS()

bool HLTResult::serialize_navigation_DS ( uint32_t * output, int & data_size, unsigned int umax_size, unsigned int nav_size, const CutPairVecs & dscuts, bool truncating ) const

private

Definition at line 321 of file HLTResult.cxx.

{
  if(nav_size + data_size < umax_size)
  { // we have space for the navigation + 1 size word
    output[data_size++] = nav_size;
    auto index_for_size_in_nav_preamble = data_size + 1;
 
    serialize_collections(output, data_size, m_navigationResult_DSonly,
                          dscuts.first);
    serialize_collections(output, data_size, m_navigationResult, dscuts.second);
 
    output[index_for_size_in_nav_preamble] = nav_size; /* the total size needs
      to be replaced in the navigation preamble as it was originally
      calculated with all data scouting collections lumped together in the
      navigation. This needs to be corrected once headers can be changed and
      serialization can be requested for each module ID separately.
      TODO: remove when changing headers */
  }
  else
  {
    assert(truncating);
 
    if(static_cast<unsigned int>(data_size) < umax_size)
      output[data_size++] = 0; /* we can still write the size; (partial
                                  navigation not supported in DS) */
  }
 
  return !truncating;
}

serialize_navigation_reg()

bool HLTResult::serialize_navigation_reg ( uint32_t * output, int & data_size, unsigned int umax_size, bool truncating ) const

private

Definition at line 277 of file HLTResult.cxx.

{
  auto calc_size_needed = [data_size](unsigned int nav_size)
                          { return nav_size + data_size + 1; }; /* given a
                                             navigation size, this gives the
                                             total space needed in the output */
  auto is_within_size = [umax_size, &calc_size_needed](unsigned int cut)
                        { return calc_size_needed(cut) <= umax_size; }; /* tells
                                             whether the given cut would make it
                                             within the allowed size */
 
  if(static_cast<unsigned int>(data_size) < umax_size)
  { // there is still some space (even if we end up truncating)
    const auto tot_nav_size = m_navigationResult.size(); // cache the total size
    auto cut_nav_size = tot_nav_size;                    // init cut size
    auto endnav = std::end(m_navigationResult);          // and cut point
 
    if(truncating && calc_size_needed(tot_nav_size) > umax_size)
    { // Truncation falls in navigation, so find the last cut that still fits
      auto cutit = std::find_if(m_navigationResultCuts.rbegin(),
                                m_navigationResultCuts.rend(),
                                is_within_size);
      cut_nav_size = (cutit == m_navigationResultCuts.rend()) ? 0 : *cutit;
      endnav -= tot_nav_size - cut_nav_size;
    }
 
    assert(endnav == std::begin(m_navigationResult) + cut_nav_size); /* endnav
                                 now marks the cutting point, while cut_nav_size
                                 says how many nav words we are copying */
 
    output[data_size++] = cut_nav_size;
    copy(std::begin(m_navigationResult), endnav, output+data_size);
    data_size += cut_nav_size;
 
    return endnav == std::end(m_navigationResult); /* whether we went with the
                                                      full navigation */
  }
 
  return false; // we did not even have space for the size
}

serialize_regular()

bool HLTResult::serialize_regular ( uint32_t *& output, int & data_size, int max_size )

private

Definition at line 411 of file HLTResult.cxx.

{
  updateExtras();
  bool truncating{false};
  auto estim_size = estimateSize();
  return serialize_bootstrap(output, data_size, truncating,
                             max_size, estim_size) &&
         serialize_body_regular(output, data_size,
                                max_size, truncating);
}

setAccepted()

void HLT::HLTResult::setAccepted ( bool acc )

inline

sets HLT decision

Definition at line 136 of file HLTResult.h.

{ acc ? (m_headerResult[IndHLTDecision] = 1) : (m_headerResult[IndHLTDecision] = 0); }

setConfigPrescalesKey()

void HLTResult::setConfigPrescalesKey

(

uint32_t

key

)

sets the key of the prescales config which was used to trigger this event

Definition at line 645 of file HLTResult.cxx.

                                                  {
  if (m_HLTResultClassVersion >=2 )
    m_headerResult[IndConfigPrescalesKey] = key;
}

setConfigSuperMasterKey()

void HLTResult::setConfigSuperMasterKey

(

uint32_t

key

)

sets the key of the menu which was used to trigger this event

Definition at line 632 of file HLTResult.cxx.

                                                    {
  if (m_HLTResultClassVersion >=2 )
    m_headerResult[IndConfigSuperMasterKey] = key;
}

setCreatedOutsideHLT()

void HLT::HLTResult::setCreatedOutsideHLT ( bool created )

inline

Definition at line 212 of file HLTResult.h.

{ created ? (m_headerResult[IndCreatedOutsideHLT] = 1) : (m_headerResult[IndCreatedOutsideHLT] = 0) ; }

setErrorCoordinates()

void HLT::HLTResult::setErrorCoordinates ( unsigned int chainCounter = 0, unsigned int step = 0 )

inline

sets the information about the error, namely chain in which the error happened and the step

Parameters

chainCounter	says in which chain it was (0 denotes that error wasn;t inchains processing)
step	is telling in which step in the chain the error occured

Definition at line 198 of file HLTResult.h.

                                                                                             {
      m_headerResult[IndErrorInChain] = chainCounter;  m_headerResult[IndErrorInStep] = step; };

setHLTLevel()

void HLT::HLTResult::setHLTLevel ( HLTLevel hltLevel )

inline

Definition at line 174 of file HLTResult.h.

{ m_headerResult[IndHLTLevelInfo] = hltLevel; }

setHLTResultTruncated()

void HLT::HLTResult::setHLTResultTruncated ( bool truncated )

inline

Definition at line 243 of file HLTResult.h.

                                                      {
      m_headerResult[IndHLTResultTruncated] = truncated ? 1 : 0;
    }

setHLTStatus()

void HLT::HLTResult::setHLTStatus ( ErrorCode hltStatus )

inline

Definition at line 159 of file HLTResult.h.

{ m_headerResult[IndHLTStatus] = hltStatus; }

setLvl1Id()

void HLT::HLTResult::setLvl1Id ( uint32_t id )

inline

sets event number (Lvl1-id)

Definition at line 126 of file HLTResult.h.

{ m_headerResult[IndEventNumber] = id; }

setLvlConverterStatus()

void HLT::HLTResult::setLvlConverterStatus ( ErrorCode status )

inline

Definition at line 168 of file HLTResult.h.

{ m_headerResult[IndLvlConverterStatus] = status; }

setNumOfSatisfiedSigs()

void HLT::HLTResult::setNumOfSatisfiedSigs ( uint32_t sigs )

inline

sget number of satisfied signatures

Definition at line 190 of file HLTResult.h.

{ m_headerResult[IndNumOfSatisfiedSigs] = sigs; }

setPassThrough()

void HLT::HLTResult::setPassThrough ( bool fa )

inline

set passTrough flag

See also

isPassThrough

Definition at line 150 of file HLTResult.h.

{ fa ? (m_headerResult[IndPassThrough] = 1) : (m_headerResult[IndPassThrough] = 0) ; }

setScoutingMap()

void HLT::HLTResult::setScoutingMap ( const std::map< unsigned int, std::set< std::pair< CLID, std::string > > > & map_modid_clid_name )

inline

Definition at line 306 of file HLTResult.h.

{m_modID_id_name = map_modid_clid_name;}  

size()

unsigned int HLTResult::size

(

)

const

Definition at line 612 of file HLTResult.cxx.

                                   {
  return m_headerResult.size() +  m_chainsResult.size() + m_navigationResult.size() + m_extras.size();
}

unpackFromStorable()

bool HLTResult::unpackFromStorable ( const std::vector< uint32_t > & raw )

private

split the rawResult vector into rawPartialResult's

Definition at line 493 of file HLTResult.cxx.

{
  if (raw.empty())
    return false;
 
  // default assumption: fixed bits of raw data are same as present class
  unsigned int rawIndNumOfFixedBit = HLTResult::IndNumOfFixedBit;
 
  unsigned version = raw[0];
 
  // different version handling
  if ( version != m_HLTResultClassVersion){
    if (version == 1) {
      // version 1 had only 12 InitBits
      rawIndNumOfFixedBit = 12;
    } else if (version == 2 ) {
      // nothing to be done
    } else { // case we don't know about
      std::cerr << "HLTResult::unpackFromStorable has noticed a class version mismatch and does not know how to translate: raw data version " << raw[0] << " current class version " << m_HLTResultClassVersion << std::endl; 
      return false;
    }
 
  }
  if ( raw.size() < HLTResult::IndNumOfFixedBit )
    return false;
  m_headerResult.assign(raw.begin(),
                        raw.begin()+rawIndNumOfFixedBit);
 
  // fill up with zeros so use of HLTResult::IndNumOfFixedBit of other indices past the end doesn't break
  m_headerResult.resize(HLTResult::IndNumOfFixedBit);
 
  if ( raw.size() ==  rawIndNumOfFixedBit )
    return true; // that's OK, we have just empty event, no processing started
 
  // chains
  uint32_t offset = rawIndNumOfFixedBit;
  uint32_t sizeOfChains = raw[offset];
  offset++;
 
  uint32_t readEnd = offset + sizeOfChains;
  bool truncation = false;
 
  if ( readEnd > raw.size() ){
    readEnd = raw.size();
    truncation = true;
  }
 
 
  m_chainsResult.assign(raw.begin()+offset, raw.begin()+readEnd);
  offset += sizeOfChains;
 
  if (truncation) {
    if ( isHLTResultTruncated() ) // if truncation was marked by creator it is OK
      return true;
    else // we need to report problems as there was extra truncation in the way which might have been done w/o any care about content
      return false;
  }
 
  // navigation
  uint32_t sizeOfNavigation = raw[offset];
  offset++;
  // check if offset is not beyond size of raw result  
 
 
  readEnd = offset + sizeOfNavigation;
  if (readEnd > raw.size()) {
    readEnd = raw.size();
    truncation = true;
  }
 
 
  if ( offset > readEnd ) 
    return true;
 
  m_navigationResult.assign(raw.begin()+offset,
                            raw.begin()+readEnd);
 
 
  if (truncation) {
    if ( isHLTResultTruncated() )
      return true;
    else
      return false;
  }
  offset += sizeOfNavigation;
 
  if (version >= 3) {
    // extras
    uint32_t sizeOfExtras = 0;
    if (offset < raw.size()) {
      sizeOfExtras = raw[offset++];
    }
    else {
      truncation = true;
    }
 
    readEnd = offset + sizeOfExtras;
    if (readEnd > raw.size()) {
      readEnd = raw.size();
      truncation = true;
    }
 
    if ( offset > readEnd )
      return true;
 
    m_extras.assign(raw.begin()+offset,
                    raw.begin()+readEnd);
    if (truncation) {
      if ( isHLTResultTruncated() )
        return true;
      else
        return false;
    } 
  }
 
  return true;
}

updateExtras()

void HLTResult::updateExtras ( )

inlineprivate

Definition at line 473 of file HLTResult.cxx.

{
  if (m_extraData)
  { // the extraData object has been used, so serialize again into m_extras
    m_extras.clear();
    m_extraData->serialize(m_extras);
  }
}

Friends And Related Symbol Documentation

HLTResultCnv_p1

friend class HLTResultCnv_p1

friend

Definition at line 350 of file HLTResult.h.

swap

void swap ( HLTResult & lhs, HLTResult & rhs )

friend

Member Data Documentation

m_chainsResult

std::vector<uint32_t> HLT::HLTResult::m_chainsResult

private

storege of serialized chains

Definition at line 477 of file HLTResult.h.

m_extraData

HLTExtraData* HLT::HLTResult::m_extraData

private

object for m_extras deserialization (on demand)

Definition at line 492 of file HLTResult.h.

m_extras

std::vector<uint32_t> HLT::HLTResult::m_extras

private

extra storeage (which can be used to store some operational infos)

Definition at line 480 of file HLTResult.h.

m_headerResult

std::vector<uint32_t> HLT::HLTResult::m_headerResult

private

the full payload, and sub-payloads

storage of header words

Definition at line 476 of file HLTResult.h.

m_HLTResultClassVersion

const uint32_t HLTResult::m_HLTResultClassVersion = 3

staticprivate

the version of this HLTResult class

version of HLTResult class: change this upon schema evolution

Definition at line 470 of file HLTResult.h.

m_id_name

std::vector< std::pair < CLID, std::string > > HLT::HLTResult::m_id_name

private

Definition at line 482 of file HLTResult.h.

m_id_name_DSonly

std::vector< std::pair < CLID, std::string > > HLT::HLTResult::m_id_name_DSonly

private

Definition at line 484 of file HLTResult.h.

m_modID_id_name

std::map<unsigned int, std::set<std::pair<CLID, std::string> > > HLT::HLTResult::m_modID_id_name

private

Definition at line 486 of file HLTResult.h.

m_navigationResult

std::vector<uint32_t> HLT::HLTResult::m_navigationResult

private

storage of navigation (serialized also)

Definition at line 478 of file HLTResult.h.

m_navigationResult_DSonly

std::vector<uint32_t> HLT::HLTResult::m_navigationResult_DSonly

private

storage of navigation (serialized also) for DataScouting

Definition at line 479 of file HLTResult.h.

m_navigationResultCuts

std::vector<unsigned int> HLT::HLTResult::m_navigationResultCuts

private

Definition at line 488 of file HLTResult.h.

m_navigationResultCuts_DSonly

std::vector<unsigned int> HLT::HLTResult::m_navigationResultCuts_DSonly

private

Definition at line 490 of file HLTResult.h.

---

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

• HLTResult.h
• HLTResult.cxx