PileUpEventLoopMgr.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef PILEUPEVENTLOOPMGR_H
#define PILEUPEVENTLOOPMGR_H
 
// Base class headers
#include "AthenaKernel/IEventSeek.h"
#include "GaudiKernel/MinimalEventLoopMgr.h"
 
// Athena headers
#include "AthenaBaseComps/AthMessaging.h"
#include "PileUpTools/PileUpStream.h"
 
// Gaudi headers
#include "Gaudi/Property.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/IAlgExecStateSvc.h"
#include <string>
 
// Forward declarations
class IBeamIntensity;
class IBeamLuminosity;
class IBkgStreamsCache;
class IEvtSelector;
class IIncidentSvc;
class PileUpMergeSvc;
class StoreGateSvc;
class EventContext;
class EventID;
class IEvtIdModifierSvc;
 
class PileUpEventLoopMgr : virtual public IEventSeek,
                           public MinimalEventLoopMgr,
                           public AthMessaging
{
public:
 
  PileUpEventLoopMgr(const std::string& nam, ISvcLocator* svcLoc);
  virtual ~PileUpEventLoopMgr();
 
public:
  virtual StatusCode initialize();
  virtual StatusCode finalize();
  //  virtual StatusCode terminate();
  virtual StatusCode nextEvent(int maxevt);
  virtual StatusCode executeEvent( EventContext &&ctx );
 
  virtual StatusCode seek(int evt);
  virtual int curEvent() const;
 
  virtual void modifyEventContext(EventContext& ctx, const EventID& eID, bool consume_modifier_stream);
 
  virtual StatusCode queryInterface(const InterfaceID& riid,
                                    void** ppvInterface);
 
  using AthMessaging::msg;
  using AthMessaging::msgLvl;
 
 
private:
  SmartIF<IAlgExecStateSvc>  m_aess;
 
  StatusCode setupStreams();
 
  virtual StatusCode executeAlgorithms(const EventContext& ctx);
 
  inline unsigned int getBCID(int bunchXing, unsigned int centralBCID) const {
    //FIXME to be completely safe this should should probably depend on the bunch spacing too. Perhaps that concept should be deprecated though?
    return static_cast<unsigned int>((((bunchXing + static_cast<int>(centralBCID)) % static_cast<int>(m_maxBunchCrossingPerOrbit)) + static_cast<int>(m_maxBunchCrossingPerOrbit) )  % static_cast<int>(m_maxBunchCrossingPerOrbit));
  }
 
  ServiceHandle<IIncidentSvc> m_incidentSvc;
 
  ServiceHandle<PileUpMergeSvc> m_mergeSvc;
 
  PileUpStream m_origStream;
 
  ServiceHandle<StoreGateSvc> m_evtStore;              // overlaid (output) event store
  
  typedef ServiceHandle<IEvtIdModifierSvc> IEvtIdModifierSvc_t;
  IEvtIdModifierSvc_t m_evtIdModSvc;
 
  //unsigned int m_nInputs;
  //unsigned int m_nStores;
 
 
  ServiceHandle<IEvtSelector> m_origSel;
  ServiceHandle<IEvtSelector> m_signalSel;
  ToolHandleArray<IBkgStreamsCache> m_caches;
  Gaudi::Property<float> m_maxCollPerXing;
 
  Gaudi::Property<float> m_xingFreq;
  Gaudi::Property<int> m_firstXing;
  Gaudi::Property<int> m_lastXing;
 
  Gaudi::Property<bool> m_allowSubEvtsEOF;
 
  Gaudi::Property<bool> m_xingByXing;
 
  Gaudi::Property<int> m_failureMode;
 
  Gaudi::Property<std::string> m_evinfName;
 
  Gaudi::Property<std::string> m_evinfContName;
 
  ServiceHandle<IBeamIntensity> m_beamInt;
  ServiceHandle<IBeamLuminosity> m_beamLumi;
 
  uint32_t m_currentRun;
  bool m_firstRun;
 
  unsigned int m_maxBunchCrossingPerOrbit;
 
  int m_nevt;
 
  int m_ncurevt;
  bool m_skipExecAlgs;
  bool m_loadProxies;
 
  Gaudi::Property<bool> m_allowSerialAndMPToDiffer;
 
  Gaudi::Property<uint32_t> m_mcChannelNumber{ this, "MCChannelNumber", 0, "sample MC channel number" };
};
#endif // PILEUPTOOLS_PILEUPEVENTLOOPMGR_H