PileUpEventInfo.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
 */
 
/* -C++- */
#ifndef EVENTINFO_PILEUPEVENTINFO_H
# define EVENTINFO_PILEUPEVENTINFO_H 1
 
 
#include "EventInfo/EventInfo.h"
#include "EventInfo/PileUpTimeEventIndex.h"
#include "GaudiKernel/ClassID.h"
#include <list>
#include <memory>
 
class StoreGateSvc;
class MsgStream;

 
class PileUpEventInfo: public EventInfo {
public:

  PileUpEventInfo();
 
  PileUpEventInfo(EventID* id, EventType* type);
  PileUpEventInfo(EventID* id, EventType* type, TriggerInfo* trig_info);
 
  virtual ~PileUpEventInfo();
 
  PileUpEventInfo(const PileUpEventInfo&) = default;
  PileUpEventInfo(PileUpEventInfo&&) = default;
  PileUpEventInfo& operator=(const PileUpEventInfo&) = default;
  PileUpEventInfo& operator=(PileUpEventInfo&&) = default;

  struct SubEvent {
  private:
    PileUpTimeEventIndex m_timeIndex;
  public:
    EventInfo* pSubEvt; 
    StoreGateSvc* pSubEvtSG;  
 
    typedef PileUpTimeEventIndex::time_type time_type;
    typedef PileUpTimeEventIndex::index_type index_type;
    typedef PileUpTimeEventIndex::PileUpType pileup_type;
 
    SubEvent();
    ~SubEvent();
    SubEvent(const SubEvent&);
    SubEvent& operator = (const SubEvent&);
    SubEvent(SubEvent&&);
    SubEvent& operator = (SubEvent&&);
    SubEvent(time_type t, const EventInfo* pse, StoreGateSvc* psg);
    SubEvent(time_type t, index_type index,
             const EventInfo* pse, StoreGateSvc* psg);
    SubEvent(time_type t, index_type index,
             PileUpTimeEventIndex::PileUpType typ,
             const EventInfo* pse, StoreGateSvc* psg);
    SubEvent(time_type t, unsigned int BCID, index_type index,
             PileUpTimeEventIndex::PileUpType typ,
             const EventInfo& rse, StoreGateSvc* psg);
 
    SubEvent(time_type t, std::unique_ptr<EventInfo> pse, StoreGateSvc* psg);
    SubEvent(time_type t, index_type index,
             std::unique_ptr<EventInfo> pse, StoreGateSvc* psg);
    SubEvent(time_type t, index_type index,
             PileUpTimeEventIndex::PileUpType typ,
             std::unique_ptr<EventInfo> pse, StoreGateSvc* psg);
    SubEvent(time_type t, unsigned int BCID, index_type index,
             PileUpTimeEventIndex::PileUpType typ,
             std::unique_ptr<EventInfo> pse, StoreGateSvc* psg);

    time_type time() const {return m_timeIndex.time();}
    index_type index() const {return m_timeIndex.index();}
 
    unsigned int BCID() const;
    pileup_type type() const {return m_timeIndex.type();}
 
    typedef std::list<SubEvent>::const_iterator const_iterator;
    typedef std::list<SubEvent>::iterator iterator;
  };
 
  typedef SubEvent::time_type time_type;
  typedef SubEvent::index_type index_type;
  void addSubEvt(time_type t, PileUpTimeEventIndex::PileUpType puType,
                 const EventInfo* pse, StoreGateSvc* psg) {
    m_subEvents.emplace_back(t, m_subEvents.size(), puType, pse, psg);
  }
 
  void addSubEvt(time_type t, PileUpTimeEventIndex::PileUpType puType,
                 std::unique_ptr<EventInfo> pse, StoreGateSvc* psg) {
    m_subEvents.emplace_back(t, m_subEvents.size(), puType, std::move(pse), psg);
  }

  void addSubEvt(time_type t, unsigned int BCID,
                 PileUpTimeEventIndex::PileUpType puType,
                 const EventInfo& rse, StoreGateSvc* psg) {
    m_subEvents.emplace_back(t, BCID, m_subEvents.size(), puType, rse, psg);
  }
 
  void addSubEvt(time_type t, unsigned int BCID,
                 PileUpTimeEventIndex::PileUpType puType,
                 std::unique_ptr<EventInfo>& pse, StoreGateSvc* psg) {
    m_subEvents.emplace_back(t, BCID, m_subEvents.size(), puType, std::move(pse), psg);
  }
 
  //NO INSERTIONS only push_backs in m_subEvents!


  SubEvent::iterator beginSubEvt() {return m_subEvents.begin();}
  SubEvent::iterator endSubEvt() {return m_subEvents.end();}
  SubEvent::const_iterator beginSubEvt() const {return m_subEvents.begin();}
  SubEvent::const_iterator endSubEvt() const {return m_subEvents.end();}
private:
  std::list<SubEvent> m_subEvents; //FIXME should become a vector
};
 
#include "AthenaKernel/CLASS_DEF.h"
CLASS_DEF(PileUpEventInfo, 2102, 1)
 
#include "AthenaKernel/BaseInfo.h"
SG_ADD_BASE(PileUpEventInfo, EventInfo);
 
#endif // EVENTINFO_PILEUPEVENTINFO_H