AthSequencer Class Reference

ClassName: AthSequencer. More...

#include <AthSequencer.h>

Inheritance diagram for AthSequencer:

Collaboration diagram for AthSequencer:

Public Member Functions
	AthSequencer (const std::string &name, ISvcLocator *svcloc)
	Constructor(s) More...
virtual	~AthSequencer ()
	Destructor. More...
virtual StatusCode	initialize () override
	Initialization of a sequencer. More...
virtual StatusCode	reinitialize () override
	AthSequencer Reinitialization. More...
virtual StatusCode	execute (const EventContext &ctx) const override
	The actions to be performed by the sequencer on an event. More...
virtual StatusCode	start () override
	Start (from INITIALIZED to RUNNING). More...
virtual StatusCode	stop () override
	Stop (from RUNNING to INITIALIZED). More...
virtual void	resetExecuted (const EventContext &ctx) const
	Reset the AthSequencer executed state for the current event. More...
virtual bool	isStopOverride () const
	Has the StopOverride mode been set? More...
StatusCode	append (Gaudi::Algorithm *pAlgorithm)
	Append an algorithm to the sequencer. More...
StatusCode	createAndAppend (const std::string &type, const std::string &name, Gaudi::Algorithm *&pAlgorithm)
	Create a algorithm and append it to the sequencer. More...
StatusCode	remove (Gaudi::Algorithm *pAlgorithm)
	Remove the specified algorithm from the sequencer. More...
StatusCode	remove (const std::string &name)
StatusCode	decodeMemberNames ()
	Decode Member Name list. More...
void	membershipHandler (Gaudi::Details::PropertyBase &theProp)
	"Members" property handler More...
StatusCode	decodeBranchMemberNames ()
	Decode branch member naem list. More...
void	branchMembershipHandler (Gaudi::Details::PropertyBase &theProp)
	"BranchMembers" propertry handler More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
StatusCode	append (Gaudi::Algorithm *pAlgorithm, std::vector< Gaudi::Algorithm * > *theAlgs)
	Append an algorithm to the sequencer. More...
StatusCode	createAndAppend (const std::string &type, const std::string &name, Gaudi::Algorithm *&pAlgorithm, std::vector< Gaudi::Algorithm * > *theAlgs)
	Create a algorithm and append it to the sequencer. More...
StatusCode	decodeNames (Gaudi::Property< std::vector< std::string >> &theNames, std::vector< Gaudi::Algorithm * > *theAlgs)
	Decode algorithm names, creating or appending algorithms as appropriate. More...
StatusCode	remove (const std::string &algname, std::vector< Gaudi::Algorithm * > *theAlgs)
	Remove the specified algorithm from the sequencer. More...
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	executeAlgorithm (Gaudi::Algorithm *theAlgorithm, const EventContext &ctx) const
	Run one algorithm. More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
Gaudi::Property< std::vector< std::string > >	m_names
Gaudi::Property< bool >	m_modeOR
Gaudi::Property< bool >	m_ignoreFilter
Gaudi::Property< bool >	m_stopOverride
Gaudi::Property< bool >	m_sequential
Gaudi::Property< double >	m_timeout
Gaudi::Property< std::vector< std::string > >	m_undeclaredOutputData
Gaudi::Property< bool >	m_runPostInitialize
ServiceHandle< IClassIDSvc >	m_clidSvc
unsigned int	m_timeoutMilliseconds {0}
	timeout converted to ms More...
const unsigned int	m_maxPass {100}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

ClassName: AthSequencer.

Description: An AthSequencer is essentially a list of Algorithms and is responsible for their management. Note that Sequences may themselves contain other Sequences. The default execute( ) implementation loops over the members of the sequence, calling their execute( ) methods. However, this can be modified if a member is disabled, has already been executed, or a member indicates that it's filter fails. The the former two cases the execution of the member is bypassed. In the latter case, the loop is terminated and the AthSequencer assumes the same filtered state as the last member.

Definition at line 38 of file AthSequencer.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

AthSequencer()

AthSequencer::AthSequencer	(	const std::string &	name,
		ISvcLocator *	svcloc
	)

Constructor(s)

Definition at line 35 of file AthSequencer.cxx.

                                                      :
  ::AthCommonDataStore<AthCommonMsg<Gaudi::Sequence>>   ( name, pSvcLocator ),
  m_clidSvc("ClassIDSvc/ClassIDSvc", name),
  m_timeoutMilliseconds(0)
{
  m_names.declareUpdateHandler( &AthSequencer::membershipHandler, this );
}

~AthSequencer()

AthSequencer::~AthSequencer ( )

virtual

Destructor.

Definition at line 47 of file AthSequencer.cxx.

{}

Member Function Documentation

append() [1/2]

StatusCode AthSequencer::append

(

Gaudi::Algorithm *

pAlgorithm

)

Append an algorithm to the sequencer.

Definition at line 247 of file AthSequencer.cxx.

{
  return append( pAlgorithm, subAlgorithms( ) );
}

append() [2/2]

StatusCode AthSequencer::append ( Gaudi::Algorithm *  pAlgorithm, std::vector< Gaudi::Algorithm * > *  theAlgs  )

protected

Append an algorithm to the sequencer.

Protected Member Functions.

Definition at line 290 of file AthSequencer.cxx.

{
  bool all_good = true;
  // Check that the specified algorithm doesn't already exist 
  // in the membership list
  for (Gaudi::Algorithm* theAlgorithm : *theAlgs) {
    if ( theAlgorithm == pAlgorithm ) {
      all_good = false;
      break;
    }
  }
  if ( all_good ) {
    theAlgs->push_back( pAlgorithm );
    pAlgorithm->addRef();
  }
  return all_good ? StatusCode::SUCCESS : StatusCode::FAILURE;
}

branchMembershipHandler()

void AthSequencer::branchMembershipHandler

(

Gaudi::Details::PropertyBase &

theProp

)

"BranchMembers" propertry handler

createAndAppend() [1/2]

StatusCode AthSequencer::createAndAppend	(	const std::string &	type,
		const std::string &	name,
		Gaudi::Algorithm *&	pAlgorithm
	)

Create a algorithm and append it to the sequencer.

A call to this method creates a child algorithm object. Note that the returned pointer is to Algorithm (as opposed to IAlgorithm), and thus the methods of IProperty are also available for the direct setting of the algorithm's properties. Using this mechanism instead of creating algorithms directly via the new operator is preferred since then the framework may take care of all of the necessary book-keeping.

Definition at line 253 of file AthSequencer.cxx.

{
  return createAndAppend( type, name, pAlgorithm, subAlgorithms( ) );
}

createAndAppend() [2/2]

StatusCode AthSequencer::createAndAppend ( const std::string &  type, const std::string &  name, Gaudi::Algorithm *&  pAlgorithm, std::vector< Gaudi::Algorithm * > *  theAlgs  )

protected

Create a algorithm and append it to the sequencer.

A call to this method creates a child algorithm object. Note that the returned pointer is to Algorithm (as opposed to IAlgorithm), and thus the methods of IProperty are also available for the direct setting of the algorithm's properties. Using this mechanism instead of creating algorithms directly via the new operator is preferred since then the framework may take care of all of the necessary book-keeping.

Definition at line 310 of file AthSequencer.cxx.

{
  SmartIF<IAlgManager> theAlgMgr(Gaudi::svcLocator()->as<IAlgManager>());
  IAlgorithm* tmp = nullptr;
 
  ATH_CHECK( theAlgMgr->createAlgorithm( type, algName, tmp ) );
  pAlgorithm = dynamic_cast<Gaudi::Algorithm*>(tmp);
  theAlgs->push_back( pAlgorithm );
 
  return StatusCode::SUCCESS;
}

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::declareProperty ( Gaudi::Property< T > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                 {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

decodeBranchMemberNames()

StatusCode AthSequencer::decodeBranchMemberNames

(

)

Decode branch member naem list.

decodeMemberNames()

StatusCode AthSequencer::decodeMemberNames

(

)

Decode Member Name list.

Definition at line 273 of file AthSequencer.cxx.

{
  // Decode the membership list
  return decodeNames( m_names, subAlgorithms() );
}

decodeNames()

StatusCode AthSequencer::decodeNames ( Gaudi::Property< std::vector< std::string >> &  theNames, std::vector< Gaudi::Algorithm * > *  theAlgs  )

protected

Decode algorithm names, creating or appending algorithms as appropriate.

Definition at line 326 of file AthSequencer.cxx.

{
  SmartIF<IAlgManager> theAlgMgr(Gaudi::svcLocator()->as<IAlgManager>());
 
  // Clear the existing list of algorithms
  theAlgs->clear( );
 
  // Build the list of member algorithms from the contents of the
  // theNames list.
  StatusCode result = StatusCode::SUCCESS;
  for (const std::string& name : theNames.value()) {
 
    // Parse the name for a syntax of the form <type>/<name>
    Gaudi::Utils::TypeNameString tn(name);
 
    // Check whether the supplied name corresponds to an existing
    // Algorithm object.
    SmartIF<IAlgorithm>& theIAlg = theAlgMgr->algorithm(tn.name(), /*createIf*/false);
    Gaudi::Algorithm* theAlgorithm = nullptr;
    if ( theIAlg ) {
      theAlgorithm = dynamic_cast<Gaudi::Algorithm*>(theIAlg.get());
      if ( theAlgorithm ) {
        // The specified Algorithm already exists -
        // just append it to the membership list.
        if ( append(theAlgorithm, theAlgs).isSuccess( ) ) {
          ATH_MSG_DEBUG (tn.name() << " already exists - appended to member list");
        } else {
          ATH_MSG_WARNING (tn.name() << " already exists - append failed!!!");
          result = StatusCode::FAILURE;
        }
      }
      else {
        ATH_MSG_WARNING (tn.name() << " is not an Algorithm - Failed dynamic cast");
        result = StatusCode::FAILURE;
      }
    } else {
      // The specified name doesn't exist -
      // create a new object of the specified type and append it to
      // the membership list.
      if ( createAndAppend(tn.type(), tn.name(), theAlgorithm, theAlgs).isSuccess( ) ) {
        ATH_MSG_DEBUG (tn.name() << " doesn't exist - created and appended to member list");
      } else {
        ATH_MSG_WARNING (tn.name() << " doesn't exist - creation failed!!!");
        result = StatusCode::FAILURE;
      }
    }
  } //> loop over names
 
  // Print membership list
  if (msgLvl(MSG::DEBUG)) {
    if ( result.isSuccess() && !theAlgs->empty() ) {
 
      msg(MSG::DEBUG) << "Member list: ";
      bool first = true;
      for (Gaudi::Algorithm* alg : *theAlgs) {
        if (first)
          first = false;
        else
          msg() << ", ";
        if ( alg->name() == System::typeinfoName(typeid(*alg)))
          msg() << alg->name();
        else
          msg() << System::typeinfoName(typeid(*alg)) << "/" << alg->name();
      }
      msg(MSG::DEBUG) << endmsg;
    }
  }
  return result;
}

detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode AthSequencer::execute ( const EventContext &  ctx ) const

overridevirtual

The actions to be performed by the sequencer on an event.

This method is invoked once per event.

Definition at line 114 of file AthSequencer.cxx.

{
  StatusCode sc = StatusCode::SUCCESS;
  bool seqPass = !m_modeOR;
 
  ATH_MSG_DEBUG ("Executing " << name() << "...");
 
  auto& state = execState( ctx );
  
  // Bypass the loop if this sequencer is disabled or has already been executed
  if ( isEnabled( ) && state.state() != AlgExecState::State::Done ) {
 
    // Prevent multiple executions of this sequencer for the current event
    state.setState( AlgExecState::State::Executing );
 
    // Loop over all algorithms calling their execute functions if they
    // are (a) not disabled, and (b) aren't already executed. Note that
    // in the latter case the filter state is still examined. Terminate
    // the loop if an algorithm indicates that it's filter didn't pass.
    const std::vector<Gaudi::Algorithm*>* subAlgms = subAlgorithms( );
    for (auto theAlgorithm : *subAlgms) {
      if ( theAlgorithm->isEnabled( ) ) {
        if ( theAlgorithm->execState(ctx).state() == AlgExecState::State::None ) {
          sc = executeAlgorithm (theAlgorithm, ctx);
        }
    
        if ( sc.isSuccess() ) {
      
          if ( !m_ignoreFilter ) {
            // Take the filter passed status of this algorithm as my own status
            const bool passed = theAlgorithm->execState( ctx ).filterPassed();
            state.setFilterPassed( passed );
            
            // The behaviour when the filter fails depends on the 
            // StopOverride property.
            // The default action is to stop processing, but this default can be
            // overridden by setting the "StopOverride" property to false.
            if ( m_modeOR ? passed : !passed ) {
              seqPass = passed;
              if ( !m_stopOverride ) break;
            }
          }
        } else {
          ATH_MSG_INFO ("execute of [" << theAlgorithm->name() << "] did NOT succeed");
          break;
        }
      }
    }
  }
 
  if ( !m_ignoreFilter && !m_names.empty() ) state.setFilterPassed( seqPass );
 
  state.setState( AlgExecState::State::Done );
 
  return sc;
}

executeAlgorithm()

StatusCode AthSequencer::executeAlgorithm ( Gaudi::Algorithm *  theAlgorithm, const EventContext &  ctx  ) const

private

Run one algorithm.

Definition at line 172 of file AthSequencer.cxx.

{
  // Start timer if enabled
  if (m_timeoutMilliseconds>0) {
    // Create thread-specific timer if not done already
    if (!s_abortTimer) {
      s_abortTimer = std::make_unique<Athena::AlgorithmTimer>(0);
    }
    s_abortTimer->start(m_timeoutMilliseconds);
  }
 
  // Call the sysExecute() of the method the algorithm
  StatusCode sc = theAlgorithm->sysExecute( ctx );
 
  // Stop timer if enabled
  if (m_timeoutMilliseconds>0) {
    const unsigned int remaining = s_abortTimer->stop();
    ATH_MSG_DEBUG ("Time left before interrupting <"
                   << theAlgorithm->name() << "> : " << remaining);
  }
  return sc;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

initialize()

StatusCode AthSequencer::initialize ( )

overridevirtual

Initialization of a sequencer.

Typically things like histogram creation, setting up of data structures etc, should be done here. If a sequence has properties specified in the job options file, they will be set to the requested values BEFORE the initialize() method is invoked.

Definition at line 51 of file AthSequencer.cxx.

{
  m_timeoutMilliseconds = static_cast<int>(m_timeout * 1e-6);
  
  if ( RUNNING_ON_VALGRIND ) {
    ATH_MSG_WARNING ("### detected running inside Valgrind, disabling algorithm timeout ###");
    m_timeoutMilliseconds = 0;
  }
  
  if (!decodeMemberNames().isSuccess()) {
    ATH_MSG_ERROR ("Unable to configure one or more sequencer members ");
    return StatusCode::FAILURE;
  }
 
  Ath::DynamicDataHelper dynamic_data_helper;
  StatusCode sc(StatusCode::SUCCESS);
  // Loop over all sub-algorithms
  for (Gaudi::Algorithm* theAlgorithm : *subAlgorithms()) {
    if (!theAlgorithm->sysInitialize( ).isSuccess()) {
      ATH_MSG_ERROR ("Unable to initialize Algorithm "
                     << theAlgorithm->type() << "/" << theAlgorithm->name());
      sc= StatusCode::FAILURE;
    }
    else if (m_runPostInitialize) {
       // visit all algorithms and its tools to gather their input, output handles and dynamic data consumers
       dynamic_data_helper.gatherDataHandlesAndDynamicConsumers(this->name(),theAlgorithm);
    }
  }
  if (sc.isSuccess() && m_runPostInitialize) {
     ATH_MSG_DEBUG("Allow dynamic data consumers to update their data dependencies.");
     if (!m_undeclaredOutputData.empty()) {
        ATH_CHECK( m_clidSvc.retrieve() );
        ATH_CHECK( dynamic_data_helper.addExtraDependencies(*m_clidSvc, m_undeclaredOutputData.value(), msg() ) );
     }
     dynamic_data_helper.updateDataNeeds(m_maxPass, msg());
  }
  return sc;
}

inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isStopOverride()

bool AthSequencer::isStopOverride ( ) const

virtual

Has the StopOverride mode been set?

Definition at line 241 of file AthSequencer.cxx.

{
  return m_stopOverride.value( );
}

membershipHandler()

void AthSequencer::membershipHandler

(

Gaudi::Details::PropertyBase &

theProp

)

"Members" property handler

Definition at line 280 of file AthSequencer.cxx.

{
  if ( isInitialized() ) decodeMemberNames().ignore();
}

msg() [1/2]

MsgStream& AthCommonMsg< Gaudi::Sequence >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< Gaudi::Sequence >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< Gaudi::Sequence >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

reinitialize()

StatusCode AthSequencer::reinitialize ( )

overridevirtual

AthSequencer Reinitialization.

Definition at line 91 of file AthSequencer.cxx.

{
  StatusCode sc(StatusCode::SUCCESS);
  // Bypass the loop if this sequencer is disabled
  if ( isEnabled( ) ) {
    
    // Loop over all members calling their reinitialize functions
    // if they are not disabled.
    for (Gaudi::Algorithm* theAlgorithm : *subAlgorithms()) {
      if ( theAlgorithm->isEnabled( ) ) {
        if (theAlgorithm->sysReinitialize( ).isFailure()) {
          ATH_MSG_ERROR ("Unable to reinitialize Algorithm "
                         << theAlgorithm->type () << "/"
                         << theAlgorithm->name());
          sc = StatusCode::FAILURE;
        }
      }
    }
  }
  return sc;
}

remove() [1/3]

StatusCode AthSequencer::remove ( const std::string &  algname, std::vector< Gaudi::Algorithm * > *  theAlgs  )

protected

Remove the specified algorithm from the sequencer.

Definition at line 398 of file AthSequencer.cxx.

{
  ATH_MSG_ERROR ("AthSequencer::remove( ) is not supported");
  return StatusCode::FAILURE;
}

remove() [2/3]

StatusCode AthSequencer::remove

(

const std::string &

name

)

Definition at line 267 of file AthSequencer.cxx.

{
  return remove( algname, subAlgorithms( ) );
}

remove() [3/3]

StatusCode AthSequencer::remove

(

Gaudi::Algorithm *

pAlgorithm

)

Remove the specified algorithm from the sequencer.

Definition at line 261 of file AthSequencer.cxx.

{
  return remove (pAlgorithm->name());
}

renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

resetExecuted()

void AthSequencer::resetExecuted ( const EventContext &  ctx ) const

virtual

Reset the AthSequencer executed state for the current event.

Definition at line 229 of file AthSequencer.cxx.

{
  execState(ctx).reset();
  
  // Loop over all members calling their resetExecuted functions
  // if they are not disabled.
  for (Gaudi::Algorithm* theAlgorithm : *subAlgorithms()) {
    theAlgorithm->execState(ctx).reset();
  }
}

start()

StatusCode AthSequencer::start ( )

overridevirtual

Start (from INITIALIZED to RUNNING).

IStateful::start

Definition at line 197 of file AthSequencer.cxx.

{
  StatusCode sc(StatusCode::SUCCESS);
  // Loop over all sub-algorithms
  for (Gaudi::Algorithm* theAlgorithm : *subAlgorithms()) {
    if (!theAlgorithm->sysStart( ).isSuccess()) {
      ATH_MSG_ERROR ("Unable to start Algorithm "
                     << theAlgorithm->type () << "/"
                     << theAlgorithm->name());
      sc = StatusCode::FAILURE;
    }
  }
  return sc;
}

stop()

StatusCode AthSequencer::stop ( )

overridevirtual

Stop (from RUNNING to INITIALIZED).

Definition at line 213 of file AthSequencer.cxx.

{
  StatusCode sc(StatusCode::SUCCESS);
  // Loop over all sub-algorithms if they are not disabled.
  for (Gaudi::Algorithm* theAlgorithm : *subAlgorithms()) {
    if (theAlgorithm->sysStop( ).isFailure()) {
      ATH_MSG_ERROR ("Unable to stop Algorithm "
                     << theAlgorithm->type () << "/"
                     << theAlgorithm->name());
      sc = StatusCode::FAILURE;
    }
  }
  return sc;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::updateVHKA ( Gaudi::Details::PropertyBase &  )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_clidSvc

ServiceHandle<IClassIDSvc> AthSequencer::m_clidSvc

private

Definition at line 204 of file AthSequencer.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_ignoreFilter

Gaudi::Property<bool> AthSequencer::m_ignoreFilter

private

Initial value:

{this, "IgnoreFilterPassed", false,
    "Always continue sequence ignoring filterPassed of member algorithms"}

Definition at line 184 of file AthSequencer.h.

m_maxPass

const unsigned int AthSequencer::m_maxPass {100}

private

Definition at line 207 of file AthSequencer.h.

m_modeOR

Gaudi::Property<bool> AthSequencer::m_modeOR

private

Initial value:

{this, "ModeOR", false,
    "Use OR logic instead of AND"}

Definition at line 181 of file AthSequencer.h.

m_names

Gaudi::Property<std::vector<std::string> > AthSequencer::m_names

private

Initial value:

{this, "Members",{},
    "Algorithm names (of the form '<cppType>/<instanceName>')","SubAlgorithm"}

Definition at line 178 of file AthSequencer.h.

m_runPostInitialize

Gaudi::Property<bool> AthSequencer::m_runPostInitialize

private

Initial value:

{this, "ProcessDynamicDataDependencies", false,
     "Run the post initialization step, to dynamically create and gather extra data dependencies. "
     "Should be enabled for the top most sequence."}

Definition at line 200 of file AthSequencer.h.

m_sequential

Gaudi::Property<bool> AthSequencer::m_sequential

private

Initial value:

{this, "Sequential", false,
    "Concurrent or (strict) Sequential ordering of algorithms"}

Definition at line 190 of file AthSequencer.h.

m_stopOverride

Gaudi::Property<bool> AthSequencer::m_stopOverride

private

Initial value:

{this, "StopOverride", false,
    "Continue even if algorithm filter fails"}

Definition at line 187 of file AthSequencer.h.

m_timeout

Gaudi::Property<double> AthSequencer::m_timeout

private

Initial value:

{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"}

Definition at line 193 of file AthSequencer.h.

m_timeoutMilliseconds

unsigned int AthSequencer::m_timeoutMilliseconds {0}

private

timeout converted to ms

Definition at line 206 of file AthSequencer.h.

m_undeclaredOutputData

Gaudi::Property<std::vector<std::string> > AthSequencer::m_undeclaredOutputData

private

Initial value:

{this, "ExtraDataForDynamicConsumers", {},
    "Pass these extra output data IDs, which are not declared by any of the algorithms or tools, to dynamic data consumers."}

Definition at line 197 of file AthSequencer.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

The documentation for this class was generated from the following files:

• AthSequencer.h
• AthSequencer.cxx