AthSequencer.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
// AthSequencer.h
// Header file for class AthSequencer
// Author: S.Binet<binet@cern.ch>
// Stolen from Gaudi repository
#ifndef GAUDISEQUENCER_ATHSEQUENCER_H
#define GAUDISEQUENCER_ATHSEQUENCER_H
 
// Include files
#include "AthenaBaseComps/AthCommonDataStore.h"
#include "AthenaBaseComps/AthCommonMsg.h"
 
#include "Gaudi/Property.h"
#include "Gaudi/Sequence.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/IClassIDSvc.h"
 
 
class AthSequencer
   : public AthCommonDataStore<AthCommonMsg<Gaudi::Sequence>>
{
public:
 
  AthSequencer( const std::string& name, // The path object's name
                ISvcLocator* svcloc      // A pointer to a service location service
                );
 
  virtual ~AthSequencer( );
 
  /*****************************
   ** Public Function Members **
   *****************************/
 
 
  virtual StatusCode initialize( ) override;
  
  virtual StatusCode reinitialize( ) override;
  
  virtual StatusCode execute( const EventContext& ctx ) const override;
 
  virtual StatusCode start () override;
  
  virtual StatusCode stop () override;
 
  virtual void resetExecuted( const EventContext& ctx ) const;
 
  virtual bool isStopOverride( ) const;
  
  StatusCode append( Gaudi::Algorithm* pAlgorithm );
 
  StatusCode createAndAppend(
                             const std::string& type,  // The concrete algorithm class of the algorithm
                             const std::string& name,  // The name to be given to the algorithm
                             Gaudi::Algorithm*& pAlgorithm    // Set to point to the newly created algorithm object
                             );
 
  StatusCode remove( Gaudi::Algorithm* pAlgorithm );
  StatusCode remove( const std::string& name );
 
  StatusCode decodeMemberNames( );
 
  void       membershipHandler( Gaudi::Details::PropertyBase& theProp );
 
  StatusCode decodeBranchMemberNames( );
 
  void       branchMembershipHandler( Gaudi::Details::PropertyBase& theProp );
 
protected:
 
  StatusCode append( Gaudi::Algorithm* pAlgorithm,
                     std::vector<Gaudi::Algorithm*>* theAlgs );
 
  StatusCode createAndAppend(
                             const std::string& type,  // The concrete algorithm class of the algorithm
                             const std::string& name,  // The name to be given to the algorithm
                             Gaudi::Algorithm*& pAlgorithm,    // Set to point to the newly created algorithm object
                             std::vector<Gaudi::Algorithm*>* theAlgs
                             );
 
  StatusCode decodeNames( Gaudi::Property<std::vector<std::string>>& theNames,
                          std::vector<Gaudi::Algorithm*>* theAlgs );
 
  StatusCode remove( const std::string& algname, std::vector<Gaudi::Algorithm*>* theAlgs );
 
private:
  StatusCode executeAlgorithm (Gaudi::Algorithm* theAlgorithm, const EventContext& ctx) const;
 
  /**************************
   ** Private Data Members **
   **************************/
  
  Gaudi::Property<std::vector<std::string>> m_names{this, "Members",{},
    "Algorithm names (of the form '<cppType>/<instanceName>')","SubAlgorithm"};
 
  Gaudi::Property<bool> m_modeOR{this, "ModeOR", false,
    "Use OR logic instead of AND"};
 
  Gaudi::Property<bool> m_ignoreFilter{this, "IgnoreFilterPassed", false,
    "Always continue sequence ignoring filterPassed of member algorithms"};
 
  Gaudi::Property<bool> m_stopOverride{this, "StopOverride", false,
    "Continue even if algorithm filter fails"};
 
  Gaudi::Property<bool> m_sequential{this, "Sequential", false,
    "Concurrent or (strict) Sequential ordering of algorithms"};
 
  Gaudi::Property<double> m_timeout{this, "TimeOut", 0,
    "Abort job after one algorithm or sequence reaches the time out. Timeout given in Nanoseconds "
    "(official ATLAS units), despite its millisecond resolution"};
 
  Gaudi::Property<std::vector<std::string>> m_undeclaredOutputData{this, "ExtraDataForDynamicConsumers", {},
    "Pass these extra output data IDs, which are not declared by any of the algorithms or tools, to dynamic data consumers."};
 
  Gaudi::Property<bool> m_runPostInitialize{this, "ProcessDynamicDataDependencies", false,
     "Run the post initialization step, to dynamically create and gather extra data dependencies. "
     "Should be enabled for the top most sequence."};
 
  ServiceHandle<IClassIDSvc> m_clidSvc;
 
  unsigned int m_timeoutMilliseconds{0};  
  const unsigned int m_maxPass{100};      //<! maximum number of iterations to process dynamic data dependencies
};
 
#endif //GAUDISEQUENCER_ATHSEQUENCER_H