EventID.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
 */
 
#ifndef EVENTINFO_EVENTID_H
#define EVENTINFO_EVENTID_H

 
//<<<<<< INCLUDES                                                       >>>>>>
 
#include <format>
#include <iostream>
#include <stdint.h>
 
#include "GaudiKernel/EventIDBase.h"

 
class EventID: public EventIDBase {
public:
  typedef EventIDBase::number_type number_type;


  EventID();
  EventID(number_type run_number,
          uint64_t event_number);
  EventID(number_type run_number,
          uint64_t event_number,
          number_type time_stamp);
  EventID(number_type run_number,
          uint64_t event_number,
          number_type time_stamp,
          number_type time_stamp_ns_offset,
          number_type lumi_block,
          number_type bunch_crossing_id);
  EventID(number_type run_number,
          uint64_t event_number,
          number_type time_stamp,
          number_type time_stamp_ns_offset,
          number_type lumi_block,
          number_type bunch_crossing_id,
          number_type detector_mask0,
          number_type detector_mask1,
          number_type detector_mask2 = 0,
          number_type detector_mask3 = 0);
  // Use default copy constructor.
  virtual ~EventID();
 
  EventID(const EventID&) = default;
  EventID(EventID&&) = default;
  EventID& operator=(const EventID&) = default;
  EventID& operator=(EventID&&) = default;

  number_type detector_mask0(void) const;

  number_type detector_mask1(void) const;

  number_type detector_mask2(void) const;

  number_type detector_mask3(void) const;

  uint64_t detector_mask(void) const;
 

  void set_detector_mask(number_type detectorMask0,
                         number_type detectorMask1,
                         number_type detectorMask2 = 0,
                         number_type detectorMask3 = 0);

  friend std::ostream& operator << (std::ostream& os, const EventID& rhs);
private:
  number_type m_detector_mask0 {
    0
  };

  number_type m_detector_mask1 {
    0
  };

  number_type m_detector_mask2 {
    0
  };

  number_type m_detector_mask3 {
    0
  };
};
 
 
//<<<<<< INLINE PUBLIC FUNCTIONS                                        >>>>>>
 
 
inline
EventID::number_type
EventID::detector_mask0(void) const {
  return m_detector_mask0;
}
 
inline
EventID::number_type
EventID::detector_mask1(void) const {
  return m_detector_mask1;
}
 
inline
EventID::number_type
EventID::detector_mask2(void) const {
  return m_detector_mask2;
}
 
inline
EventID::number_type
EventID::detector_mask3(void) const {
  return m_detector_mask3;
}
 
inline
uint64_t
EventID::detector_mask(void) const {
  uint64_t result = m_detector_mask1;
 
  result = result << 32;
  result |= m_detector_mask0;
  return(result);
}
 
 
namespace std {

template <>
struct formatter<EventID>
  : public formatter<string_view>
{
  template <class FmtContext>
  FmtContext::iterator format (const EventID& ei, FmtContext& ctx) const
  {
    return std::format_to (ctx.out(),
                           "[Run,Evt,Lumi,Time,BunchCross,DetMask] = [{},{},{},{}:{},{},{:#0x},{:#0x},{:#0x}]",
                           ei.run_number(),
                           ei.event_number(),
                           ei.lumi_block(),
                           ei.time_stamp(),
                           ei.time_stamp_ns_offset(),
                           ei.bunch_crossing_id(),
                           ei.detector_mask(),
                           ei.detector_mask2(),
                           ei.detector_mask3());
  }
};
 
} // namespace std
 
 
inline std::ostream& operator << (std::ostream& os, const EventID& rhs) {
  os << std::format ("{}", rhs);
  return os;
}
 
 
#endif // EVENTINFO_EVENTID_H