A Sequencer is essentially a list of Algorithms and is responsible for their management. More...

#include </builds/gaudi/Gaudi/GaudiKernel/include/Gaudi/Sequencer.h>

Inheritance diagram for Gaudi::Sequencer:

[legend]

Collaboration diagram for Gaudi::Sequencer:

[legend]

Public Member Functions
StatusCode	initialize () override
	Initialization of a sequencer.

StatusCode	reinitialize () override
	Sequencer Reinitialization.

StatusCode	start () override
	Sequencer finalization.

StatusCode	execute (const EventContext &ctx) const override
	The actions to be performed by the sequencer on an event.

StatusCode	stop () override
	Sequencer stop.

StatusCode	finalize () override
	Sequencer finalization.

bool	branchFilterPassed (const EventContext &ctx) const
	Was the branch filter passed for the last event?

void	setBranchFilterPassed (const EventContext &ctx, bool state) const
	Set the branch filter passed flag for the last event.

StatusCode	append (Gaudi::Algorithm *pAlgorithm)
	Append an algorithm to the sequencer.

StatusCode	appendToBranch (Gaudi::Algorithm *pAlgorithm)
	Append an algorithm to the sequencer branch.

StatusCode	createAndAppend (const std::string &type, const std::string &name, Gaudi::Algorithm *&pAlgorithm)
	Create a algorithm and append it to the sequencer.

StatusCode	createAndAppendToBranch (const std::string &type, const std::string &name, Gaudi::Algorithm *&pAlgorithm)
	Create a algorithm and append it to the sequencer branch.

StatusCode	remove (Gaudi::Algorithm *pAlgorithm)
	Remove the specified algorithm from the sequencer.

StatusCode	remove (const std::string &name)

StatusCode	removeFromBranch (Gaudi::Algorithm *pAlgorithm)

StatusCode	removeFromBranch (const std::string &name)

const std::vector< Gaudi::Algorithm * > &	branchAlgorithms () const
	List of branch algorithms.

std::vector< Gaudi::Algorithm * > &	branchAlgorithms ()

StatusCode	decodeMemberNames ()
	Decode Member Name list.

StatusCode	decodeBranchMemberNames ()
	Decode branch member name list.

std::ostream &	toControlFlowExpression (std::ostream &os) const override
	Produce string representation of the control flow expression.

Public Member Functions inherited from Gaudi::Sequence
bool	isSequence () const override final
	Are we a Sequence?

StatusCode	createSubAlgorithm (const std::string &type, const std::string &name, Algorithm *&pSubAlg)
	Create a sub algorithm.

const std::vector< Algorithm * > *	subAlgorithms () const
	List of sub-algorithms. Returns a pointer to a vector of (sub) Algorithms.

std::vector< Algorithm * > *	subAlgorithms ()
	List of sub-algorithms. Returns a pointer to a vector of (sub) Algorithms.

StatusCode	start () override
	System start.

StatusCode	initialize () override
	Initialization method invoked by the framework.

StatusCode	reinitialize () override
	Reinitialization method invoked by the framework.

StatusCode	restart () override
	Restart method invoked by the framework.

StatusCode	stop () override
	System stop.

StatusCode	finalize () override
	System finalization.

void	acceptDHVisitor (IDataHandleVisitor *) const override

	Algorithm (std::string name, ISvcLocator *svcloc, std::string version=PACKAGE_VERSION)
	Constructor.

Public Member Functions inherited from Gaudi::Algorithm
	Algorithm (std::string name, ISvcLocator *svcloc, std::string version=PACKAGE_VERSION)
	Constructor.

StatusCode	sysStart () override
	Reinitialization method invoked by the framework.

StatusCode	sysInitialize () override
	Initialization method invoked by the framework.

StatusCode	sysReinitialize () override
	Reinitialization method invoked by the framework.

StatusCode	sysRestart () override
	Restart method invoked by the framework.

StatusCode	sysExecute (const EventContext &ctx) override
	The actions to be performed by the algorithm on an event.

StatusCode	sysStop () override
	System stop.

StatusCode	sysFinalize () override
	System finalization.

const std::string &	name () const override
	The identifying name of the algorithm object.

const Gaudi::StringKey &	nameKey () const override

const std::string &	type () const override
	The type of the algorithm object.

void	setType (std::string type) override

const std::string &	version () const override

unsigned int	index () const override

StatusCode	configure () override
	Dummy implementation of IStateful::configure() method.

StatusCode	terminate () override
	Dummy implementation of IStateful::terminate() method.

StatusCode	initialize () override
	the default (empty) implementation of IStateful::initialize() method

StatusCode	start () override
	the default (empty) implementation of IStateful::start() method

StatusCode	stop () override
	the default (empty) implementation of IStateful::stop() method

StatusCode	finalize () override
	the default (empty) implementation of IStateful::finalize() method

StatusCode	reinitialize () override
	the default (empty) implementation of IStateful::reinitialize() method

StatusCode	restart () override
	the default (empty) implementation of IStateful::restart() method

Gaudi::StateMachine::State	FSMState () const override
	returns the current state of the algorithm

Gaudi::StateMachine::State	targetFSMState () const override
	returns the state the algorithm will be in after the ongoing transition

bool	isEnabled () const override
	Is this algorithm enabled or disabled?

bool	isSequence () const override
	Are we a Sequence?

unsigned int	errorCount () const
	Get the number of failures of the algorithm.

SmartIF< IService >	service (std::string_view name, const bool createIf=true, const bool quiet=false) const
	Return a pointer to the service identified by name (or "type/name")

template<class T>
SmartIF< T >	service (std::string_view name, bool createIf=true, bool quiet=false) const

SmartIF< IAuditorSvc > &	auditorSvc () const
	The standard auditor service.May not be invoked before sysInitialize() has been invoked.

SmartIF< IChronoStatSvc > &	chronoSvc () const
	The standard Chrono & Stat service, Return a pointer to the service if present.

SmartIF< IDataProviderSvc > &	detSvc () const
	The standard detector data service.

SmartIF< IConversionSvc > &	detCnvSvc () const
	The standard detector data persistency conversion service.

SmartIF< IDataProviderSvc > &	eventSvc () const
	The standard event data service.

SmartIF< IDataProviderSvc > &	evtSvc () const
	shortcut for method eventSvc

SmartIF< IConversionSvc > &	eventCnvSvc () const
	The standard event data persistency conversion service.

SmartIF< IHistogramSvc > &	histoSvc () const
	The standard histogram service.

SmartIF< INTupleSvc > &	ntupleSvc () const
	The standard N tuple service.

SmartIF< IRndmGenSvc > &	randSvc () const
	The standard RandomGen service, Return a pointer to the service if present.

SmartIF< IToolSvc > &	toolSvc () const
	The standard ToolSvc service, Return a pointer to the service if present.

SmartIF< IExceptionSvc > &	exceptionSvc () const
	Get the exception Service.

SmartIF< IAlgContextSvc > &	contextSvc () const
	get Algorithm Context Service

SmartIF< ITimelineSvc > &	timelineSvc () const

SmartIF< ISvcLocator > &	serviceLocator () const override
	The standard service locator.

SmartIF< ISvcLocator > &	svcLoc () const
	shortcut for method serviceLocator

SmartIF< IHiveWhiteBoard > &	whiteboard () const

SmartIF< IAlgExecStateSvc > &	algExecStateSvc () const

bool	registerContext () const
	register for Algorithm Context Service?

template<class T>
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, ToolHandle< T > &hndl, const std::string &doc="none")

template<class T>
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, ToolHandleArray< T > &hndlArr, const std::string &doc="none")

SmartIF< IMonitorSvc > &	monitorSvc () const
	Access the monitor service.

template<class T>
void	declareInfo (const std::string &name, const T &var, const std::string &desc) const
	Declare monitoring information.

void	declareInfo (const std::string &name, const std::string &format, const void *var, int size, const std::string &desc) const
	Declare monitoring information (special case)

void	acceptDHVisitor (IDataHandleVisitor *) const override

void	registerTool (IAlgTool *tool) const

void	deregisterTool (IAlgTool *tool) const

template<class T>
StatusCode	declareTool (ToolHandle< T > &handle, bool createIf=true)

template<class T>
StatusCode	declareTool (ToolHandle< T > &handle, const std::string &toolTypeAndName, bool createIf=true)

template<class T>
void	addToolsArray (ToolHandleArray< T > &hndlArr)

const std::vector< IAlgTool * > &	tools () const

bool	isAsynchronous () const

void	setAsynchronous (bool value)

unsigned int	cardinality () const override
	Return the cardinality.

const std::vector< std::string > &	neededResources () const override

AlgExecStateRef	execState (const EventContext &ctx) const override
	get the AlgExecStateRef of current algorithm Actually a small wrapper around it, thus the plain object return type

std::ostream &	toControlFlowExpression (std::ostream &os) const override
	Produce string represention of the control flow expression.

Public Member Functions inherited from DataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > > >
std::vector< Gaudi::DataHandle * >	inputHandles () const override

std::vector< Gaudi::DataHandle * >	outputHandles () const override

virtual const DataObjIDColl &	extraInputDeps () const override

virtual const DataObjIDColl &	extraOutputDeps () const override

void	declare (Gaudi::DataHandle &handle) override

void	renounce (Gaudi::DataHandle &handle) override

bool	renounceInput (const DataObjID &id) override

const DataObjIDColl &	inputDataObjs () const override

const DataObjIDColl &	outputDataObjs () const override

void	addDependency (const DataObjID &id, const Gaudi::DataHandle::Mode &mode) override

Public Member Functions inherited from extends< PropertyHolder< CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > >, IDataHandleHolder >
void const *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast.

StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface.

std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames.

Public Member Functions inherited from PropertyHolder< CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > >
StatusCode	setProperty (const Gaudi::Details::PropertyBase &p)
	Set the property from a property.

StatusCode	setProperty (const std::string &name, const char *v)
	Special case for string literals.

StatusCode	setProperty (const std::string &name, const std::string &v)
	Special case for std::string.

StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value

	PropertyHolder ()=default

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Details::PropertyBase &prop)
	Declare a property.

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, TYPE &value, const std::string &doc="none")
	Helper to wrap a regular data member and use it as a regular property.

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, Gaudi::Property< TYPE, VERIFIER, HANDLERS > &prop, const std::string &doc="none")
	Declare a PropertyBase instance setting name and documentation.

Gaudi::Details::PropertyBase *	declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="")
	Declare a remote property.

StatusCode	setProperty (const std::string &name, const Gaudi::Details::PropertyBase &p) override
	set the property from another property with a different name

StatusCode	setProperty (const std::string &s) override
	set the property from the formatted string

StatusCode	setProperty (const Gaudi::Details::PropertyBase &p)
	Set the property from a property.

StatusCode	setProperty (const std::string &name, const char *v)
	Special case for string literals.

StatusCode	setProperty (const std::string &name, const std::string &v)
	Special case for std::string.

StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value

StatusCode	setPropertyRepr (const std::string &n, const std::string &r) override
	set the property from name and value string representation

StatusCode	getProperty (Gaudi::Details::PropertyBase *p) const override
	get the property

const Gaudi::Details::PropertyBase &	getProperty (std::string_view name) const override
	get the property by name

StatusCode	getProperty (std::string_view n, std::string &v) const override
	convert the property to the string

const std::vector< Gaudi::Details::PropertyBase * > &	getProperties () const override
	get all properties

bool	hasProperty (std::string_view name) const override
	Return true if we have a property with the given name.

Gaudi::Details::PropertyBase *	property (std::string_view name) const
	\fixme property and bindPropertiesTo should be protected

void	bindPropertiesTo (Gaudi::Interfaces::IOptionsSvc &optsSvc)

	PropertyHolder (const PropertyHolder &)=delete

PropertyHolder &	operator= (const PropertyHolder &)=delete

Public Member Functions inherited from CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > >
MSG::Level	msgLevel () const
	get the cached level (originally extracted from the embedded MsgStream)

bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream

Public Member Functions inherited from CommonMessagingBase
virtual	~CommonMessagingBase ()=default
	Virtual destructor.

const SmartIF< IMessageSvc > &	msgSvc () const
	The standard message service.

MsgStream &	msgStream () const
	Return an uninitialized MsgStream.

MsgStream &	msgStream (const MSG::Level level) const
	Predefined configurable message stream for the efficient printouts.

MsgStream &	always () const
	shortcut for the method msgStream(MSG::ALWAYS)

MsgStream &	fatal () const
	shortcut for the method msgStream(MSG::FATAL)

MsgStream &	err () const
	shortcut for the method msgStream(MSG::ERROR)

MsgStream &	error () const
	shortcut for the method msgStream(MSG::ERROR)

MsgStream &	warning () const
	shortcut for the method msgStream(MSG::WARNING)

MsgStream &	info () const
	shortcut for the method msgStream(MSG::INFO)

MsgStream &	debug () const
	shortcut for the method msgStream(MSG::DEBUG)

MsgStream &	verbose () const
	shortcut for the method msgStream(MSG::VERBOSE)

MsgStream &	msg () const
	shortcut for the method msgStream(MSG::INFO)

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, std::vector< bool > &theLogic)
	Decode algorithm names, creating or appending algorithms as appropriate.

StatusCode	execute (const EventContext &ctx, const std::vector< Gaudi::Algorithm * > &theAlgs, const std::vector< bool > &theLogic, Gaudi::Algorithm *&lastAlgorithm, std::size_t first=0) const
	Execute the members in the specified list.

StatusCode	executeMember (Gaudi::Algorithm *theAlgorithm, const EventContext &context) const
	Execute member algorithm.

StatusCode	remove (const std::string &algname, std::vector< Gaudi::Algorithm * > &theAlgs)
	Remove the specified algorithm from the sequencer.

	Sequencer (const Sequencer &a)=delete

Sequencer &	operator= (const Sequencer &rhs)=delete

Protected Member Functions inherited from Gaudi::Algorithm
std::vector< IAlgTool * > &	tools ()

bool	isInitialized () const override
	Has the Algorithm already been initialized?

bool	isFinalized () const override
	Has the Algorithm already been finalized?

void	setIndex (const unsigned int &idx) override
	set instantiation index of Alg

bool	isReEntrant () const override

Protected Member Functions inherited from DataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > > >
void	initDataHandleHolder ()
	initializes all handles - called by the sysInitialize method of any descendant of this

Protected Member Functions inherited from CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > >
MSG::Level	setUpMessaging () const
	Set up local caches.

MSG::Level	resetMessaging ()
	Reinitialize internal states.

void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream.

Private Attributes
Gaudi::Property< std::vector< std::string > >	m_names

Gaudi::Property< std::vector< std::string > >	m_branchNames

Gaudi::Property< bool >	m_shortCircuit { this, "ShortCircuit", true, "stop processing as soon as possible" }

Gaudi::Property< bool >	m_sequential { this, "Sequential", false, "execute members one at a time" }

Gaudi::Property< bool >	m_modeOR { this, "ModeOR", false, "use OR logic instead of AND" }

Gaudi::Property< bool >	m_ignoreFilter { this, "IgnoreFilterPassed", false, "always continue" }

Gaudi::Property< bool >	m_invert { this, "Invert", false, "invert the logic result of the sequencer" }

Gaudi::Property< std::vector< std::string > >	m_vetoObjs

Gaudi::Property< std::vector< std::string > >	m_requireObjs

std::vector< bool >	m_isInverted

std::vector< Gaudi::Algorithm * >	m_branchAlgs

std::vector< bool >	m_isBranchInverted

std::mutex	m_branchFilterMutex

std::map< EventContext::ContextID_t, bool >	m_branchFilterPassed

Additional Inherited Members
Public Types inherited from Gaudi::Algorithm
typedef Gaudi::PluginService::Factory< IAlgorithm (const std::string &, ISvcLocator )>	Factory

Public Types inherited from extends< PropertyHolder< CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > >, IDataHandleHolder >
using	base_class
	Typedef to this class.

using	extend_interfaces_base
	Typedef to the base of this class.

Public Types inherited from PropertyHolder< CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > >
using	PropertyHolderImpl
	Typedef used to refer to this class from derived classes, as in.

Public Types inherited from CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > >
using	base_class

Public Types inherited from extend_interfaces< Interfaces... >
using	ext_iids
	take union of the ext_iids of all Interfaces...

Public Attributes inherited from Gaudi::Algorithm
friend	AlgorithmManager

Protected Attributes inherited from Gaudi::Algorithm
std::unique_ptr< IDataHandleVisitor >	m_updateDataHandles
	Hook for for derived classes to provide a custom visitor for data handles.

Protected Attributes inherited from DataHandleHolderBase< PropertyHolder< CommonMessaging< implements< IAlgorithm, IDataHandleHolder, IProperty, IStateful > > > >
DataObjIDColl	m_inputDataObjs

DataObjIDColl	m_outputDataObjs

Detailed Description

A Sequencer 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 Sequencer assumes the same filtered state as the last member.

Definition at line 28 of file Sequencer.h.

Constructor & Destructor Documentation

◆ Sequencer()

Gaudi::Sequencer::Sequencer ( const Sequencer & a )

protecteddelete

Member Function Documentation

◆ append() [1/2]

StatusCode Gaudi::Sequencer::append ( Gaudi::Algorithm * pAlgorithm )

Append an algorithm to the sequencer.

Definition at line 161 of file Sequencer.cpp.

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

Gaudi::Sequence::subAlgorithms

const std::vector< Algorithm * > * subAlgorithms() const

List of sub-algorithms. Returns a pointer to a vector of (sub) Algorithms.

Definition Sequence.cpp:105

Gaudi::Sequencer::append

StatusCode append(Gaudi::Algorithm *pAlgorithm)

Append an algorithm to the sequencer.

Definition Sequencer.cpp:161

◆ append() [2/2]

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

protected

Append an algorithm to the sequencer.

Protected Member Functions.

Definition at line 205 of file Sequencer.cpp.

                                                                                                {
    // Check that the specified algorithm doesn't already exist in the membership list
    if ( std::find( std::begin( theAlgs ), std::end( theAlgs ), pAlgorithm ) != std::end( theAlgs ) ) {
      return StatusCode::FAILURE;
    }
    theAlgs.push_back( pAlgorithm );
    pAlgorithm->addRef();
    return StatusCode::SUCCESS;
  }

◆ appendToBranch()

StatusCode Gaudi::Sequencer::appendToBranch ( Gaudi::Algorithm * pAlgorithm )

Append an algorithm to the sequencer branch.

Definition at line 163 of file Sequencer.cpp.

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

◆ branchAlgorithms() [1/2]

std::vector< Gaudi::Algorithm * > & Gaudi::Sequencer::branchAlgorithms ( )

Definition at line 189 of file Sequencer.cpp.

189{ return m_branchAlgs; }

Gaudi::Sequencer::m_branchAlgs

std::vector< Gaudi::Algorithm * > m_branchAlgs

Definition Sequencer.h:204

◆ branchAlgorithms() [2/2]

const std::vector< Gaudi::Algorithm * > & Gaudi::Sequencer::branchAlgorithms ( ) const

List of branch algorithms.

These are the algorithms that would get executed if a filter algorithm indicated a failure. The branch is located within the main sequence by the first element, which is the filter algorithm.

Definition at line 187 of file Sequencer.cpp.

187{ return m_branchAlgs; }

◆ branchFilterPassed()

bool Gaudi::Sequencer::branchFilterPassed ( const EventContext & ctx ) const

Was the branch filter passed for the last event?

Definition at line 151 of file Sequencer.cpp.

                                                                    {
    auto lock = std::scoped_lock{ m_branchFilterMutex };
    return m_branchFilterPassed[ctx.slot()];
  }

◆ createAndAppend() [1/2]

StatusCode Gaudi::Sequencer::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 167 of file Sequencer.cpp.

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

◆ createAndAppend() [2/2]

StatusCode Gaudi::Sequencer::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 215 of file Sequencer.cpp.

                                                                                                            {
    auto theAlgMgr = serviceLocator()->service<IAlgManager>( "ApplicationMgr" );
    if ( !theAlgMgr ) return StatusCode::FAILURE;
 
    IAlgorithm* tmp;
    StatusCode  result = theAlgMgr->createAlgorithm( type, algName, tmp );
    if ( result.isSuccess() ) {
      try {
        pAlgorithm = dynamic_cast<Gaudi::Algorithm*>( tmp );
        theAlgs.push_back( pAlgorithm );
      } catch ( ... ) {
        error() << "Unable to create Algorithm " << algName << endmsg;
        result = StatusCode::FAILURE;
      }
    }
 
    return result;
  }

◆ createAndAppendToBranch()

StatusCode Gaudi::Sequencer::createAndAppendToBranch	(	const std::string &	type,
		const std::string &	name,
		Gaudi::Algorithm *&	pAlgorithm )

Create a algorithm and append it to the sequencer branch.

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 172 of file Sequencer.cpp.

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

◆ decodeBranchMemberNames()

StatusCode Gaudi::Sequencer::decodeBranchMemberNames ( )

Decode branch member name list.

Definition at line 196 of file Sequencer.cpp.

                                                {
    // Decode the branch membership list
    return decodeNames( m_branchNames, branchAlgorithms(), m_isBranchInverted );
  }

◆ decodeMemberNames()

StatusCode Gaudi::Sequencer::decodeMemberNames ( )

Decode Member Name list.

Definition at line 191 of file Sequencer.cpp.

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

◆ decodeNames()

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

protected

Decode algorithm names, creating or appending algorithms as appropriate.

Definition at line 235 of file Sequencer.cpp.

                                                                                                      {
    StatusCode result;
    auto       theAlgMgr = serviceLocator()->service<IAlgManager>( "ApplicationMgr" );
    if ( theAlgMgr ) {
      // Clear the existing list of algorithms
      theAlgs.clear();
 
      // Build the list of member algorithms from the contents of the
      // theNames list.
      for ( const auto& n : theNames.value() ) {
 
        // Parse the name for a syntax of the form:
        //
        // <type>/<name>
        //
        // Where <name> is the algorithm instance name, and <type> is the
        // algorithm class type (being a subclass of Algorithm).
        const Gaudi::Utils::TypeNameString typeName( n );
        std::string                        theName = typeName.name();
        std::string                        theType = typeName.type();
 
        // Parse the name for a syntax of the form:
        //
        // <name>:invert
        //
        // Where <name> is the algorithm instance name and ":invert"
        // indicates that the filter passed logic is inverted.
        bool                   isInverted = false;
        std::string::size_type invert     = theName.find_first_of( ":" );
        // Skip all occurrences of "::" (allow namespaces)
        while ( std::string::npos != invert && invert < ( theName.size() - 1 ) && theName[invert + 1] == ':' )
          invert = theName.find_first_of( ":", invert + 2 );
        if ( std::string::npos != invert ) {
          if ( theName == theType ) {
            // This means that we got something like "Type:invert",
            // so we have to strip the ":invert" from the type too.
            theType = theType.substr( 0, invert );
          }
          theName    = theName.substr( 0, invert );
          isInverted = true;
        }
        // Check whether the supplied name corresponds to an existing
        // Algorithm object.
        SmartIF<IAlgorithm>& theIAlg      = theAlgMgr->algorithm( theName, false );
        Gaudi::Algorithm*    theAlgorithm = nullptr;
        StatusCode           status       = StatusCode::SUCCESS;
        if ( theIAlg ) {
          try {
            theAlgorithm = dynamic_cast<Gaudi::Algorithm*>( theIAlg.get() );
          } catch ( ... ) {
            warning() << theName << " is not an Algorithm - Failed dynamic cast" << endmsg;
            theAlgorithm = nullptr; // release
          }
        }
        if ( theAlgorithm ) {
 
          // The specified Algorithm already exists - just append it to the membership list.
          status = append( theAlgorithm, theAlgs );
          if ( status.isSuccess() ) {
            ON_DEBUG debug() << theName << " already exists - appended to member list" << endmsg;
          } else {
            warning() << theName << " already exists - append failed!!!" << endmsg;
            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.
          status = createAndAppend( theType, theName, theAlgorithm, theAlgs );
          if ( status.isSuccess() ) {
            ON_DEBUG debug() << theName << " doesn't exist - created and appended to member list" << endmsg;
          } else {
            warning() << theName << " doesn't exist - creation failed!!!" << endmsg;
            result = StatusCode::FAILURE;
          }
        }
        if ( status.isSuccess() ) theLogic.push_back( isInverted );
      }
    }
    // Print membership list
    if ( result.isSuccess() && theAlgs.size() != 0 ) {
      info() << "Member list: ";
      auto ai = theAlgs.begin();
      auto li = theLogic.begin();
      for ( ; ai != theAlgs.end(); ++ai, ++li ) {
 
        if ( ai != theAlgs.begin() ) info() << ", ";
        auto alg = *ai;
        if ( alg->name() == System::typeinfoName( typeid( *alg ) ) )
          info() << alg->name();
        else
          info() << System::typeinfoName( typeid( *alg ) ) << "/" << alg->name();
 
        if ( *li ) info() << ":invert";
      }
      info() << endmsg;
    }
    return result;
  }

◆ execute() [1/2]

StatusCode Gaudi::Sequencer::execute ( const EventContext & ctx ) const

override

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

Definition at line 71 of file Sequencer.cpp.

                                                               {
    StatusCode result = StatusCode::SUCCESS;
    ON_DEBUG   debug() << name() << " Sequencer::execute()" << endmsg;
 
    auto state = execState( ctx );
 
    // Bypass the loop if this sequencer is disabled or has already been executed
    if ( isEnabled() && !( state.state() == AlgExecState::Done ) ) {
      Gaudi::Algorithm* lastAlgorithm;
      result = execute( ctx, *subAlgorithms(), m_isInverted, lastAlgorithm );
      if ( result.isSuccess() ) {
        const bool passed = state.filterPassed();
        if ( !passed && m_shortCircuit ) {
 
          // Filter failed and stop override not set. Execute the
          // branch if there is one associated with the filter
          // algorithm that failed. Note that the first member on
          // the branch is the failing algorithm and so should
          // be skipped.
          const auto& theAlgs = branchAlgorithms();
          if ( !theAlgs.empty() ) {
            Gaudi::Algorithm* branchAlgorithm = theAlgs[0];
            if ( lastAlgorithm == branchAlgorithm ) {
 
              // Branch specified - Loop over branch members
              result = execute( ctx, branchAlgorithms(), m_isBranchInverted, lastAlgorithm, 1 );
              if ( result.isSuccess() ) {
 
                // The final filter passed state will be set true if either
                // of the main or branches passed, otherwise false.
 
                // Save the branch  filter passed state.
                setBranchFilterPassed( ctx, state.filterPassed() );
              }
            }
          }
        }
      }
 
      // Prevent multiple executions of this sequencer for the current event
      state.setState( AlgExecState::Done );
    }
    return result;
  }

◆ execute() [2/2]

StatusCode Gaudi::Sequencer::execute	(	const EventContext &	ctx,
		const std::vector< Gaudi::Algorithm * > &	theAlgs,
		const std::vector< bool > &	theLogic,
		Gaudi::Algorithm *&	lastAlgorithm,
		std::size_t	first = 0 ) const

protected

Execute the members in the specified list.

Definition at line 336 of file Sequencer.cpp.

                                                         {
    StatusCode result = StatusCode::SUCCESS;
 
    auto state = execState( ctx );
    state.setFilterPassed( !m_modeOR ); //  for OR, result will be false, unless (at least) one is true
                                        //  for AND, result will be true, unless (at least) one is false
                                        //    also see comment below ....)
 
    // Reset the branch filter passed flag
    setBranchFilterPassed( ctx, false );
 
    auto exists = [&]( const std::string_view loc ) -> bool {
      DataObject* tmp{ nullptr };
      return evtSvc()->retrieveObject( loc, tmp ).isSuccess();
    };
 
    // Do not execute if one or more of the m_vetoObjs exist in TES
    if ( const auto it = find_if( begin( m_vetoObjs ), end( m_vetoObjs ), exists ); it != end( m_vetoObjs ) ) {
      if ( msgLevel( MSG::DEBUG ) ) debug() << *it << " found, skipping event " << endmsg;
      return result;
    }
 
    // Execute if m_requireObjs is empty
    // or if one or more of the m_requireObjs exist in TES
    if ( !( m_requireObjs.empty() || any_of( begin( m_requireObjs ), end( m_requireObjs ), exists ) ) ) {
      return result;
    }
 
    // 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.
    auto size = theAlgs.size();
    for ( auto i = first; i < size; i++ ) {
      lastAlgorithm = theAlgs[i];
      result        = executeMember( lastAlgorithm, ctx );
      if ( result.isSuccess() ) {
        if ( !m_ignoreFilter ) {
          // Take the filter passed status of this algorithm as my own status.
          // Note that we take into account inverted logic.
          bool passed     = lastAlgorithm->execState( ctx ).filterPassed();
          bool isInverted = theLogic[i];
          if ( isInverted ) passed = !passed;
 
          // in OR mode, we don't care about things
          // which are false, as they leave our current state alone (provided
          // we stared as 'false'!), and in AND mode, we keep our current
          // state until someone returns 'false' (provided we started as 'true')
          if ( m_modeOR ? passed : !passed ) {
            state.setFilterPassed( m_modeOR );
            if ( m_shortCircuit ) { break; }
          }
        }
      } else {
        break;
      }
    }
    if ( m_invert ) state.setFilterPassed( !state.filterPassed() );
    return result;
  }

◆ executeMember()

StatusCode Gaudi::Sequencer::executeMember	(	Gaudi::Algorithm *	theAlgorithm,
		const EventContext &	context ) const

protected

Execute member algorithm.

Definition at line 399 of file Sequencer.cpp.

                                                                                                       {
    StatusCode result = StatusCode::SUCCESS;
    if ( theAlgorithm->isEnabled() ) {
      if ( theAlgorithm->execState( context ).state() != AlgExecState::Done ) {
        result = theAlgorithm->sysExecute( context );
      }
    }
    return result;
  }

◆ finalize()

StatusCode Gaudi::Sequencer::finalize ( )

override

Sequencer finalization.

Definition at line 116 of file Sequencer.cpp.

                                 {
    // Loop over all branch members calling their finalize functions
    // if they are not disabled. Note that the Sequence::finalize
    // function already does this for the main members.
    for ( auto& alg : branchAlgorithms() ) {
      if ( alg->sysFinalize().isFailure() ) { error() << "Unable to finalize Algorithm " << alg->name() << endmsg; }
    }
    return Sequence::finalize();
  }

◆ initialize()

StatusCode Gaudi::Sequencer::initialize ( )

override

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 28 of file Sequencer.cpp.

                                   {
    auto is_good = decodeMemberNames();
    if ( !is_good ) {
      error() << "Unable to configure one or more sequencer members " << endmsg;
      return is_good;
    }
 
    is_good = decodeBranchMemberNames();
    if ( !is_good ) {
      error() << "Unable to configure one or more branch members " << endmsg;
      return is_good;
    }
 
    // We have to "decode" members before calling base class initialize
    is_good = Sequence::initialize();
    if ( !is_good ) return is_good;
 
    // Loop over all branches
    // (Sequence does not know about branches)
    for ( auto& alg : branchAlgorithms() ) {
      is_good = alg->sysInitialize();
      if ( is_good.isFailure() ) {
        error() << "Unable to initialize Algorithm " << alg->name() << endmsg;
        return is_good;
      }
    }
 
    return is_good;
  }

◆ operator=()

Sequencer & Gaudi::Sequencer::operator= ( const Sequencer & rhs )

protecteddelete

◆ reinitialize()

StatusCode Gaudi::Sequencer::reinitialize ( )

override

Sequencer Reinitialization.

Definition at line 58 of file Sequencer.cpp.

                                     {
    // Bypass the loop if this sequencer is disabled
    if ( isEnabled() ) {
      // Loop over all branch members calling their reinitialize functions
      // if they are not disabled.
      for ( auto& alg : branchAlgorithms() ) {
        if ( alg->isEnabled() ) { alg->reinitialize().ignore(); }
      }
      return Sequence::reinitialize();
    }
    return StatusCode::SUCCESS;
  }

◆ remove() [1/3]

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

protected

Remove the specified algorithm from the sequencer.

Definition at line 409 of file Sequencer.cpp.

                                                                                              {
    StatusCode result = StatusCode::FAILURE;
 
    // Test that the algorithm exists in the member list
    for ( auto& alg : theAlgs ) {
      if ( alg->name() == algname ) {
 
        // Algorithm with specified name exists in the algorithm list - remove it
        // THIS ISN'T IMPLEMENTED YET!!!!
        info() << "Sequencer::remove( ) isn't implemented yet!!!!!" << endmsg;
        result = StatusCode::SUCCESS;
        break;
      }
    }
    return result;
  }

◆ remove() [2/3]

StatusCode Gaudi::Sequencer::remove ( const std::string & name )

Definition at line 179 of file Sequencer.cpp.

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

Gaudi::Sequencer::remove

StatusCode remove(Gaudi::Algorithm *pAlgorithm)

Remove the specified algorithm from the sequencer.

Definition Sequencer.cpp:177

◆ remove() [3/3]

StatusCode Gaudi::Sequencer::remove ( Gaudi::Algorithm * pAlgorithm )

Remove the specified algorithm from the sequencer.

Definition at line 177 of file Sequencer.cpp.

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

◆ removeFromBranch() [1/2]

StatusCode Gaudi::Sequencer::removeFromBranch ( const std::string & name )

Definition at line 185 of file Sequencer.cpp.

185{ return remove( algname, branchAlgorithms() ); }

◆ removeFromBranch() [2/2]

StatusCode Gaudi::Sequencer::removeFromBranch ( Gaudi::Algorithm * pAlgorithm )

Definition at line 181 of file Sequencer.cpp.

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

◆ setBranchFilterPassed()

void Gaudi::Sequencer::setBranchFilterPassed	(	const EventContext &	ctx,
		bool	state ) const

Set the branch filter passed flag for the last event.

Definition at line 156 of file Sequencer.cpp.

                                                                                   {
    auto lock                        = std::scoped_lock{ m_branchFilterMutex };
    m_branchFilterPassed[ctx.slot()] = state;
  }

◆ start()

StatusCode Gaudi::Sequencer::start ( )

override

Sequencer finalization.

Definition at line 126 of file Sequencer.cpp.

                              {
    auto is_good = Sequence::start();
    if ( !is_good ) return is_good;
 
    // Loop over all branches
    for ( auto& alg : branchAlgorithms() ) {
      is_good = alg->sysStart();
      if ( !is_good ) {
        error() << "Unable to start Algorithm " << alg->name() << endmsg;
        return is_good;
      }
    }
 
    return is_good;
  }

◆ stop()

StatusCode Gaudi::Sequencer::stop ( )

override

Sequencer stop.

Definition at line 142 of file Sequencer.cpp.

                             {
    // Loop over all branch members calling their finalize functions
    // if they are not disabled.
    for ( auto& alg : branchAlgorithms() ) {
      if ( alg->sysStop().isFailure() ) { error() << "Unable to stop Algorithm " << alg->name() << endmsg; }
    }
    return Sequence::stop();
  }

◆ toControlFlowExpression()

std::ostream & Gaudi::Sequencer::toControlFlowExpression ( std::ostream & os ) const

override

Produce string representation of the control flow expression.

Definition at line 426 of file Sequencer.cpp.

                                                                       {
    if ( m_invert ) os << '~';
 
    auto& theAlgs = *subAlgorithms();
    if ( theAlgs.empty() ) return os << ( ( !m_modeOR ) ? "CFTrue" : "CFFalse" );
 
    // if we have only one element, we do not need a name
    if ( theAlgs.size() > 1 ) os << "seq(";
 
    const auto algs_count = theAlgs.size();
    const auto op         = m_shortCircuit ? ( m_modeOR ? " | " : " & " ) : " >> ";
    size_t     i          = 0;
    while ( i < algs_count ) {
      if ( i ) os << op;
      if ( m_isInverted[i] ) os << '~';
      theAlgs[i]->toControlFlowExpression( os );
      ++i;
    }
    if ( theAlgs.size() > 1 ) os << ')';
    return os;
  }

Member Data Documentation

◆ m_branchAlgs

std::vector<Gaudi::Algorithm*> Gaudi::Sequencer::m_branchAlgs

private

Definition at line 204 of file Sequencer.h.

◆ m_branchFilterMutex

std::mutex Gaudi::Sequencer::m_branchFilterMutex

mutableprivate

Definition at line 207 of file Sequencer.h.

◆ m_branchFilterPassed

std::map<EventContext::ContextID_t, bool> Gaudi::Sequencer::m_branchFilterPassed

mutableprivate

Definition at line 208 of file Sequencer.h.

◆ m_branchNames

Gaudi::Property<std::vector<std::string> > Gaudi::Sequencer::m_branchNames

private

Initial value:

{ this,
                                                             "BranchMembers",
                                                             {},
                                                             [this]( auto& ) {
                                                               if ( this->isInitialized() )
                                                                 this->decodeBranchMemberNames().ignore();
                                                             },
                                                             "branch member names",
                                                             "vector<Algorithm>" }

Definition at line 182 of file Sequencer.h.

                                                     { this,
                                                             "BranchMembers",
                                                             {},
                                                             [this]( auto& ) {
                                                               if ( this->isInitialized() )
                                                                 this->decodeBranchMemberNames().ignore();
                                                             },
                                                             "branch member names",
                                                             "vector<Algorithm>" };

◆ m_ignoreFilter

Gaudi::Property<bool> Gaudi::Sequencer::m_ignoreFilter { this, "IgnoreFilterPassed", false, "always continue" }

private

Definition at line 195 of file Sequencer.h.

195{ this, "IgnoreFilterPassed", false, "always continue" };

◆ m_invert

Gaudi::Property<bool> Gaudi::Sequencer::m_invert { this, "Invert", false, "invert the logic result of the sequencer" }

private

Definition at line 196 of file Sequencer.h.

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

◆ m_isBranchInverted

std::vector<bool> Gaudi::Sequencer::m_isBranchInverted

private

Definition at line 205 of file Sequencer.h.

◆ m_isInverted

std::vector<bool> Gaudi::Sequencer::m_isInverted

private

Definition at line 203 of file Sequencer.h.

◆ m_modeOR

Gaudi::Property<bool> Gaudi::Sequencer::m_modeOR { this, "ModeOR", false, "use OR logic instead of AND" }

private

Definition at line 194 of file Sequencer.h.

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

◆ m_names

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

private

Initial value:

{ this,
                                                       "Members",
                                                       {},
                                                       [this]( auto& ) {
                                                         if ( this->isInitialized() )
                                                           this->decodeMemberNames().ignore();
                                                       },
                                                       "member names",
                                                       "vector<Algorithm>" }

Definition at line 173 of file Sequencer.h.

                                               { this,
                                                       "Members",
                                                       {},
                                                       [this]( auto& ) {
                                                         if ( this->isInitialized() )
                                                           this->decodeMemberNames().ignore();
                                                       },
                                                       "member names",
                                                       "vector<Algorithm>" };

◆ m_requireObjs

Gaudi::Property<std::vector<std::string> > Gaudi::Sequencer::m_requireObjs

private

Initial value:

{

this, "RequireObjects", {}, "execute only if one or more of these TES objects exist" }

Definition at line 200 of file Sequencer.h.

200 {

201 this, "RequireObjects", {}, "execute only if one or more of these TES objects exist" };

◆ m_sequential

Gaudi::Property<bool> Gaudi::Sequencer::m_sequential { this, "Sequential", false, "execute members one at a time" }

private

Definition at line 193 of file Sequencer.h.

193{ this, "Sequential", false, "execute members one at a time" };

◆ m_shortCircuit

Gaudi::Property<bool> Gaudi::Sequencer::m_shortCircuit { this, "ShortCircuit", true, "stop processing as soon as possible" }

private

Definition at line 192 of file Sequencer.h.

192{ this, "ShortCircuit", true, "stop processing as soon as possible" };

◆ m_vetoObjs

Gaudi::Property<std::vector<std::string> > Gaudi::Sequencer::m_vetoObjs

private

Initial value:

{

this, "VetoObjects", {}, "skip execute if one or more of these TES objects exist" }

Definition at line 198 of file Sequencer.h.

198 {

199 this, "VetoObjects", {}, "skip execute if one or more of these TES objects exist" };

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

GaudiKernel/include/Gaudi/Sequencer.h
GaudiKernel/src/Lib/Sequencer.cpp

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Sequencer()

Member Function Documentation

◆ append() [1/2]

◆ append() [2/2]

◆ appendToBranch()

◆ branchAlgorithms() [1/2]

◆ branchAlgorithms() [2/2]

◆ branchFilterPassed()

◆ createAndAppend() [1/2]

◆ createAndAppend() [2/2]

◆ createAndAppendToBranch()

◆ decodeBranchMemberNames()

◆ decodeMemberNames()

◆ decodeNames()

◆ execute() [1/2]

◆ execute() [2/2]

◆ executeMember()

◆ finalize()

◆ initialize()

◆ operator=()

◆ reinitialize()

◆ remove() [1/3]

◆ remove() [2/3]

◆ remove() [3/3]

◆ removeFromBranch() [1/2]

◆ removeFromBranch() [2/2]

◆ setBranchFilterPassed()

◆ start()

◆ stop()

◆ toControlFlowExpression()

Member Data Documentation

◆ m_branchAlgs

◆ m_branchFilterMutex

◆ m_branchFilterPassed

◆ m_branchNames

◆ m_ignoreFilter

◆ m_invert

◆ m_isBranchInverted

◆ m_isInverted

◆ m_modeOR

◆ m_names

◆ m_requireObjs

◆ m_sequential

◆ m_shortCircuit

◆ m_vetoObjs