GaudiSequencer Class Reference

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

#include <GaudiSequencer.h>

Inheritance diagram for GaudiSequencer:

[legend]

Collaboration diagram for GaudiSequencer:

[legend]

List of all members.

Public Member Functions
	GaudiSequencer (const std::string &name, ISvcLocator *pSvcLocator)
	Standard constructor.
virtual	~GaudiSequencer ()
	Destructor.
virtual StatusCode	initialize ()
	Algorithm initialization.
virtual StatusCode	execute ()
	Algorithm execution.
virtual StatusCode	finalize ()
	Algorithm finalization.
virtual StatusCode	beginRun ()
	Algorithm beginRun.
virtual StatusCode	endRun ()
	Algorithm endRun.
void	resetExecuted ()
	Called before an event processing.
void	membershipHandler (Property &theProp)
	for asynchronous changes in the list of algorithms
Protected Member Functions
StatusCode	decodeNames ()
	Decode a vector of string.
Private Member Functions
	GaudiSequencer (const GaudiSequencer &a)
	Private copy, copy not allowed.
GaudiSequencer &	operator= (const GaudiSequencer &a)
	Private assignment operator: This is not allowed.
Private Attributes
StringArrayProperty	m_names
	Input string, list of algorithms.
std::vector< AlgorithmEntry >	m_entries
	List of algorithms to process.
bool	m_modeOR
	Indicates that the OR is wanted instead of AND.
bool	m_shortCircuit
	Indicates whether to stop processing as soon as possible, or to always execute _all_ subalgorithms.
bool	m_ignoreFilter
	True if one continues always.
bool	m_isInitialized
	Indicate that we are ready.
bool	m_measureTime
	Flag to measure time.
bool	m_returnOK
	Forces the sequencer to return a good status.
ISequencerTimerTool *	m_timerTool
	Pointer to the timer tool.
int	m_timer
	Timer number for the sequencer.
Classes
class	AlgorithmEntry

---

Detailed Description

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

Author:

Olivier Callot

Date:

2004-05-13

Definition at line 18 of file GaudiSequencer.h.

---

Constructor & Destructor Documentation

GaudiSequencer::GaudiSequencer	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Standard constructor.

Definition at line 20 of file GaudiSequencer.cpp.

  : GaudiAlgorithm ( name , pSvcLocator )
  , m_timerTool( 0 )
{
  declareProperty( "Members"             , m_names                  );
  declareProperty( "ModeOR"              , m_modeOR         = false );
  declareProperty( "IgnoreFilterPassed"  , m_ignoreFilter   = false );
  declareProperty( "MeasureTime"         , m_measureTime    = false );
  declareProperty( "ReturnOK"            , m_returnOK       = false );
  declareProperty( "ShortCircuit"        , m_shortCircuit   = true  );

  m_names.declareUpdateHandler (& GaudiSequencer::membershipHandler, this );
}

GaudiSequencer::~GaudiSequencer

(

)

[virtual]

Destructor.

Definition at line 37 of file GaudiSequencer.cpp.

{}

GaudiSequencer::GaudiSequencer

(

const GaudiSequencer &

a

)

[private]

Private copy, copy not allowed.

---

Member Function Documentation

StatusCode GaudiSequencer::initialize

(

)

[virtual]

Algorithm initialization.

Reimplemented from GaudiAlgorithm.

Definition at line 42 of file GaudiSequencer.cpp.

                                      {
  GaudiAlgorithm::initialize();

  debug() << "==> Initialise" << endmsg;

  StatusCode 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 );
    m_timerTool = 0;
  }

  //== Initialize the algorithms
  std::vector<AlgorithmEntry>::iterator itE;
  for ( itE = m_entries.begin(); m_entries.end() != itE; itE++ ) {
    if ( m_measureTime ) {
      itE->setTimer( m_timerTool->addTimer( itE->algorithm()->name() ) );
    }

    status = itE->algorithm()->sysInitialize();
    if ( !status.isSuccess() ) {
      return Error( "Can not initialize " + itE->algorithm()->name(),
                    status );
    }
  }
  if ( m_measureTime ) m_timerTool->decreaseIndent();

  return StatusCode::SUCCESS;
}

StatusCode GaudiSequencer::execute

(

)

[virtual]

Algorithm execution.

Reimplemented from GaudiAlgorithm.

Definition at line 82 of file GaudiSequencer.cpp.

                                   {

  if ( m_measureTime ) m_timerTool->start( m_timer );

  debug() << "==> Execute" << endmsg;

  StatusCode result = StatusCode::SUCCESS;

  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 ....

  std::vector<AlgorithmEntry>::const_iterator itE;
  for ( itE = m_entries.begin(); m_entries.end() != itE; ++itE ) {
    Algorithm* myAlg = itE->algorithm();
    if ( ! myAlg->isEnabled() ) continue;
      if ( ! myAlg->isExecuted() ) {
      if ( m_measureTime ) m_timerTool->start( itE->timer() );
        result = myAlg->sysExecute();
      if ( m_measureTime ) m_timerTool->stop( itE->timer() );
        myAlg->setExecuted( true );
        if ( ! result.isSuccess() ) break;  //== Abort and return bad status

      }
      //== Check the returned status
      if ( !m_ignoreFilter ) {
        bool passed = myAlg->filterPassed();
      if ( itE->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 (m_shortCircuit) break;
      }
    }

  }
  if ( !m_ignoreFilter && !m_entries.empty() ) setFilterPassed( seqPass );
  setExecuted( true );

  if ( m_measureTime ) m_timerTool->stop( m_timer );

  return m_returnOK ? StatusCode::SUCCESS : result;
}

StatusCode GaudiSequencer::finalize

(

void

)

[virtual]

Algorithm finalization.

Reimplemented from GaudiAlgorithm.

Definition at line 144 of file GaudiSequencer.cpp.

                                    {

  debug() << "==> Finalize" << endmsg;
  return  GaudiAlgorithm::finalize();
}

StatusCode GaudiSequencer::beginRun

(

)

[virtual]

Algorithm beginRun.

Reimplemented from Algorithm.

Definition at line 153 of file GaudiSequencer.cpp.

                                      {

  if ( !isEnabled() ) return StatusCode::SUCCESS;

  debug() << "==> beginRun" << endmsg;
  return StatusCode::SUCCESS;
}

StatusCode GaudiSequencer::endRun

(

)

[virtual]

Algorithm endRun.

Reimplemented from Algorithm.

Definition at line 164 of file GaudiSequencer.cpp.

                                    {

  if ( !isEnabled() ) return StatusCode::SUCCESS;

  debug() << "==> endRun" << endmsg;
  return StatusCode::SUCCESS;
}

void GaudiSequencer::resetExecuted

(

)

[virtual]

Called before an event processing.

Reimplemented from Algorithm.

Definition at line 175 of file GaudiSequencer.cpp.

                                     {
  Algorithm::resetExecuted();
  // algorithm doesn't call resetExecuted of subalgos! should it???
  std::vector<AlgorithmEntry>::const_iterator itE;
  for ( itE = m_entries.begin(); m_entries.end() != itE; ++itE ) {
    itE->algorithm()->resetExecuted();
  }
}

void GaudiSequencer::membershipHandler

(

Property &

theProp

)

for asynchronous changes in the list of algorithms

Definition at line 343 of file GaudiSequencer.cpp.

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

StatusCode GaudiSequencer::decodeNames

(

)

[protected]

Decode a vector of string.

Definition at line 192 of file GaudiSequencer.cpp.

                                         {

  StatusCode final = StatusCode::SUCCESS;
  m_entries.clear();

  //== Get the "Context" option if in the file...
  IJobOptionsSvc* jos = svc<IJobOptionsSvc>( "JobOptionsSvc" );
  bool addedContext = false;  //= Have we added the context ?
  bool addedRootInTES = false;  //= Have we added the rootInTES ?
  bool addedGlobalTimeOffset = false;  //= Have we added the globalTimeOffset ?


  //= Get the Application manager, to see if algorithm exist
  IAlgManager* appMgr = svc<IAlgManager>("ApplicationMgr");
  const std::vector<std::string>& nameVector = m_names.value();
  std::vector<std::string>::const_iterator it;
  for ( it = nameVector.begin(); nameVector.end() != it; it++ ) {
    const Gaudi::Utils::TypeNameString typeName(*it);
    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.isValid() ) {
      //== Set the Context if not in the jobOptions list
      if ( ""  != context() ||
           ""  != rootInTES() ||
           0.0 != globalTimeOffset() ) {
        bool foundContext = false;
        bool foundRootInTES = false;
        bool foundGlobalTimeOffset = false;
        const std::vector<const Property*>* properties = jos->getProperties( theName );
        if ( 0 != properties ) {
          // Iterate over the list to set the options
          for ( std::vector<const Property*>::const_iterator itProp = properties->begin();
               itProp != properties->end();
               itProp++ )   {
            const StringProperty* sp = dynamic_cast<const StringProperty*>(*itProp);
            if ( 0 != sp )    {
              if ( "Context" == (*itProp)->name() ) {
                foundContext = true;
              }
              if ( "RootInTES" == (*itProp)->name() ) {
                foundRootInTES = true;
              }
              if ( "GlobalTimeOffset" == (*itProp)->name() ) {
                foundGlobalTimeOffset = true;
              }
            }
          }
        }
        if ( !foundContext && "" != context() ) {
          StringProperty contextProperty( "Context", context() );
          jos->addPropertyToCatalogue( theName, contextProperty ).ignore();
          addedContext = true;
        }
        if ( !foundRootInTES && "" != rootInTES() ) {
          StringProperty rootInTESProperty( "RootInTES", rootInTES() );
          jos->addPropertyToCatalogue( theName, rootInTESProperty ).ignore();
          addedRootInTES = true;
        }
        if ( !foundGlobalTimeOffset && 0.0 != globalTimeOffset() ) {
          DoubleProperty globalTimeOffsetProperty( "GlobalTimeOffset", globalTimeOffset() );
          jos->addPropertyToCatalogue( theName, globalTimeOffsetProperty ).ignore();
          addedGlobalTimeOffset = true;
        }
      }

      Algorithm *myAlg = 0;
      result = createSubAlgorithm( theType, theName, myAlg );
      // (MCl) this should prevent bug #35199... even if I didn't manage to
      // reproduce it with a simple test.
      if (result.isSuccess()) myIAlg = myAlg;
    } else {
      Algorithm *myAlg = dynamic_cast<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();
      }
    }

    //== Remove the property, in case this is not a GaudiAlgorithm...
    if ( addedContext ) {
      jos->removePropertyFromCatalogue( theName, "Context" ).ignore();
      addedContext = false;
    }
    if ( addedRootInTES ) {
      jos->removePropertyFromCatalogue( theName, "RootInTES" ).ignore();
      addedRootInTES = false;
    }
    if ( addedGlobalTimeOffset ) {
      jos->removePropertyFromCatalogue( theName, "GlobalTimeOffset" ).ignore();
      addedGlobalTimeOffset = false;
    }

    //== 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.
      Algorithm*  myAlg = dynamic_cast<Algorithm*>(myIAlg.get());
      if (myAlg!=0) {
        // Note: The reference counting is kept by the system of sub-algorithms
        m_entries.push_back( AlgorithmEntry( myAlg ) );
        debug () << "Added algorithm " << theName << endmsg;
      } else {
        warning() << theName << " is not an Algorithm - failed dynamic_cast"
                  << endmsg;
        final = StatusCode::FAILURE;
      }
    } else {
      warning() << "Unable to find or create " << theName << endmsg;
      final = result;
    }

  }
  release(appMgr).ignore();
  release(jos).ignore();

  //== Print the list of algorithms
  MsgStream& msg = info();
  if ( m_modeOR ) msg << "OR ";
  msg << "Member list: ";
  std::vector<AlgorithmEntry>::iterator itE;
  for ( itE = m_entries.begin(); m_entries.end() != itE; itE++ ) {
    Algorithm* myAlg = (*itE).algorithm();
    std::string myAlgType = System::typeinfoName( typeid( *myAlg) ) ;
    if ( myAlg->name() == myAlgType ) {
      msg << myAlg->name();
    } else {
      msg << myAlgType << "/" << myAlg->name();
    }
    if ( itE+1 != m_entries.end() ) msg << ", ";
  }
  if ( "" != context() ) msg << ", with context '" << context() << "'";
  if ( "" != rootInTES() ) msg << ", with rootInTES '" << rootInTES() << "'";
  if ( 0.0 != globalTimeOffset() ) msg << ", with globalTimeOffset " << globalTimeOffset();
  msg << endmsg;

  return final;

}

GaudiSequencer& GaudiSequencer::operator=

(

const GaudiSequencer &

a

)

[private]

Private assignment operator: This is not allowed.

---

Member Data Documentation

StringArrayProperty GaudiSequencer::m_names [private]

Input string, list of algorithms.

Definition at line 72 of file GaudiSequencer.h.

std::vector<AlgorithmEntry> GaudiSequencer::m_entries [private]

List of algorithms to process.

Definition at line 73 of file GaudiSequencer.h.

bool GaudiSequencer::m_modeOR [private]

Indicates that the OR is wanted instead of AND.

Definition at line 74 of file GaudiSequencer.h.

bool GaudiSequencer::m_shortCircuit [private]

Indicates whether to stop processing as soon as possible, or to always execute _all_ subalgorithms.

Definition at line 75 of file GaudiSequencer.h.

bool GaudiSequencer::m_ignoreFilter [private]

True if one continues always.

Definition at line 77 of file GaudiSequencer.h.

bool GaudiSequencer::m_isInitialized [private]

Indicate that we are ready.

Definition at line 78 of file GaudiSequencer.h.

bool GaudiSequencer::m_measureTime [private]

Flag to measure time.

Definition at line 79 of file GaudiSequencer.h.

bool GaudiSequencer::m_returnOK [private]

Forces the sequencer to return a good status.

Definition at line 80 of file GaudiSequencer.h.

ISequencerTimerTool* GaudiSequencer::m_timerTool [private]

Pointer to the timer tool.

Definition at line 81 of file GaudiSequencer.h.

int GaudiSequencer::m_timer [private]

Timer number for the sequencer.

Definition at line 82 of file GaudiSequencer.h.

---

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

• /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r9/GaudiAlg/GaudiAlg/GaudiSequencer.h
• /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r9/GaudiAlg/src/lib/GaudiSequencer.cpp