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)
virtual	~AthSequencer ()
	Destructor.
virtual StatusCode	initialize () override
	Initialization of a sequencer.
virtual StatusCode	reinitialize () override
	AthSequencer Reinitialization.
virtual StatusCode	execute (const EventContext &ctx) const override
	The actions to be performed by the sequencer on an event.
virtual StatusCode	start () override
	Start (from INITIALIZED to RUNNING).
virtual StatusCode	stop () override
	Stop (from RUNNING to INITIALIZED).
virtual void	resetExecuted (const EventContext &ctx) const
	Reset the AthSequencer executed state for the current event.
virtual bool	isStopOverride () const
	Has the StopOverride mode been set?
StatusCode	append (Gaudi::Algorithm *pAlgorithm)
	Append an algorithm to the sequencer.
StatusCode	createAndAppend (const std::string &type, const std::string &name, Gaudi::Algorithm *&pAlgorithm)
	Create a algorithm and append it to the sequencer.
StatusCode	remove (Gaudi::Algorithm *pAlgorithm)
	Remove the specified algorithm from the sequencer.
StatusCode	remove (const std::string &name)
StatusCode	decodeMemberNames ()
	Decode Member Name list.
void	membershipHandler (Gaudi::Details::PropertyBase &theProp)
	"Members" property handler
StatusCode	decodeBranchMemberNames ()
	Decode branch member naem list.
void	branchMembershipHandler (Gaudi::Details::PropertyBase &theProp)
	"BranchMembers" propertry handler
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () 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.
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.
StatusCode	decodeNames (Gaudi::Property< std::vector< std::string > > &theNames, std::vector< Gaudi::Algorithm * > *theAlgs)
	Decode algorithm names, creating or appending algorithms as appropriate.
StatusCode	remove (const std::string &algname, std::vector< Gaudi::Algorithm * > *theAlgs)
	Remove the specified algorithm from the sequencer.
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	executeAlgorithm (Gaudi::Algorithm *theAlgorithm, const EventContext &ctx) const
	Run one algorithm.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
Gaudi::Property< std::vector< std::string > >	m_names
Gaudi::Property< bool >	m_modeOR
Gaudi::Property< bool >	m_ignoreFilter
Gaudi::Property< bool >	m_invert
Gaudi::Property< bool >	m_stopOverride
Gaudi::Property< bool >	m_sequential
Gaudi::Property< std::vector< std::string > >	m_undeclaredOutputData
Gaudi::Property< bool >	m_runPostInitialize
ServiceHandle< IClassIDSvc >	m_clidSvc
const unsigned int	m_maxPass {100}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
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 27 of file AthSequencer.cxx.

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

~AthSequencer()

AthSequencer::~AthSequencer ( )

virtual

Destructor.

Definition at line 38 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 224 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 267 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 230 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 287 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()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & 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());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::declareProperty ( Gaudi::Property< T, V, H > & 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 250 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 303 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()

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; }

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 98 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();
            if ( m_invert ) {
              state.setFilterPassed( !passed );
            } else {
              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() ) {
    if ( m_invert ) {
      state.setFilterPassed( !seqPass );
    } else {
      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 166 of file AthSequencer.cxx.

{
  // Call the sysExecute() of the method the algorithm
  return theAlgorithm->sysExecute( ctx );
}

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 42 of file AthSequencer.cxx.

{
  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 218 of file AthSequencer.cxx.

{
  return m_stopOverride.value( );
}

membershipHandler()

void AthSequencer::membershipHandler

(

Gaudi::Details::PropertyBase &

theProp

)

"Members" property handler

Definition at line 257 of file AthSequencer.cxx.

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

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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 75 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 375 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 244 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 238 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 206 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 174 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 190 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 203 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.

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

m_invert

Gaudi::Property<bool> AthSequencer::m_invert

private

Initial value:

{ this, "Invert", false,
    "Invert the logic result of the sequencer"}

Definition at line 187 of file AthSequencer.h.

                              { this, "Invert", false,
    "Invert the logic result of the sequencer"};

m_maxPass

const unsigned int AthSequencer::m_maxPass {100}

private

Definition at line 205 of file AthSequencer.h.

{100};      //<! maximum number of iterations to process dynamic data dependencies

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.

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

m_names

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

private

Initial value:

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

Definition at line 178 of file AthSequencer.h.

                                             {this, "Members",{},
    "Algorithm names (of the form '<cppType>/<instanceName>')","std::vector<Algorithm>"};

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 199 of file AthSequencer.h.

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

m_sequential

Gaudi::Property<bool> AthSequencer::m_sequential

private

Initial value:

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

Definition at line 193 of file AthSequencer.h.

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

m_stopOverride

Gaudi::Property<bool> AthSequencer::m_stopOverride

private

Initial value:

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

Definition at line 190 of file AthSequencer.h.

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

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 196 of file AthSequencer.h.

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

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