EventIDBase.h File Reference

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

#include <cstdint>
#include <iomanip>
#include <iostream>
#include <tuple>
#include "GaudiKernel/compose.h"

Include dependency graph for EventIDBase.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	details::arg_helper< lambda >
struct	details::arg_helper< Ret(T::*)(Arg) const >
class	EventIDBase
	This class provides a unique identification for each event, in terms of run/event number and/or a time stamp. More...

Namespaces
	details

Typedefs
template<typename lambda >
using	details::argument_t = typename arg_helper< lambda >::type

Functions
template<typename Fun >
auto	details::add_deref (Fun f)
template<typename Proj , typename Cmp = std::greater<>>
auto	details::make_cmp (Proj p, Cmp cmp={})
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)

Detailed Description

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

Author

RD Schaffer R.D.S.nosp@m.chaf.nosp@m.fer@c.nosp@m.ern..nosp@m.ch

Paolo Calafiura pcala.nosp@m.fiur.nosp@m.a@lbl.nosp@m..gov

Charles Leggett

Definition in file EventIDBase.h.

Function Documentation

max()

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

inline

Definition at line 225 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()

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

inline

Definition at line 212 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  )

inline

Definition at line 255 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<<()

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

inline

Definition at line 274 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  )

inline

Definition at line 268 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 );
}