AthenaEventLoopMgr.h

Go to the documentation of this file.

// -*- C++ -*-
 
/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENASERVICES_ATHENAEVENTLOOPMGR_H
#define ATHENASERVICES_ATHENAEVENTLOOPMGR_H
 
#include "CxxUtils/checker_macros.h"
ATLAS_NO_CHECK_FILE_THREAD_SAFETY;  // non-MT EventLoopMgr
 
// 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/IEvtSelectorSeek.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 
  : virtual public IEventSeek,
    virtual public ICollectionSize,
    virtual public IIncidentListener,
    public MinimalEventLoopMgr,
    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();
  virtual StatusCode finalize();
  virtual StatusCode nextEvent(int maxevt);
  virtual StatusCode executeEvent( EventContext && ctx );
  virtual StatusCode executeRun(int maxevt);
  virtual StatusCode seek(int evt);
  virtual int curEvent() const;
  virtual int size();
  void handle(const Incident& inc);
  StatusCode execAtPreFork(const EventContext& ctx) const;
 
  virtual StatusCode queryInterface( const InterfaceID& riid, 
                                     void** ppvInterface );
 
  using AthMessaging::msg;
  using AthMessaging::msgLvl;
 
  //FIXME hack to workaround pylcgdict problem...
  virtual const std::string& name() const { 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