StepSequencer Class Reference

#include <StepSequencer.h>

Inheritance diagram for StepSequencer:

Public Member Functions
	StepSequencer (const std::string &name, ISvcLocator *pSvcLocator)
	~StepSequencer ()
virtual bool	isEnabled () const
StatusCode	initialize ()
StatusCode	execute ()
StatusCode	finalize ()
void	reset ()
StatusCode	initSequencer (HltProcessor::Sequence *)
bool	execSequencer (const std::string &seqID)
std::vector< Algorithm * >	searchAlgForEachTE_o (HltProcessor::Sequence *)
bool	doesExistAlready (std::string)
Algorithm *	existingAlg (std::string)

Detailed Description

Definition at line 14 of file StepSequencer.h.

Constructor & Destructor Documentation

StepSequencer()

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

Definition at line 28 of file StepSequencer.cxx.

    : Algorithm( name, pSvcLocator ) {
  m_isEnabled = false;
}

~StepSequencer()

StepSequencer::~StepSequencer

(

)

Definition at line 34 of file StepSequencer.cxx.

                              {
  /*
  std::vector<Algorithm*>* subAlgms = subAlgorithms();
  std::vector<Algorithm *>::iterator it;
  for (it = subAlgms->begin(); it != subAlgms->end(); it++) {
    std::cout << *it << (*it)->name() << std::endl;
    (*it)->release();
  }
  */
}

Member Function Documentation

doesExistAlready()

bool StepSequencer::doesExistAlready

(

std::string

aName

)

Definition at line 144 of file StepSequencer.cxx.

                                                      {
  MsgStream                log( msgSvc(), name() );
  bool                     doesExist = false;
  std::vector<Algorithm*>* subAlgms  = subAlgorithms();
 
  if ( subAlgms->size() == 0 )
  {
    doesExist = false;
    return doesExist;
  }
  else
  {
    std::vector<Algorithm*>::iterator it = subAlgms->begin();
    for ( ; it != subAlgms->end(); it++ )
    {
      if ( aName == ( *it )->name() )
      {
        log << MSG::WARNING << aName << " sub-algorithm already created" << endmsg;
        doesExist = true;
        break;
      }
    }
  }
  return doesExist;
}

Referenced by initSequencer().

execSequencer()

bool StepSequencer::execSequencer

(

const std::string &

seqID

)

Definition at line 172 of file StepSequencer.cxx.

                                                          {
  MsgStream                      log( msgSvc(), name() );
  const std::vector<Algorithm*>& algVec = m_AlgMap[seqID];
  /*log << MSG::DEBUG << " Execute Sequencer on a step with "
      << algVec.size() << " algorithms." << endmsg;*/
 
  log << MSG::DEBUG << "=============================" << endmsg;
 
  std::vector<Algorithm*>::const_iterator it = algVec.begin();
  for ( ; it != algVec.end(); it++ )
  {
    StatusCode sc = ( *it )->execute();
    if ( sc.isFailure() )
    {
      log << MSG::ERROR << ( *it )->name() << " execute failed" << endmsg;
      return false;
    }
  }
 
  return true;
}

execute()

StatusCode StepSequencer::execute ( )

inline

Definition at line 21 of file StepSequencer.h.

{ return StatusCode::SUCCESS; }

existingAlg()

Algorithm * StepSequencer::existingAlg

(

std::string

subAlgName

)

Definition at line 127 of file StepSequencer.cxx.

                                                            {
  MsgStream                         log( msgSvc(), name() );
  Algorithm*                        exAlg;
  std::vector<Algorithm*>*          subAlgms = subAlgorithms();
  std::vector<Algorithm*>::iterator it       = subAlgms->begin();
  for ( ; it != subAlgms->end(); it++ )
  {
    if ( subAlgName == ( *it )->name() )
    {
      log << subAlgName << " already created, return pointer to it " << endmsg;
      return *it;
    }
  }
  return exAlg;
}

Referenced by initSequencer().

finalize()

StatusCode StepSequencer::finalize ( )

inline

Definition at line 22 of file StepSequencer.h.

{ return StatusCode::SUCCESS; }

initialize()

StatusCode StepSequencer::initialize ( )

inline

Definition at line 20 of file StepSequencer.h.

{ return StatusCode::SUCCESS; }

initSequencer()

StatusCode StepSequencer::initSequencer

(

HltProcessor::Sequence *

sequence

)

Definition at line 67 of file StepSequencer.cxx.

                                                            {
  MsgStream log( msgSvc(), name() );
 
  std::string SubAlg_type, SubAlg_name, SubAlg_param, SubAlg_NameParam, AlgNameFromConfig;
  Algorithm*  pAlg;
  Algorithm*  bAlg;
 
  // read in algorithms in sequence and initialize them
  log << MSG::DEBUG << "Sequence " << sequence->getSeqID() << " has " << sequence->algoNum()
      << " algorithms " << endmsg;
 
  std::vector<Algorithm*>            helpAlgVec;
  std::vector<std::string>::iterator algI = sequence->algoVector().begin();
 
  for ( ; algI != sequence->algoVector().end(); algI++ )
  {
    std::string alg_def = *algI;
    log << MSG::DEBUG << "algorithm    : " << alg_def << endmsg;
    findAlgTypeName( alg_def, SubAlg_type, SubAlg_NameParam );
    findParamSet( SubAlg_NameParam, AlgNameFromConfig, SubAlg_param );
    SubAlg_name = AlgNameFromConfig + "_" + SubAlg_param;
 
    // check if the name exists, don't create again the subalgorithm, just added to the
    // AlgoTePairs vector
    bool subAlgExist = doesExistAlready( SubAlg_name );
    if ( !subAlgExist )
    {
      StatusCode sc = createSubAlgorithm( SubAlg_type, SubAlg_name, pAlg );
      if ( sc.isFailure() )
      {
        log << MSG::FATAL << alg_def << " sub-algorithm create failed!" << endmsg;
        return sc;
      }
      log << MSG::DEBUG << "created " << SubAlg_type << "/" << SubAlg_name << endmsg;
      bAlg = dynamic_cast<Algorithm*>( pAlg );
      bAlg->initialize();
      bAlg->beginRun();
      StringProperty paramSet( "ParamSetFile", SubAlg_param );
      bAlg->setProperty( paramSet );
 
      helpAlgVec.push_back( bAlg );
    }
    else
    {
      pAlg = existingAlg( SubAlg_name );
      bAlg = dynamic_cast<Algorithm*>( pAlg );
      // bAlg->set_isReRunable();
      StringProperty paramSet( "ParamSetFile", SubAlg_param );
      bAlg->setProperty( paramSet );
      helpAlgVec.push_back( bAlg );
    }
  }
  m_AlgMap[sequence->getSeqID()] = helpAlgVec;
 
  log << MSG::INFO << "Initialization of " << name() << " completed successfully" << endmsg;
  return StatusCode::SUCCESS;
}

isEnabled()

virtual bool StepSequencer::isEnabled ( ) const

inlinevirtual

Definition at line 19 of file StepSequencer.h.

{ return m_isEnabled; };

reset()

void StepSequencer::reset

(

)

Definition at line 46 of file StepSequencer.cxx.

                          {
  MsgStream                                                log( msgSvc(), name() );
  std::map<std::string, std::vector<Algorithm*>>::iterator it = m_AlgMap.begin();
  log << MSG::DEBUG << "the size of algorithm map is " << m_AlgMap.size() << endmsg;
  for ( ; it != m_AlgMap.end(); it++ )
  {
    log << MSG::DEBUG << "reset() of " << it->first << endmsg;
    const std::vector<Algorithm*>& algs = it->second;
    int                            n    = algs.size();
    for ( int i = 0; i < n; i++ )
    {
      if ( IEFAlgorithm* ialg = dynamic_cast<IEFAlgorithm*>( algs[i] ) )
      {
        // std::cout << " @reset(): " << algs[i]->name() << "  p: " << ialg << std::endl;
        ialg->reset();
      }
    }
  }
}

searchAlgForEachTE_o()

std::vector< Algorithm * > StepSequencer::searchAlgForEachTE_o

(

HltProcessor::Sequence *

seq

)

Definition at line 194 of file StepSequencer.cxx.

                                                                         {
 
  MsgStream   log( msgSvc(), name() );
  std::string SubAlg_type, SubAlg_name, SubAlg_param, SubAlg_NameParam, AlgNameFromConfig;
 
  /* std::string n=name();
  std::string::size_type p_end, p_begin;
  p_end=n.size();
  p_begin=p_end-3;
  std::string instance=n.substr( p_begin, p_end);*/
 
  vMatchAlg.clear();
  std::vector<std::string>::iterator It = seq->algoVector().begin();
  for ( ; It < seq->algoVector().end(); It++ )
  {
    std::string alg_defin = *It;
    findAlgTypeName( alg_defin, SubAlg_type, SubAlg_NameParam );
    findParamSet( SubAlg_NameParam, AlgNameFromConfig, SubAlg_param );
    SubAlg_name = AlgNameFromConfig + "_" + SubAlg_param;
 
    /*std::vector<std::pair<Algorithm*,HltElement* > >::iterator I;
    for(I=AlgoTEPairs.begin();I!=AlgoTEPairs.end();++I) {
 
       if( SubAlg_name==(I->first)->name() && (I->second)->label()==seq->outputLabel() ) {
         matchAlg=I->first;
         vMatchAlg.push_back(matchAlg);
       }
    }*/
  }
  return vMatchAlg;
}

---

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

• StepSequencer.h
• StepSequencer.cxx