AthenaEventLoopMgr.h

Go to the documentation of this file.

// -*- C++ -*-
 
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENASERVICES_ATHENAEVENTLOOPMGR_H
#define ATHENASERVICES_ATHENAEVENTLOOPMGR_H
 
// Base class headers
#include "AthenaKernel/IEventSeek.h"
#include "AthenaKernel/ICollectionSize.h"
#include "GaudiKernel/IIncidentListener.h"
#include "AthenaKernel/Timeout.h"
#include "GaudiKernel/MinimalEventLoopMgr.h"
 
// Athena headers
#include "AthenaBaseComps/AthMessaging.h"
#include "AthenaKernel/IAthenaEvtLoopPreSelectTool.h"
#include "AthenaKernel/IConditionsCleanerSvc.h"
#ifndef EVENTINFO_EVENTID_H
# include "EventInfo/EventID.h"  /* number_type */
#endif
 
// Gaudi headers
#include <string>
#include <vector>
#include "GaudiKernel/IEvtSelector.h"
#include "Gaudi/Property.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/IChronoStatSvc.h"
#include "GaudiKernel/IAlgExecStateSvc.h"
 
// Forward declarations
class IConversionSvc;
struct IDataManagerSvc;
class IIncidentSvc;
class StoreGateSvc;
class EventContext;
class ISvcLocator;
class IEvtIdModifierSvc;

class AthenaEventLoopMgr : public extends<MinimalEventLoopMgr,
                                          IEventSeek, ICollectionSize, IIncidentListener>,
                           public Athena::TimeoutMaster,
                           public AthMessaging
{
public:
  typedef IEvtSelector::Context   EvtContext;
 
protected:
  typedef ServiceHandle<IIncidentSvc> IIncidentSvc_t;
  IIncidentSvc_t     m_incidentSvc;
 
  typedef ServiceHandle<StoreGateSvc> StoreGateSvc_t;
  StoreGateSvc_t  m_eventStore;  

  IEvtSelector*     m_evtSelector;
  IEvtSelector::Context* m_evtSelCtxt;
  StringProperty    m_evtsel;
 
  typedef ServiceHandle<IDataManagerSvc> IDataManagerSvc_t;
  IDataManagerSvc_t  m_histoDataMgrSvc;
 
  typedef ServiceHandle<IConversionSvc> IConversionSvc_t;
  IConversionSvc_t   m_histoPersSvc;
 
  typedef ServiceHandle<IEvtIdModifierSvc> IEvtIdModifierSvc_t;
  IEvtIdModifierSvc_t m_evtIdModSvc;

  StringArrayProperty m_execAtPreFork;

  StringProperty    m_histPersName;
 
  typedef EventID::number_type number_type;
  number_type m_currentRun;
  bool m_firstRun;

  IntegerProperty m_failureMode;

  UnsignedIntegerProperty m_eventPrintoutInterval;

  typedef IAthenaEvtLoopPreSelectTool          tool_type;
  typedef ToolHandleArray< tool_type >         tool_store;
  typedef tool_store::const_iterator           tool_iterator;
  typedef std::vector<unsigned int>            tool_stats;
  typedef tool_stats::const_iterator           tool_stats_iterator;
 
  tool_stats m_toolInvoke; 
  tool_stats m_toolReject; 
  tool_stats m_toolAccept; 
  tool_store m_tools;         

  bool m_requireInputAttributeList{};

  bool m_useSecondaryEventNumber{};

  void setupPreSelectTools(Gaudi::Details::PropertyBase&);

  StringProperty m_clearStorePolicy;

  void setClearStorePolicy(Gaudi::Details::PropertyBase& clearStorePolicy);

  virtual StatusCode writeHistograms(bool force=false);

  virtual StatusCode executeAlgorithms(const EventContext&);

  StatusCode initializeAlgorithms();
 
protected:
  SmartIF<IAlgExecStateSvc>  m_aess;
 
public:
  AthenaEventLoopMgr(const std::string& nam, ISvcLocator* svcLoc);
  virtual ~AthenaEventLoopMgr();
  virtual StatusCode initialize() override;
  virtual StatusCode finalize() override;
  virtual StatusCode nextEvent(int maxevt) override;
  virtual StatusCode executeEvent( EventContext && ctx ) override;
  virtual StatusCode executeRun(int maxevt) override;
  virtual StatusCode seek(int evt) override;
  virtual int curEvent() const override;
  virtual int size() override;
  virtual void handle(const Incident& inc) override;
  StatusCode execAtPreFork(const EventContext& ctx) const;
  virtual StatusCode stopRun() override;
 
  using AthMessaging::msg;
  using AthMessaging::msgLvl;
 
  //FIXME hack to workaround pylcgdict problem...
  virtual const std::string& name() const override { return Service::name(); } //FIXME 
 
  virtual void modifyEventContext(EventContext& ctx, const EventID& eID, bool consume_modifier_stream);
 
private:
  AthenaEventLoopMgr(); 
  AthenaEventLoopMgr(const AthenaEventLoopMgr&); 
  AthenaEventLoopMgr& operator= (const AthenaEventLoopMgr&); 
 
  StatusCode installEventContext(EventContext& ctx);
 
  int m_nevt{};
  IntegerProperty m_writeInterval;
  bool m_writeHists{};

  unsigned int m_nev;
  unsigned int m_proc;
  bool m_useTools;
 
  unsigned int m_lastNev{};
  unsigned int m_intervalInSeconds;
  time_t m_lastTime{};
 
  bool m_liteLoop;
 
  StoreGateSvc* eventStore() const;
 
  bool m_doChrono = false;
  ServiceHandle<IChronoStatSvc> m_chronoStatSvc;
  ServiceHandle<Athena::IConditionsCleanerSvc> m_conditionsCleaner;
};
 
#endif // STOREGATE_ATHENAEVENTLOOPMGR_H