Sequencer for executing several algorithms, stopping when one is faulty. More...

#include <GaudiAlg/GaudiSequencer.h>

Inheritance diagram for GaudiSequencer:

[legend]

Collaboration diagram for GaudiSequencer:

[legend]

Classes
class	AlgorithmEntry

Public Member Functions
StatusCode	initialize () override

StatusCode	execute (const EventContext &ctx) const override

StatusCode	sysExecute (const EventContext &ctx) override

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

template<typename U = PBASE, typename = std::enable_if_t<std::is_base_of_v<Gaudi::Algorithm, PBASE>, U>>
	GaudiCommon (std::string name, ISvcLocator *pSvcLocator)
	Standard constructor. More...

template<typename U = PBASE, typename = std::enable_if_t<std::is_base_of_v<AlgTool, PBASE>, U>>
	GaudiCommon (std::string type, std::string name, const IInterface *ancestor)
	Standard constructor. More...

	GaudiCommon ()=delete
	Standard constructor. More...

	GaudiCommon (const GaudiCommon &)=delete
	Standard constructor. More...

Public Member Functions inherited from GaudiCommon< Gaudi::Sequence >
Gaudi::Utils::GetData< TYPE >::return_type	get (IDataProviderSvc *svc, std::string_view location, const bool useRootInTES=true) const
	Templated access to the data in Gaudi Transient Store. More...

Gaudi::Utils::GetData< TYPE >::return_type	getIfExists (IDataProviderSvc *svc, std::string_view location, const bool useRootInTES=true) const
	Quicker version of the get function which bypasses the check on the retrieved data. More...

bool	exist (IDataProviderSvc *svc, std::string_view location, const bool useRootInTES=true) const
	Check the existence of a data object or container in the Gaudi Transient Event Store. More...

Gaudi::Utils::GetData< TYPE >::return_type	getOrCreate (IDataProviderSvc *svc, std::string_view location, const bool useRootInTES=true) const
	Get the existing data object from Gaudi Event Transient store. More...

DataObject *	put (IDataProviderSvc *svc, std::unique_ptr< DataObject > object, std::string_view location, const bool useRootInTES=true) const
	Register a data object or container into Gaudi Event Transient Store. More...

DataObject *	put (IDataProviderSvc svc, DataObject object, std::string_view location, const bool useRootInTES=true) const

TOOL *	tool (std::string_view type, std::string_view name, const IInterface *parent=0, bool create=true) const
	Useful method for the easy location of tools. More...

TOOL *	tool (std::string_view type, const IInterface *parent=0, bool create=true) const
	A useful method for the easy location of tools. More...

SmartIF< SERVICE >	svc (std::string_view name, const bool create=true) const
	A useful method for the easy location of services. More...

IUpdateManagerSvc *	updMgrSvc () const
	Short-cut to locate the Update Manager Service. More...

StatusCode	Error (std::string_view msg, const StatusCode st=StatusCode::FAILURE, const size_t mx=10) const
	Print the error message and return with the given StatusCode. More...

StatusCode	Warning (std::string_view msg, const StatusCode st=StatusCode::FAILURE, const size_t mx=10) const
	Print the warning message and return with the given StatusCode. More...

StatusCode	Info (std::string_view msg, const StatusCode st=StatusCode::SUCCESS, const size_t mx=10) const
	Print the info message and return with the given StatusCode. More...

StatusCode	Print (std::string_view msg, const StatusCode st=StatusCode::SUCCESS, const MSG::Level lev=MSG::INFO) const
	Print the message and return with the given StatusCode. More...

void	Assert (const bool ok, std::string_view message="", const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
	Assertion - throw exception if the given condition is not fulfilled. More...

void	Exception (std::string_view msg, const GaudiException &exc, const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
	Create and (re)-throw a given GaudiException. More...

void	Exception (std::string_view msg, const std::exception &exc, const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
	Create and (re)-throw a given exception. More...

void	Exception (std::string_view msg="no message", const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
	Create and throw an exception with the given message. More...

StatEntity &	counter (std::string_view tag) const
	accessor to certain counter by name More...

StatEntity &	counter (std::string_view tag)

bool	typePrint () const
	Insert the actual C++ type of the algorithm/tool in the messages ? More...

bool	propsPrint () const
	Print properties at initialization ? More...

bool	statPrint () const
	Print statistical counters at finalization ? More...

bool	errorsPrint () const
	Print error counters at finalization ? More...

long	printStat (const MSG::Level level=MSG::ALWAYS) const
	perform the actual printout of statistical counters More...

long	printErrors (const MSG::Level level=MSG::ALWAYS) const
	perform the actual printout of error counters More...

long	printProps (const MSG::Level level=MSG::ALWAYS) const
	perform the actual printout of properties More...

void	registerCondition (const std::string &condition, StatusCode(CallerClass::*mf)()=nullptr)
	register the current instance to the UpdateManagerSvc as a consumer for a condition. More...

void	registerCondition (const std::string &condition, CondType &condPtrDest, StatusCode(CallerClass::mf)()=NULL)
	register the current instance to the UpdateManagerSvc as a consumer for a condition. More...

void	registerCondition (char condition, StatusCode(CallerClass::mf)()=NULL)
	just to avoid conflicts with the version using a pointer to a template class. More...

void	registerCondition (TargetClass condition, StatusCode(CallerClass::mf)()=NULL)
	register the current instance to the UpdateManagerSvc as a consumer for a condition. More...

StatusCode	runUpdate ()
	asks the UpdateManagerSvc to perform an update of the instance (if needed) without waiting the next BeginEvent incident. More...

	GaudiCommon (std::string name, ISvcLocator *pSvcLocator)
	Algorithm constructor - the SFINAE constraint below ensures that this is constructor is only defined if PBASE derives from Algorithm. More...

	GaudiCommon (std::string type, std::string name, const IInterface *ancestor)
	Tool constructor - SFINAE-ed to insure this constructor is only defined if PBASE derives from AlgTool. More...

	GaudiCommon ()=delete

	GaudiCommon (const GaudiCommon &)=delete

StatusCode	initialize () override
	standard initialization method More...

StatusCode	finalize () override
	standard finalization method More...

GaudiCommon &	operator= (const GaudiCommon &)=delete

StatusCode	release (const IInterface *interface) const
	Manual forced (and 'safe') release of the active tool or service. More...

const Services &	services () const
	get the list of aquired services More...

const std::string &	context () const
	Returns the "context" string. Used to identify different processing states. More...

Public Member Functions inherited from FixTESPath< BASE >
template<typename U = BASE, typename = std::enable_if_t<std::is_base_of_v<Gaudi::Algorithm, BASE>, U>>
	FixTESPath (std::string name, ISvcLocator *pSvcLocator)
	Algorithm constructor - the SFINAE constraint below ensures that this is constructor is only defined if BASE derives from Algorithm. More...

template<typename U = BASE, typename = std::enable_if_t<std::is_base_of_v<AlgTool, BASE>, U>>
	FixTESPath (std::string type, std::string name, const IInterface *ancestor)
	Tool constructor - SFINAE-ed to insure this constructor is only defined if BASE derives from AlgTool. More...

StatusCode	initialize () override

const std::string &	rootInTES () const
	Returns the "rootInTES" string. More...

std::string	fullTESLocation (std::string_view location, bool useRootInTES) const
	Returns the full correct event location given the rootInTes settings. More...

Private Member Functions
StatusCode	decodeNames ()
	Decode a vector of string. More...

void	membershipHandler ()
	for asynchronous changes in the list of algorithms More...

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

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

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

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_measureTime = {this, "MeasureTime", false, "measure time"}

Gaudi::Property< bool >	m_returnOK = {this, "ReturnOK", false, "forces the sequencer to return a good status"}

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

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

std::vector< AlgorithmEntry >	m_entries
	List of algorithms to process. More...

ISequencerTimerTool *	m_timerTool = nullptr
	Pointer to the timer tool. More...

int	m_timer
	Timer number for the sequencer. More...

Additional Inherited Members
Protected Types inherited from GaudiCommon< Gaudi::Sequence >
using	base_class = FixTESPath< Gaudi::Sequence >

typedef std::map< std::string, StatEntity, std::less<> >	StatisticsOwn
	the actual type of general counters More...

typedef std::map< std::string, std::reference_wrapper< Gaudi::Accumulators::PrintableCounter >, std::less<> >	Statistics

typedef std::map< std::string, unsigned int, std::less<> >	Counter
	the actual type error/warning counter More...

typedef std::vector< IAlgTool * >	AlgTools
	storage for active tools More...

typedef std::vector< SmartIF< IService > >	Services
	storage for active services More...

Protected Member Functions inherited from GaudiCommon< Gaudi::Sequence >
StatusCode	releaseTool (const IAlgTool *tool) const
	manual forced (and 'safe') release of the tool More...

StatusCode	releaseSvc (const IInterface *svc) const
	manual forced (and 'safe') release of the service More...

Protected Attributes inherited from GaudiCommon< Gaudi::Sequence >
SmartIF< ICounterSummarySvc >	m_counterSummarySvc
	a pointer to the CounterSummarySvc More...

Static Protected Attributes inherited from GaudiCommon< Gaudi::Sequence >
static const bool	IgnoreRootInTES
	Simple definition to be used with the new useRootInTES argument get<TYPE> and put methods. More...

static const bool	UseRootInTES
	Simple definition to be used with the new useRootInTES argument get<TYPE> and put methods. More...

Detailed Description

Sequencer for executing several algorithms, stopping when one is faulty.

Default behaviour (ModeOR=False) is to execute all algorithms until one returns filterPassed() = False. If ShortCircuit is set to False, then all algorithms will be executed.

In OR mode, the logic is opposite. All algorithms until one returns filterPassed() = True. To then exit one must conter-intuitively set ShortCircuit to False. If the default value ShortCircuit=True is left then all algorithms will be executed.

Author: Olivier Callot

Date: 2004-05-13

Definition at line 38 of file GaudiSequencer.h.

Member Function Documentation

◆ decodeNames()

StatusCode GaudiSequencer::decodeNames ( )

private

Decode a vector of string.

Definition at line 139 of file GaudiSequencer.cpp.

                                        {
   StatusCode final = StatusCode::SUCCESS;
   m_entries.clear();
 
   //== Get the "Context" option if in the file...
   auto jos = service<IJobOptionsSvc>( "JobOptionsSvc" );
 
   //= Get the Application manager, to see if algorithm exist
   auto appMgr = service<IAlgManager>( "ApplicationMgr" );
   for ( const auto& item : m_names.value() ) {
     const Gaudi::Utils::TypeNameString typeName( item );
     const std::string&                 theName = typeName.name();
     const std::string&                 theType = typeName.type();
 
     //== Check wether the specified algorithm already exists. If not, create it
     StatusCode          result = StatusCode::SUCCESS;
     SmartIF<IAlgorithm> myIAlg = appMgr->algorithm( typeName, false ); // do not create it now
     if ( !myIAlg ) {
       Gaudi::Algorithm* myAlg = nullptr;
       result                  = createSubAlgorithm( theType, theName, myAlg );
       if ( myAlg ) {
         // Override the default values of the special properties Context and RootInTES,
         // which will be superseded by the explicit value in options (if present).
         if ( !isDefault( context() ) && myAlg->hasProperty( "Context" ) ) {
           myAlg->setProperty( "Context", context() ).ignore();
         }
         if ( !isDefault( rootInTES() ) && myAlg->hasProperty( "RootInTES" ) ) {
           myAlg->setProperty( "RootInTES", rootInTES() ).ignore();
         }
       }
       myIAlg = myAlg; // ensure that myIAlg.isValid() from here onwards!
     } else {
       Gaudi::Algorithm* myAlg = dynamic_cast<Gaudi::Algorithm*>( myIAlg.get() );
       if ( myAlg ) {
         subAlgorithms()->push_back( myAlg );
         // when the algorithm is not created, the ref count is short by one, so we have to fix it.
         myAlg->addRef();
       }
     }
 
     // propagate the sub-algorithm into own state.
     if ( result.isSuccess() && Gaudi::StateMachine::INITIALIZED <= FSMState() && myIAlg &&
          Gaudi::StateMachine::INITIALIZED > myIAlg->FSMState() ) {
       StatusCode sc = myIAlg->sysInitialize();
       if ( sc.isFailure() ) result = sc;
     }
 
     // propagate the sub-algorithm into own state.
     if ( result.isSuccess() && Gaudi::StateMachine::RUNNING <= FSMState() && myIAlg &&
          Gaudi::StateMachine::RUNNING > myIAlg->FSMState() ) {
       StatusCode sc = myIAlg->sysStart();
       if ( sc.isFailure() ) result = sc;
     }
 
     //== Is it an Algorithm ?  Strange test...
     if ( result.isSuccess() ) {
       // TODO: (MCl) it is possible to avoid the dynamic_cast in most of the
       //             cases by keeping the result of createSubAlgorithm.
       Gaudi::Algorithm* myAlg = dynamic_cast<Gaudi::Algorithm*>( myIAlg.get() );
       if ( myAlg ) {
         // Note: The reference counting is kept by the system of sub-algorithms
         m_entries.emplace_back( myAlg );
         if ( msgLevel( MSG::DEBUG ) ) debug() << "Added algorithm " << theName << endmsg;
       } else {
         warning() << theName << " is not a Gaudi::Algorithm - failed dynamic_cast" << endmsg;
         final = StatusCode::FAILURE;
       }
     } else {
       warning() << "Unable to find or create " << theName << endmsg;
       final = result;
     }
   }
 
   //== Print the list of algorithms
   MsgStream& msg = info();
   if ( m_modeOR ) msg << "OR ";
   msg << "Member list: ";
   GaudiUtils::details::ostream_joiner( msg, m_entries, ", ",
                                        []( auto& os, const AlgorithmEntry& e ) -> decltype( auto ) {
                                          Gaudi::Algorithm* alg = e.algorithm();
                                          std::string       typ = System::typeinfoName( typeid( *alg ) );
                                          os << typ;
                                          if ( alg->name() != typ ) os << "/" << alg->name();
                                          return os;
                                        } );
   if ( !isDefault( context() ) ) msg << ", with context '" << context() << "'";
   if ( !isDefault( rootInTES() ) ) msg << ", with rootInTES '" << rootInTES() << "'";
   msg << endmsg;
 
   return final;
 }

◆ execute()

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

override

Definition at line 74 of file GaudiSequencer.cpp.

                                                                   {
 
   if ( m_measureTime ) m_timerTool->start( m_timer );
 
   if ( msgLevel( MSG::DEBUG ) ) debug() << "==> Execute" << endmsg;
 
   StatusCode result = StatusCode( StatusCode::SUCCESS, true );
 
   bool seqPass = !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 ....
 
   for ( auto& entry : m_entries ) {
     Gaudi::Algorithm* myAlg = entry.algorithm();
     if ( !myAlg->isEnabled() ) continue;
     if ( myAlg->execState( ctx ).state() != AlgExecState::State::Done ) {
 
       if ( m_measureTime ) m_timerTool->start( entry.timer() );
       result = myAlg->sysExecute( ctx );
       if ( m_measureTime ) m_timerTool->stop( entry.timer() );
       if ( !result.isSuccess() ) break; //== Abort and return bad status
     }
     //== Check the returned status
     if ( !m_ignoreFilter ) {
       bool passed = myAlg->execState( ctx ).filterPassed();
       if ( msgLevel( MSG::VERBOSE ) )
         verbose() << "Algorithm " << myAlg->name() << " returned filter passed " << ( passed ? "true" : "false" )
                   << endmsg;
       if ( entry.reverse() ) passed = !passed;
 
       //== indicate our own result. For OR, exit as soon as true.
       //        If no more, will exit with false.
       //== for AND, exit as soon as false. Else, will be true (default)
 
       // if not short-circuiting, make sure we latch iPass to 'true' in
       // OR mode (i.e. it is sufficient for one item to be true in order
       // to be true at the end, and thus we start out at 'false'), and latch
       // to 'false' in AND mode (i.e. it is sufficient for one item to
       // be false to the false in the end, and thus we start out at 'true')
       // -- i.e. we should not just blindly return the 'last' passed status!
 
       // or to put it another way: 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 ) {
         seqPass = passed;
         if ( msgLevel( MSG::VERBOSE ) ) verbose() << "SeqPass is now " << ( seqPass ? "true" : "false" ) << endmsg;
         if ( m_shortCircuit ) break;
       }
     }
   }
   if ( msgLevel( MSG::VERBOSE ) ) verbose() << "SeqPass is " << ( seqPass ? "true" : "false" ) << endmsg;
   auto& state = execState( ctx );
   if ( !m_ignoreFilter && !m_entries.empty() ) state.setFilterPassed( m_invert ? !seqPass : seqPass );
   state.setState( AlgExecState::State::Done );
 
   if ( m_measureTime ) m_timerTool->stop( m_timer );
 
   return m_returnOK ? ( result.ignore(), StatusCode::SUCCESS ) : result;
 }

◆ GaudiCommon() [1/4]

template<typename U = PBASE, typename = std::enable_if_t<std::is_base_of_v<AlgTool, PBASE>, U>>

GaudiCommon< PBASE >::GaudiCommon	(	typename U	= `PBASE`,
		typename	= `std::enable_if_t<std::is_base_of_v<AlgTool, PBASE>, U>`
	)

inline

Standard constructor.

Definition at line 636 of file GaudiCommon.h.

       : base_class( std::move( type ), std::move( name ), ancestor ) {
     initGaudiCommonConstructor( this->parent() );
   }

◆ GaudiCommon() [2/4]

GaudiCommon< PBASE >::GaudiCommon

delete

Standard constructor.

◆ GaudiCommon() [3/4]

GaudiCommon< PBASE >::GaudiCommon

delete

Standard constructor.

◆ GaudiCommon() [4/4]

template<typename U = PBASE, typename = std::enable_if_t<std::is_base_of_v<Gaudi::Algorithm, PBASE>, U>>

GaudiCommon< PBASE >::GaudiCommon	(	typename U	= `PBASE`,
		typename	= `std::enable_if_t<std::is_base_of_v<Gaudi::Algorithm, PBASE>, U>`
	)

inline

Standard constructor.

Definition at line 630 of file GaudiCommon.h.

                                                           : base_class( std::move( name ), pSvcLocator ) {
     initGaudiCommonConstructor();
   }

◆ initialize()

StatusCode GaudiSequencer::initialize ( )

override

Definition at line 40 of file GaudiSequencer.cpp.

                                       {
   // Note: not calling base class initialize because we want to reimplement the loop over sub algs
   if ( msgLevel( MSG::DEBUG ) ) debug() << "==> Initialise" << endmsg;
 
   auto status = decodeNames();
   if ( !status.isSuccess() ) return status;
 
   m_timerTool = tool<ISequencerTimerTool>( "SequencerTimerTool" );
 
   if ( m_timerTool->globalTiming() ) m_measureTime = true;
 
   if ( m_measureTime ) {
     m_timer = m_timerTool->addTimer( name() );
     m_timerTool->increaseIndent();
   } else {
     release( m_timerTool ).ignore();
     m_timerTool = nullptr;
   }
 
   //== Initialize the algorithms
   for ( auto& entry : m_entries ) {
     if ( m_measureTime ) { entry.setTimer( m_timerTool->addTimer( entry.algorithm()->name() ) ); }
 
     status = entry.algorithm()->sysInitialize();
     if ( !status.isSuccess() ) { return Error( "Can not initialize " + entry.algorithm()->name(), status ); }
   }
   if ( m_measureTime ) m_timerTool->decreaseIndent();
 
   return StatusCode::SUCCESS;
 }

◆ membershipHandler()

void GaudiSequencer::membershipHandler ( )

private

for asynchronous changes in the list of algorithms

Definition at line 234 of file GaudiSequencer.cpp.

                                        {
   // no action for not-yet initialized sequencer
   if ( Gaudi::StateMachine::INITIALIZED > FSMState() ) return; // RETURN
 
   decodeNames().ignore();
 
   if ( !m_measureTime ) return; // RETURN
 
   // add the entries into timer table:
 
   if ( !m_timerTool ) { m_timerTool = tool<ISequencerTimerTool>( "SequencerTimerTool" ); }
 
   if ( m_timerTool->globalTiming() ) m_measureTime = true;
 
   m_timer = m_timerTool->addTimer( name() );
   m_timerTool->increaseIndent();
 
   for ( auto& entry : m_entries ) { entry.setTimer( m_timerTool->addTimer( entry.algorithm()->name() ) ); }
 
   m_timerTool->decreaseIndent();
 }

◆ sysExecute()

StatusCode GaudiSequencer::sysExecute ( const EventContext & ctx )

override

< guard/sentry

Definition at line 278 of file GaudiSequencer.cpp.

                                                                {
   StatusCode sc{StatusCode::SUCCESS};
 
   IAlgContextSvc* algCtx = nullptr;
   if ( registerContext() ) { algCtx = contextSvc(); }
   // Lock the context
   Gaudi::Utils::AlgContext cnt( this, algCtx, ctx ); 
 
   // Do not execute if one or more of the m_vetoObjs exist in TES
   const auto it = find_if( begin( m_vetoObjs ), end( m_vetoObjs ),
                            [&]( const std::string& loc ) { return this->exist<DataObject>( evtSvc(), loc ); } );
   if ( it != end( m_vetoObjs ) ) {
     if ( msgLevel( MSG::DEBUG ) ) debug() << *it << " found, skipping event " << endmsg;
     return sc;
   }
 
   // Execute if m_requireObjs is empty
   // or if one or more of the m_requireObjs exist in TES
   bool doIt = m_requireObjs.empty() ||
               any_of( begin( m_requireObjs ), end( m_requireObjs ),
                       [&]( const std::string& loc ) { return this->exist<DataObject>( evtSvc(), loc ); } );
 
   // execute the generic method:
   if ( doIt ) sc = GaudiCommon<Gaudi::Sequence>::sysExecute( ctx );
   return sc;
 }

◆ toControlFlowExpression()

std::ostream & GaudiSequencer::toControlFlowExpression ( std::ostream & os ) const

override

Produce string represention of the control flow expression.

Definition at line 256 of file GaudiSequencer.cpp.

                                                                           {
   if ( m_invert ) os << "~";
   // the default filterpass value for an empty sequencer depends on ModeOR
   if ( m_entries.empty() ) return os << ( ( !m_modeOR ) ? "CFTrue" : "CFFalse" );
 
   // if we have only one element, we do not need a name
   if ( m_entries.size() > 1 ) os << "seq(";
 
   const auto op    = m_modeOR ? " | " : " & ";
   const auto last  = end( m_entries );
   const auto first = begin( m_entries );
   for ( auto iterator = first; iterator != last; ++iterator ) {
     if ( iterator != first ) os << op;
     if ( iterator->reverse() ) os << "~";
     iterator->algorithm()->toControlFlowExpression( os );
   }
 
   if ( m_entries.size() > 1 ) os << ")";
   return os;
 }

Member Data Documentation

◆ m_entries

std::vector<AlgorithmEntry> GaudiSequencer::m_entries

private

List of algorithms to process.

Definition at line 90 of file GaudiSequencer.h.

◆ m_ignoreFilter

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

private

Definition at line 84 of file GaudiSequencer.h.

◆ m_invert

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

private

Definition at line 88 of file GaudiSequencer.h.

◆ m_measureTime

Gaudi::Property<bool> GaudiSequencer::m_measureTime = {this, "MeasureTime", false, "measure time"}

private

Definition at line 85 of file GaudiSequencer.h.

◆ m_modeOR

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

private

Definition at line 83 of file GaudiSequencer.h.

◆ m_names

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

private

Initial value:

= {

this, "Members", {}, &GaudiSequencer::membershipHandler, "list of algorithms"}

Definition at line 80 of file GaudiSequencer.h.

◆ m_requireObjs

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

private

Initial value:

{

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

Definition at line 77 of file GaudiSequencer.h.

◆ m_returnOK

Gaudi::Property<bool> GaudiSequencer::m_returnOK = {this, "ReturnOK", false, "forces the sequencer to return a good status"}

private

Definition at line 86 of file GaudiSequencer.h.

◆ m_sequential

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

private

Definition at line 82 of file GaudiSequencer.h.

◆ m_shortCircuit

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

private

Definition at line 87 of file GaudiSequencer.h.

◆ m_timer

int GaudiSequencer::m_timer

private

Timer number for the sequencer.

Definition at line 92 of file GaudiSequencer.h.

◆ m_timerTool

ISequencerTimerTool* GaudiSequencer::m_timerTool = nullptr

private

Pointer to the timer tool.

Definition at line 91 of file GaudiSequencer.h.

◆ m_vetoObjs

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

private

Initial value:

{

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

Definition at line 75 of file GaudiSequencer.h.

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

GaudiAlg/GaudiAlg/GaudiSequencer.h
GaudiAlg/src/lib/GaudiSequencer.cpp

Classes

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ decodeNames()

◆ execute()

◆ GaudiCommon() [1/4]

◆ GaudiCommon() [2/4]

◆ GaudiCommon() [3/4]

◆ GaudiCommon() [4/4]

◆ initialize()

◆ membershipHandler()

◆ sysExecute()

◆ toControlFlowExpression()

Member Data Documentation

◆ m_entries

◆ m_ignoreFilter

◆ m_invert

◆ m_measureTime

◆ m_modeOR

◆ m_names

◆ m_requireObjs

◆ m_returnOK

◆ m_sequential

◆ m_shortCircuit

◆ m_timer

◆ m_timerTool

◆ m_vetoObjs