AthenaMtesEventLoopMgr.h

Go to the documentation of this file.

// -*- C++ -*-
 
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENASERVICES_ATHENAMTESEVENTLOOPMGR_H
#define ATHENASERVICES_ATHENAMTESEVENTLOOPMGR_H
 
#include "GaudiKernel/IEvtSelector.h"
#include "Gaudi/Property.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/MinimalEventLoopMgr.h"
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/IAlgResourcePool.h"
#include "GaudiKernel/IHiveWhiteBoard.h"
#include "GaudiKernel/IScheduler.h"
#include "GaudiKernel/IAlgExecStateSvc.h"
 
#include "AthenaKernel/Timeout.h"
#include "AthenaKernel/IAthenaEvtLoopPreSelectTool.h"
#include "AthenaKernel/IEventSeek.h"
#include "AthenaKernel/ICollectionSize.h"
#include "AthenaKernel/IConditionsCleanerSvc.h"
#include "AthenaKernel/IHybridProcessorHelper.h"
 
#include <memory>
#include <string>
#include <vector>
 
#ifndef EVENTINFO_EVENTID_H
# include "EventInfo/EventID.h"  /* number_type */
#endif
 
// Forward declarations
class IConversionSvc;
struct IDataManagerSvc;
class IDataProviderSvc;
class IIncidentSvc;
class StoreGateSvc;
class ISvcLocator;
class IEvtIdModifierSvc;
class OutputStreamSequencerSvc;
 
namespace yampl {
  class ISocket;
}
 
class AthenaMtesEventLoopMgr
  : virtual public IEventSeek,
    virtual public ICollectionSize,
    virtual public IIncidentListener,
    virtual public IHybridProcessorHelper,
            public MinimalEventLoopMgr,
            public Athena::TimeoutMaster
{
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;
  EvtContext*       m_evtContext;
  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;
 
  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;         
 
  void setupPreSelectTools(Gaudi::Details::PropertyBase&);
 
  StringProperty m_clearStorePolicy;
 
  bool m_requireInputAttributeList{};
  bool m_useSecondaryEventNumber{};
 
  void setClearStorePolicy(Gaudi::Details::PropertyBase& clearStorePolicy);
 
  virtual StatusCode writeHistograms(bool force=false);
 
  virtual StatusCode executeAlgorithms();
 
  StatusCode initializeAlgorithms();
 
 
  //***********************************************************//
  // for Hive
protected:
 
  SmartIF<IHiveWhiteBoard>  m_whiteboard;
 
  SmartIF<IAlgResourcePool>  m_algResourcePool;
 
  SmartIF<IAlgExecStateSvc>  m_aess;
 
  SmartIF<IProperty>        m_appMgrProperty;
 
  SmartIF<IScheduler> m_schedulerSvc;
  StatusCode clearWBSlot(int evtSlot);
  int declareEventRootAddress(EventContext&);
  SmartIF< IIncidentListener >  m_abortEventListener;
  std::string m_schedulerName;
  std::string m_whiteboardName;
  bool                m_scheduledStop;
 
  int m_currentEvntNum{-1};
 
public:
  StatusCode getEventRoot(IOpaqueAddress*& refpAddr);    
 
 
 
//***********************************************************//
 
public:
  AthenaMtesEventLoopMgr(const std::string& nam, ISvcLocator* svcLoc);
  virtual ~AthenaMtesEventLoopMgr();
  virtual StatusCode initialize() override;
  virtual StatusCode finalize() override;
  virtual StatusCode nextEvent(int maxevt) override;
  virtual EventContext createEventContext() override;
  virtual StatusCode executeEvent( EventContext&& ctx ) override;
  virtual StatusCode executeRun(int maxevt) override;
  virtual StatusCode stopRun() override;
  virtual StatusCode stop() override;
 
 
  virtual StatusCode seek(int evt) override;
  virtual int curEvent() const override;
  virtual int size() override;
  virtual void handle(const Incident& inc) override;
 
  virtual void resetAppReturnCode() override;
  
  virtual void setCurrentEventNum(int num) override;
  virtual bool terminateLoop() override;
 
  virtual int drainScheduler(int& finishedEvents, bool report) override;
 
  virtual StatusCode queryInterface( const InterfaceID& riid, 
                                     void** ppvInterface ) override;
 
  //FIXME hack to workaround pylcgdict problem...
  virtual const std::string& name() const  override { return Service::name(); } //FIXME 
 
private:
  AthenaMtesEventLoopMgr() = delete;
  AthenaMtesEventLoopMgr(const AthenaMtesEventLoopMgr&) = delete;
  AthenaMtesEventLoopMgr& operator= (const AthenaMtesEventLoopMgr&) = delete;
 
  unsigned int m_nevt;
  unsigned int m_timeStamp { 0 };
  UnsignedIntegerProperty m_writeInterval;
  bool m_writeHists;
 
  bool m_terminateLoop { false };
 
  unsigned int m_nev;
  unsigned int m_proc;
  bool m_useTools;
  bool m_doEvtHeartbeat;
 
  unsigned int m_flmbi, m_timeStampInt;
 
  // from MinimalEventLoopMgr
public:
  typedef std::list<SmartIF<IAlgorithm> >  ListAlg;
 
  // Property to specify text messages with event ranges to simulate input from
  // EventService pilot - use for standalone tests
  StringArrayProperty m_testPilotMessages;
  bool m_inTestMode { false };
   
private:
  StoreGateSvc* eventStore() const;
 
  void modifyEventContext(EventContext& ctx, const EventID& eID, bool consume_modifier_stream);
 
  ServiceHandle<Athena::IConditionsCleanerSvc> m_conditionsCleaner;
  
  // Save a copy of the last event context to use
  // at the end of event processing.
  EventContext m_lastEventContext;
 
  // Event Service Specific stuff
  struct RangeStruct{
    RangeStruct()
      : eventRangeID{""}
      , pfn{""}
      , startEvent{-1}
      , lastEvent{-1} {}
 
    std::string eventRangeID;
    std::string pfn;
    int startEvent;
    int lastEvent;
  };
 
  std::unique_ptr<RangeStruct> getNextRange(yampl::ISocket* socket);
  void trimRangeStrings(std::string& str);
 
  ServiceHandle<OutputStreamSequencerSvc>  m_outSeqSvc;
 
  Gaudi::Property<std::string> m_eventRangeChannel{this
      , "EventRangeChannel"
      , "EventService_EventRanges"
      , "The name of the Yampl channel between AthenaMT and the Pilot"
      };
 
  // Hopefully a temporary measurement. For the time being we cannot
  // support event ranges from different input files.
  std::string m_pfn{""};
 
  // For the event service running:
  yampl::ISocket* m_socket{nullptr};
};
 
#endif // ATHENASERVICES_ATHENAHIVEEVENTLOOPMGR_H