EventIDBase.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_EVENTIDBASE_H
#define GAUDIKERNEL_EVENTIDBASE_H 1

#include <iostream>
#include <tuple>
#include <stdint.h>


class EventIDBase {
public:
  
  typedef unsigned int       number_type;
  typedef uint64_t           event_number_t;

  static const number_type    UNDEFNUM;
  static const event_number_t UNDEFEVT;
public:
  
  

  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);
  // Use default copy constructor.
  virtual ~EventIDBase();
  
  number_type   run_number () const { return m_run_number; }
  
  event_number_t event_number () const { return m_event_number; }
  
  number_type   time_stamp   () const { return m_time_stamp; }
  
  number_type   time_stamp_ns_offset () const { return m_time_stamp_ns_offset; }
  
  number_type   lumi_block           () const { return m_lumiBlock; }
  
  number_type   bunch_crossing_id    () const { return m_bunch_crossing_id; }
  
  void set_run_number  (number_type runNumber) { m_run_number = runNumber; setRE();}
  
  void set_event_number (event_number_t eventNumber) { m_event_number = eventNumber; }
  
  void set_time_stamp   (number_type timeStamp) { m_time_stamp = timeStamp; setTS();}
  
  void set_time_stamp_ns_offset (number_type timeStampNs) {
    m_time_stamp_ns_offset = timeStampNs; 
  }
  
  void set_lumi_block (number_type lumiBlock) { m_lumiBlock = lumiBlock; setLE(); }
  
  void set_bunch_crossing_id (number_type bcid) { m_bunch_crossing_id = bcid; }
  
  friend bool operator<(const EventIDBase& lhs, const EventIDBase& rhs);
  friend bool operator>(const EventIDBase& lhs, const EventIDBase& rhs);
  friend bool operator==(const EventIDBase& lhs, const EventIDBase& rhs);
  friend bool operator!=(const EventIDBase& lhs, const EventIDBase& rhs);
  friend bool operator<=(const EventIDBase& lhs, const EventIDBase& rhs);
  friend bool operator>=(const EventIDBase& lhs, const EventIDBase& rhs);
  
  bool isRunEvent() const;
  bool isTimeStamp() const;
  bool isLumiEvent() const;
  bool isValid() const;

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

  class SortByTimeStamp {
  public:
    bool operator() ( const EventIDBase& t1, const EventIDBase& t2 ) const {
      if (t1.time_stamp() == t2.time_stamp()) {
        return t1.time_stamp_ns_offset() > t2.time_stamp_ns_offset();
      } else {
        return t1.time_stamp() > t2.time_stamp();
      }
    }
    bool operator() ( const EventIDBase* t1, const EventIDBase* t2 ) const {
      return ( SortByTimeStamp()(*t1,*t2) );
    }
  };

  class SortByRunEvent {
  public:
    bool operator() ( const EventIDBase& t1, const EventIDBase& t2 ) const {
      if (t1.run_number() == t2.run_number()) {
        return t1.event_number() > t2.event_number();
      } else {
        return t1.run_number() > t2.run_number();
      }
    }
    bool operator() ( const EventIDBase* t1, const EventIDBase* t2 ) const {
      return ( SortByRunEvent()(*t1,*t2) );
    }
  };

  class SortByLumiEvent {
  public:
    bool operator() ( const EventIDBase& t1, const EventIDBase& t2 ) const {
      if (t1.lumi_block() == t2.lumi_block()) {
        return t1.event_number() > t2.event_number();
      } else {
        return t1.lumi_block() > t2.lumi_block();
      }
    }
    bool operator() ( const EventIDBase* t1, const EventIDBase* t2 ) const {
      return ( SortByLumiEvent()(*t1,*t2) );
    }
  };

private:
  
  enum Type {
    Invalid = 0,
    RunEvent = 1 << 1,
    TimeStamp = 1 << 2,
    LumiEvent = 1 << 3
  };

  unsigned m_type {Invalid};
    
  void setRE() { m_type = m_type | RunEvent; }
  void setTS() { m_type = m_type | TimeStamp; }
  void setLE() { m_type = m_type | LumiEvent; }

  number_type   m_run_number {UNDEFNUM};
  
  event_number_t      m_event_number {UNDEFEVT};
  
  number_type   m_time_stamp {UNDEFNUM};
  
  number_type   m_time_stamp_ns_offset {UNDEFNUM}; 
  
  number_type   m_lumiBlock {UNDEFNUM};
  
  number_type   m_bunch_crossing_id {UNDEFNUM};
  
};

inline bool operator<(const EventIDBase& lhs, const EventIDBase& rhs) {
  // first try ordering by timestamp if both are non-zero
  // then try ordering by lumi/event if both have non-zero lumi
  // then order by run/event

  if (lhs.isTimeStamp() && rhs.isTimeStamp()) {
    return (lhs.m_time_stamp < rhs.m_time_stamp);
  } else {
    if (lhs.isLumiEvent() && rhs.isLumiEvent()) {
      return (std::tie(lhs.m_lumiBlock, lhs.m_event_number) < 
              std::tie(rhs.m_lumiBlock, rhs.m_event_number) );
    } else {
      return (std::tie(lhs.m_run_number, lhs.m_event_number) < 
              std::tie(rhs.m_run_number, rhs.m_event_number) );
    }
  }
}

inline bool operator==(const EventIDBase& lhs, const EventIDBase& rhs) {
  // We assume that equality via run/event numbers is sufficient
  return ( lhs.m_run_number  == rhs.m_run_number && 
           lhs.m_event_number == rhs.m_event_number );
}
inline bool operator>(const EventIDBase& lhs, const EventIDBase& rhs) {
  return !( (lhs < rhs) || (lhs == rhs));
}
inline bool operator!=(const EventIDBase& lhs, const EventIDBase& rhs) {
  return !(lhs == rhs);
}
inline bool operator<=(const EventIDBase& lhs, const EventIDBase& rhs) {
  return !(lhs > rhs);
}
inline bool operator>=(const EventIDBase& lhs, const EventIDBase& rhs) {
  return !(lhs < rhs);
}

inline std::ostream& operator<<(std::ostream& os, const EventIDBase& rhs) {
  if (rhs.m_type == EventIDBase::Invalid) {
    os << "[INVALID]";
    return os;
  }

  os << "[" 
     << rhs.m_run_number 
     << "," << rhs.m_event_number;
  
  if ( rhs.isTimeStamp() != 0 ) {
    os << "," << rhs.m_time_stamp << ":" << rhs.m_time_stamp_ns_offset;
  }

  if ( rhs.isLumiEvent() != 0) {
    os << ",l:" << rhs.m_lumiBlock;
  }

  if ( rhs.m_bunch_crossing_id != 0) {
    os << ",b:" << rhs.m_bunch_crossing_id;
  }
  os << "]";
  return os;
}

#endif // EVENTINFO_EVENTID_H