This class provides a unique identification for each event, in terms of run/event number and/or a time stamp. More...

#include </builds/gaudi/Gaudi/GaudiKernel/include/GaudiKernel/EventIDBase.h>

Public Types
typedef unsigned int	number_type

typedef uint64_t	event_number_t

Static Public Attributes
static const number_type	UNDEFNUM = std::numeric_limits<EventIDBase::number_type>::max()

static const event_number_t	UNDEFEVT = std::numeric_limits<EventIDBase::event_number_t>::max()

Friends
class	EventIDRange

structors
enum	Type { Invalid = 0, RunEvent = 1 << 1, TimeStamp = 1 << 2, LumiEvent = 1 << 3, RunLumi = 1 << 4 }

bool	operator== (const EventIDBase &lhs, const EventIDBase &rhs)
	Comparison operators. More...

bool	operator< (const EventIDBase &lhs, const EventIDBase &rhs)

bool	operator> (const EventIDBase &lhs, const EventIDBase &rhs)

bool	operator!= (const EventIDBase &lhs, const EventIDBase &rhs)

bool	operator<= (const EventIDBase &lhs, const EventIDBase &rhs)

bool	operator>= (const EventIDBase &lhs, const EventIDBase &rhs)

EventIDBase	min (const EventIDBase &lhs, const EventIDBase &rhs)

EventIDBase	max (const EventIDBase &lhs, const EventIDBase &rhs)

std::ostream &	operator<< (std::ostream &os, const EventIDBase &rhs)
	Extraction operators. More...

EventIDBase	min (const EventIDBase &lhs, const EventIDBase &rhs)

EventIDBase	max (const EventIDBase &lhs, const EventIDBase &rhs)

bool	operator< (const EventIDBase &lhs, const EventIDBase &rhs)

bool	operator== (const EventIDBase &lhs, const EventIDBase &rhs)

std::ostream &	operator<< (std::ostream &os, const EventIDBase &rhs)

unsigned	m_type { Invalid }

number_type	m_run_number { UNDEFNUM }
	run number More...

event_number_t	m_event_number { UNDEFEVT }
	event number More...

number_type	m_time_stamp { UNDEFNUM }
	posix time in seconds since 1970/01/01 More...

number_type	m_time_stamp_ns_offset { UNDEFNUM }
	time stamp ns - ns time offset for time_stamp, 32 bit unsigned More...

number_type	m_lumi_block { UNDEFNUM }
	luminosity block number: the number which uniquely tags a luminosity block within a run More...

number_type	m_bunch_crossing_id { UNDEFNUM }
	bunch crossing ID, 32 bit unsigned More...

	EventIDBase ()

	EventIDBase (number_type run_number, event_number_t event_number, number_type time_stamp=UNDEFNUM, number_type time_stamp_ns_offset=0, number_type lumi_block=UNDEFNUM, number_type bunch_crossing_id=0)

	EventIDBase (std::tuple< number_type, number_type, event_number_t > run_lumi_ev, std::tuple< number_type, number_type > time_stamp, number_type bunch_crossing_id)

virtual	~EventIDBase ()=default

number_type	run_number () const
	run number - 32 bit unsigned More...

event_number_t	event_number () const
	event number - 64 bit unsigned More...

number_type	time_stamp () const
	time stamp - posix time in seconds from 1970, 32 bit unsigned More...

number_type	time_stamp_ns_offset () const
	time stamp ns - ns time offset for time_stamp, 32 bit unsigned More...

number_type	lumi_block () const
	luminosity block identifier, 32 bit unsigned More...

number_type	bunch_crossing_id () const
	bunch crossing ID, 32 bit unsigned More...

void	set_run_number (number_type runNumber)
	set run number More...

void	set_event_number (event_number_t eventNumber)
	set event number More...

void	set_time_stamp (number_type timeStamp)
	set time stamp More...

void	set_time_stamp_ns_offset (number_type timeStampNs)
	set time stamp in ns More...

void	set_lumi_block (number_type lumiBlock)
	set luminosity block identifier More...

void	set_bunch_crossing_id (number_type bcid)
	set bunch crossing ID More...

bool	isRunEvent () const

bool	isTimeStamp () const

bool	isLumiEvent () const

bool	isRunLumi () const

bool	isValid () const

static auto	SortByTimeStamp ()

static auto	SortByRunEvent ()

static auto	SortByLumiEvent ()

static auto	SortByRunLumi ()

void	setRE ()

void	setTS ()

void	setLE ()

void	setRL ()

Detailed Description

This class provides a unique identification for each event, in terms of run/event number and/or a time stamp.

Definition at line 65 of file EventIDBase.h.

Member Typedef Documentation

◆ event_number_t

typedef uint64_t EventIDBase::event_number_t

Definition at line 68 of file EventIDBase.h.

◆ number_type

typedef unsigned int EventIDBase::number_type

Definition at line 67 of file EventIDBase.h.

Member Enumeration Documentation

◆ Type

enum EventIDBase::Type

private

Enumerator
Invalid
RunEvent
TimeStamp
LumiEvent
RunLumi

Definition at line 182 of file EventIDBase.h.

182 { Invalid = 0, RunEvent = 1 << 1, TimeStamp = 1 << 2, LumiEvent = 1 << 3, RunLumi = 1 << 4 };

Constructor & Destructor Documentation

◆ EventIDBase() [1/3]

EventIDBase::EventIDBase ( )

inline

Definition at line 78 of file EventIDBase.h.

78 {}

◆ EventIDBase() [2/3]

EventIDBase::EventIDBase	(	number_type	run_number,
		event_number_t	event_number,
		number_type	time_stamp = `UNDEFNUM`,
		number_type	time_stamp_ns_offset = `0`,
		number_type	lumi_block = `UNDEFNUM`,
		number_type	bunch_crossing_id = `0`
	)

Definition at line 27 of file EventIDBase.cpp.

     : m_run_number( run_number )
     , m_event_number( event_number )
     , m_time_stamp( time_stamp )
     , m_time_stamp_ns_offset( time_stamp_ns_offset )
     , m_lumi_block( lumi_block )
     , m_bunch_crossing_id( bunch_crossing_id ) {
   if ( m_run_number != UNDEFNUM && m_event_number != UNDEFEVT ) setRE();
  
   if ( m_time_stamp != UNDEFNUM ) {
     setTS();
     if ( m_time_stamp_ns_offset == UNDEFNUM ) m_time_stamp_ns_offset = 0;
   }
  
   if ( m_lumi_block != UNDEFNUM && m_event_number != UNDEFEVT ) setLE();
  
   if ( m_run_number != UNDEFNUM && m_lumi_block != UNDEFNUM ) setRL();
 }

◆ EventIDBase() [3/3]

EventIDBase::EventIDBase	(	std::tuple< number_type, number_type, event_number_t >	run_lumi_ev,
		std::tuple< number_type, number_type >	time_stamp,
		number_type	bunch_crossing_id
	)

Definition at line 47 of file EventIDBase.cpp.

     : EventIDBase( std::get<0>( run_lumi_ev ), // run number
                    std::get<2>( run_lumi_ev ), // event number
                    std::get<0>( time_stamp ),  // timestamp in seconds
                    std::get<1>( time_stamp ),  // nanoseconds offst
                    std::get<1>( run_lumi_ev ), // lumi block
                    bunch_crossing_id ) {}

◆ ~EventIDBase()

virtual EventIDBase::~EventIDBase ( )

virtualdefault

Member Function Documentation

◆ bunch_crossing_id()

number_type EventIDBase::bunch_crossing_id ( ) const

inline

bunch crossing ID, 32 bit unsigned

Definition at line 106 of file EventIDBase.h.

106 { return m_bunch_crossing_id; }

◆ event_number()

event_number_t EventIDBase::event_number ( ) const

inline

event number - 64 bit unsigned

Definition at line 94 of file EventIDBase.h.

94 { return m_event_number; }

◆ isLumiEvent()

bool EventIDBase::isLumiEvent ( ) const

inline

Definition at line 154 of file EventIDBase.h.

154 { return m_type & LumiEvent; }

◆ isRunEvent()

bool EventIDBase::isRunEvent ( ) const

inline

Definition at line 152 of file EventIDBase.h.

152 { return m_type & RunEvent; }

◆ isRunLumi()

bool EventIDBase::isRunLumi ( ) const

inline

Definition at line 155 of file EventIDBase.h.

155 { return m_type & RunLumi; }

◆ isTimeStamp()

bool EventIDBase::isTimeStamp ( ) const

inline

Definition at line 153 of file EventIDBase.h.

153 { return m_type & TimeStamp; }

◆ isValid()

bool EventIDBase::isValid ( ) const

inline

Definition at line 156 of file EventIDBase.h.

156 { return m_type != Invalid; }

◆ lumi_block()

number_type EventIDBase::lumi_block ( ) const

inline

luminosity block identifier, 32 bit unsigned

Definition at line 103 of file EventIDBase.h.

103 { return m_lumi_block; }

◆ run_number()

number_type EventIDBase::run_number ( ) const

inline

run number - 32 bit unsigned

Definition at line 91 of file EventIDBase.h.

91 { return m_run_number; }

◆ set_bunch_crossing_id()

void EventIDBase::set_bunch_crossing_id ( number_type bcid )

inline

set bunch crossing ID

Definition at line 139 of file EventIDBase.h.

139 { m_bunch_crossing_id = bcid; }

◆ set_event_number()

void EventIDBase::set_event_number ( event_number_t eventNumber )

inline

set event number

Definition at line 116 of file EventIDBase.h.

                                                       {
     m_event_number = eventNumber;
     if ( m_run_number != UNDEFNUM ) setRE();
     if ( m_lumi_block != UNDEFNUM ) setLE();
   }

◆ set_lumi_block()

void EventIDBase::set_lumi_block ( number_type lumiBlock )

inline

set luminosity block identifier

Definition at line 132 of file EventIDBase.h.

                                                {
     m_lumi_block = lumiBlock;
     if ( m_run_number != UNDEFNUM ) setRL();
     if ( m_event_number != UNDEFEVT ) setLE();
   }

◆ set_run_number()

void EventIDBase::set_run_number ( number_type runNumber )

inline

set run number

Definition at line 109 of file EventIDBase.h.

                                                {
     m_run_number = runNumber;
     if ( m_event_number != UNDEFEVT ) setRE();
     if ( m_lumi_block != UNDEFNUM ) setRL();
   }

◆ set_time_stamp()

void EventIDBase::set_time_stamp ( number_type timeStamp )

inline

set time stamp

Definition at line 123 of file EventIDBase.h.

                                                {
     m_time_stamp = timeStamp;
     setTS();
   }

◆ set_time_stamp_ns_offset()

void EventIDBase::set_time_stamp_ns_offset ( number_type timeStampNs )

inline

set time stamp in ns

Definition at line 129 of file EventIDBase.h.

129 { m_time_stamp_ns_offset = timeStampNs; }

◆ setLE()

void EventIDBase::setLE ( )

inlineprivate

Definition at line 188 of file EventIDBase.h.

188 { m_type |= LumiEvent; }

◆ setRE()

void EventIDBase::setRE ( )

inlineprivate

Definition at line 186 of file EventIDBase.h.

186 { m_type |= RunEvent; }

◆ setRL()

void EventIDBase::setRL ( )

inlineprivate

Definition at line 189 of file EventIDBase.h.

189 { m_type |= RunLumi; }

◆ setTS()

void EventIDBase::setTS ( )

inlineprivate

Definition at line 187 of file EventIDBase.h.

187 { m_type |= TimeStamp; }

◆ SortByLumiEvent()

static auto EventIDBase::SortByLumiEvent ( )

inlinestatic

Definition at line 171 of file EventIDBase.h.

                                 {
     return ::details::add_deref(
         ::details::make_cmp( []( const EventIDBase& e ) { return std::tie( e.m_lumi_block, e.m_event_number ); } ) );
   }

◆ SortByRunEvent()

static auto EventIDBase::SortByRunEvent ( )

inlinestatic

Definition at line 166 of file EventIDBase.h.

                                {
     return ::details::add_deref(
         ::details::make_cmp( []( const EventIDBase& e ) { return std::tie( e.m_run_number, e.m_event_number ); } ) );
   }

◆ SortByRunLumi()

static auto EventIDBase::SortByRunLumi ( )

inlinestatic

Definition at line 176 of file EventIDBase.h.

                               {
     return ::details::add_deref(
         ::details::make_cmp( []( const EventIDBase& e ) { return std::tie( e.m_run_number, e.m_lumi_block ); } ) );
   }

◆ SortByTimeStamp()

static auto EventIDBase::SortByTimeStamp ( )

inlinestatic

Definition at line 161 of file EventIDBase.h.

                                 {
     return ::details::add_deref( ::details::make_cmp(
         []( const EventIDBase& e ) { return std::tie( e.m_time_stamp, e.m_time_stamp_ns_offset ); } ) );
   }

◆ time_stamp()

number_type EventIDBase::time_stamp ( ) const

inline

time stamp - posix time in seconds from 1970, 32 bit unsigned

Definition at line 97 of file EventIDBase.h.

97 { return m_time_stamp; }

◆ time_stamp_ns_offset()

number_type EventIDBase::time_stamp_ns_offset ( ) const

inline

time stamp ns - ns time offset for time_stamp, 32 bit unsigned

Definition at line 100 of file EventIDBase.h.

100 { return m_time_stamp_ns_offset; }

Friends And Related Function Documentation

◆ EventIDRange

friend class EventIDRange

friend

Definition at line 73 of file EventIDBase.h.

◆ max [1/2]

EventIDBase max	(	const EventIDBase &	lhs,
		const EventIDBase &	rhs
	)

friend

◆ max [2/2]

EventIDBase max	(	const EventIDBase &	lhs,
		const EventIDBase &	rhs
	)

friend

Definition at line 223 of file EventIDBase.h.

                                                                            {
  
     //"max" is much trickier because we need to handle invalid number explicilty by
     // checking if a EventIDBase is TS or Run/Lumi
  
     std::tuple<EventIDBase::number_type, EventIDBase::number_type, EventIDBase::event_number_t> run_lumi_ev;
     std::tuple<EventIDBase::number_type, EventIDBase::number_type>                              time_stamp;
  
     if ( lhs.isTimeStamp() && rhs.isTimeStamp() ) { // both time-stamp, compare them
       time_stamp = std::max( std::tie( lhs.m_time_stamp, lhs.m_time_stamp_ns_offset ),
                              std::tie( rhs.m_time_stamp, rhs.m_time_stamp_ns_offset ) );
     } else if ( lhs.isTimeStamp() ) { // only lhs time-stamp: Use it
       time_stamp = std::tie( lhs.m_time_stamp, lhs.m_time_stamp_ns_offset );
     } else { // otherwise use rhs time-stamp which might be UNDEFNUM (in case both input values are Run-Lumi only)
       time_stamp = std::tie( rhs.m_time_stamp, rhs.m_time_stamp_ns_offset );
     }
  
     if ( lhs.isRunLumi() && rhs.isRunLumi() ) { // both run-lumi, compare them
       run_lumi_ev = std::max( std::tie( lhs.m_run_number, lhs.m_lumi_block, lhs.m_event_number ),
                               std::tie( rhs.m_run_number, rhs.m_lumi_block, rhs.m_event_number ) );
  
     } else if ( lhs.isRunLumi() ) { // only lhs run-lumi: Use it
       run_lumi_ev = std::tie( lhs.m_run_number, lhs.m_lumi_block, lhs.m_event_number );
     } else { // otherwise use rhs run-lumi which might be UNDEFNUM (in case both input values are TS-only)
       run_lumi_ev = std::tie( rhs.m_run_number, rhs.m_lumi_block, rhs.m_event_number );
     }
  
     return EventIDBase( run_lumi_ev, time_stamp, lhs.bunch_crossing_id() );
   }

◆ min [1/2]

EventIDBase min	(	const EventIDBase &	lhs,
		const EventIDBase &	rhs
	)

friend

◆ min [2/2]

EventIDBase min	(	const EventIDBase &	lhs,
		const EventIDBase &	rhs
	)

friend

Definition at line 210 of file EventIDBase.h.

                                                                            {
  
     //"min" is easy b/c the numbers denoting invalidty for TS or Run/Event/LB are the
     // largest possible numbers, so naturally larger than any valid number
  
     return EventIDBase( std::min( std::tie( lhs.m_run_number, lhs.m_lumi_block, lhs.m_event_number ),
                                   std::tie( rhs.m_run_number, rhs.m_lumi_block, rhs.m_event_number ) ),
                         std::min( std::tie( lhs.m_time_stamp, lhs.m_time_stamp_ns_offset ),
                                   std::tie( rhs.m_time_stamp, rhs.m_time_stamp_ns_offset ) ),
                         lhs.bunch_crossing_id() // bcid doesn't really matter here
     );
   }

◆ operator!=

bool operator!=	(	const EventIDBase &	lhs,
		const EventIDBase &	rhs
	)

friend

Definition at line 145 of file EventIDBase.h.

145 { return !( lhs == rhs ); }

◆ operator< [1/2]

bool operator<	(	const EventIDBase &	lhs,
		const EventIDBase &	rhs
	)

friend

◆ operator< [2/2]

bool operator<	(	const EventIDBase &	lhs,
		const EventIDBase &	rhs
	)

friend

Definition at line 253 of file EventIDBase.h.

                                                                           {
     // first try ordering by timestamp if both are non-zero
     // then try ordering by run/lumi/event
     // this assumes that both EventIDBase have the same set of values defined.
  
     if ( lhs.isTimeStamp() && rhs.isTimeStamp() ) {
       return lhs.m_time_stamp < rhs.m_time_stamp;
     } else {
       return std::tie( lhs.m_run_number, lhs.m_lumi_block, lhs.m_event_number ) <
              std::tie( rhs.m_run_number, rhs.m_lumi_block, rhs.m_event_number );
     }
   }

◆ operator<< [1/2]

std::ostream& operator<<	(	std::ostream &	os,
		const EventIDBase &	rhs
	)

friend

Extraction operators.

◆ operator<< [2/2]

std::ostream& operator<<	(	std::ostream &	os,
		const EventIDBase &	rhs
	)

friend

Definition at line 272 of file EventIDBase.h.

                                                                           {
     if ( rhs.m_type == EventIDBase::Invalid ) return os << "[INVALID]";
  
     const char* separator = "";
     os << "[";
     if ( rhs.m_run_number != EventIDBase::UNDEFNUM ) {
       os << rhs.m_run_number;
       separator = ",";
     }
  
     if ( rhs.m_event_number != EventIDBase::UNDEFEVT ) {
       os << separator << rhs.m_event_number;
       separator = ",";
     }
  
     if ( rhs.isTimeStamp() ) {
       os << separator << "t:" << rhs.m_time_stamp;
       if ( rhs.m_time_stamp_ns_offset != 0 ) {
         os << "." << std::setfill( '0' ) << std::setw( 9 ) << rhs.m_time_stamp_ns_offset;
       }
       separator = ",";
     }
  
     if ( rhs.isLumiEvent() || rhs.isRunLumi() ) {
       os << separator << "l:" << rhs.m_lumi_block;
       separator = ",";
     }
  
     if ( rhs.m_bunch_crossing_id != 0 ) { os << separator << "b:" << rhs.m_bunch_crossing_id; }
     os << "]";
     return os;
   }

◆ operator<=

bool operator<=	(	const EventIDBase &	lhs,
		const EventIDBase &	rhs
	)

friend

Definition at line 146 of file EventIDBase.h.

146 { return !( lhs > rhs ); }

◆ operator== [1/2]

bool operator==	(	const EventIDBase &	lhs,
		const EventIDBase &	rhs
	)

friend

Comparison operators.

◆ operator== [2/2]

bool operator==	(	const EventIDBase &	lhs,
		const EventIDBase &	rhs
	)

friend

Definition at line 266 of file EventIDBase.h.

                                                                            {
     // We assume that equality via run/event/lumi numbers is sufficient
     return ( lhs.m_run_number == rhs.m_run_number && lhs.m_event_number == rhs.m_event_number &&
              lhs.m_lumi_block == rhs.m_lumi_block );
   }

◆ operator>

bool operator>	(	const EventIDBase &	lhs,
		const EventIDBase &	rhs
	)

friend

Definition at line 144 of file EventIDBase.h.

144 { return rhs < lhs; }

◆ operator>=

bool operator>=	(	const EventIDBase &	lhs,
		const EventIDBase &	rhs
	)

friend

Definition at line 147 of file EventIDBase.h.

147 { return !( lhs < rhs ); }

Member Data Documentation

◆ m_bunch_crossing_id

number_type EventIDBase::m_bunch_crossing_id { UNDEFNUM }

private

bunch crossing ID, 32 bit unsigned

Definition at line 208 of file EventIDBase.h.

◆ m_event_number

event_number_t EventIDBase::m_event_number { UNDEFEVT }

private

event number

Definition at line 195 of file EventIDBase.h.

◆ m_lumi_block

number_type EventIDBase::m_lumi_block { UNDEFNUM }

private

luminosity block number: the number which uniquely tags a luminosity block within a run

Definition at line 205 of file EventIDBase.h.

◆ m_run_number

number_type EventIDBase::m_run_number { UNDEFNUM }

private

run number

Definition at line 192 of file EventIDBase.h.

◆ m_time_stamp

number_type EventIDBase::m_time_stamp { UNDEFNUM }

private

posix time in seconds since 1970/01/01

Definition at line 198 of file EventIDBase.h.

◆ m_time_stamp_ns_offset

number_type EventIDBase::m_time_stamp_ns_offset { UNDEFNUM }

private

time stamp ns - ns time offset for time_stamp, 32 bit unsigned

Definition at line 201 of file EventIDBase.h.

◆ m_type

unsigned EventIDBase::m_type { Invalid }

private

Definition at line 184 of file EventIDBase.h.

◆ UNDEFEVT

const EventIDBase::event_number_t EventIDBase::UNDEFEVT = std::numeric_limits<EventIDBase::event_number_t>::max()

static

Definition at line 71 of file EventIDBase.h.

◆ UNDEFNUM

const EventIDBase::number_type EventIDBase::UNDEFNUM = std::numeric_limits<EventIDBase::number_type>::max()

static

Definition at line 70 of file EventIDBase.h.

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

GaudiKernel/include/GaudiKernel/EventIDBase.h
GaudiKernel/src/Lib/EventIDBase.cpp

Public Types

Static Public Attributes

Friends

structors

Detailed Description

Member Typedef Documentation

◆ event_number_t

◆ number_type

Member Enumeration Documentation

◆ Type

Constructor & Destructor Documentation

◆ EventIDBase() [1/3]

◆ EventIDBase() [2/3]

◆ EventIDBase() [3/3]

◆ ~EventIDBase()

Member Function Documentation

◆ bunch_crossing_id()

◆ event_number()

◆ isLumiEvent()

◆ isRunEvent()

◆ isRunLumi()

◆ isTimeStamp()

◆ isValid()

◆ lumi_block()

◆ run_number()

◆ set_bunch_crossing_id()

◆ set_event_number()

◆ set_lumi_block()

◆ set_run_number()

◆ set_time_stamp()

◆ set_time_stamp_ns_offset()

◆ setLE()

◆ setRE()

◆ setRL()

◆ setTS()

◆ SortByLumiEvent()

◆ SortByRunEvent()

◆ SortByRunLumi()

◆ SortByTimeStamp()

◆ time_stamp()

◆ time_stamp_ns_offset()

Friends And Related Function Documentation

◆ EventIDRange

◆ max [1/2]

◆ max [2/2]

◆ min [1/2]

◆ min [2/2]

◆ operator!=

◆ operator< [1/2]

◆ operator< [2/2]

◆ operator<< [1/2]

◆ operator<< [2/2]

◆ operator<=

◆ operator== [1/2]

◆ operator== [2/2]

◆ operator>

◆ operator>=

Member Data Documentation

◆ m_bunch_crossing_id

◆ m_event_number

◆ m_lumi_block

◆ m_run_number

◆ m_time_stamp

◆ m_time_stamp_ns_offset

◆ m_type

◆ UNDEFEVT

◆ UNDEFNUM