In This Package:

Stage.cc

Go to the documentation of this file.

#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/GaudiException.h"
#include "GaudiKernel/IAlgManager.h"
#include "GaudiKernel/IJobOptionsSvc.h"


#include "Stage.h"

//------------------------------------------------------------------------------
Stage::Stage( const std::string& type,
              const std::string& name, 
              const IInterface* parent )
  : GaudiTool( type, name, parent ) 
  , m_SeqName("")
{
    // declare my special interface
    declareInterface<IStage>(this);

    declareProperty( "Sequencer", m_SeqName, "Sequencer's Name");
}

//------------------------------------------------------------------------------
FFTimeStamp Stage::currentTime() const
//------------------------------------------------------------------------------
{
    MsgStream log(msgSvc(), name());
    log << MSG::DEBUG << "currentTime() is: " << m_CurrentTime << endreq;
    return m_CurrentTime;
}

//------------------------------------------------------------------------------
StatusCode Stage::nextElement(IStageData*& pIStgData,
                              bool erase)
//------------------------------------------------------------------------------
{
    debug() << " -- == nextElement() is called == -- " << endreq;

    std::vector<Algorithm*>::iterator pVec;

    if(m_read_erase==true) {
        m_sequencer->resetExecuted();
        StatusCode sc = m_sequencer->execute();
        if (sc.isFailure()) {
            error() << "Sequence failed" << endreq;
            return sc;
        }
        debug() << "every processor retured" << endreq;
    } else {
    }

    IStageDataList::iterator ppData;

    debug() << "current number of elements: "<< m_DataList.size() <<endreq;
    if(m_DataList.size()<=0) {
        fatal()<<"NO data available! Where is data? Check processors!"<<endreq;
        return StatusCode::FAILURE;
    }

    ppData=m_DataList.begin();
    m_CurrentTime=ppData->first;
    debug() << "Smallest time found T_min = "<< m_CurrentTime << endreq;

    pIStgData=ppData->second;
  
    if(erase) {
        m_DataList.erase(ppData);
    } 

    m_read_erase=erase;

    debug() << " -- == nextElement() call finished == --" << endreq;
    return StatusCode::SUCCESS;
}

StatusCode Stage::pushElement(IStageData* pIStgData)
{
    MsgStream log(msgSvc(), name());
    StatusCode sc;
  
    m_DataList.insert(IStageDataList::value_type(pIStgData->time(),pIStgData));
  
    return sc;
}

//------------------------------------------------------------------------------
StatusCode Stage::initialize()
//------------------------------------------------------------------------------
{
    // Make use of svc<>
    IMessageSvc* msg = svc<IMessageSvc>("MessageSvc");
    MsgStream log(msg, name());
    log << MSG::DEBUG << "intializing ......" << endreq;

    if ("" == m_SeqName) {
        log << MSG::ERROR << "No seqencer given to stage " << name() << endreq;
        return StatusCode::FAILURE;
    }

    { // inspired by Algorithm::createSubAlgorithm and
      // GaudiSequencer::decodeNames()

        SmartIF<IAlgManager> am(IID_IAlgManager,serviceLocator());

        IAlgorithm *tmp = 0;

        StatusCode sc = am->getAlgorithm(m_SeqName, tmp);
        if (sc.isFailure()) {
            log << MSG::DEBUG
                << "Failed to get GaudiSequencer named " << m_SeqName 
                << ". Will try to create..." << endreq;

            sc = am->createAlgorithm ("GaudiSequencer", m_SeqName, tmp);
            if( sc.isFailure() ) {
                log << MSG::ERROR
                    << "Failed to create GaudiSequencer named "
                    << m_SeqName << endreq;
                return StatusCode::FAILURE;
            }
        }

        try{
            m_sequencer = dynamic_cast<Algorithm*>(tmp);
        } 
        catch(...) {
            log << MSG::ERROR
                << "GaudiSequencer named " << m_SeqName << " not an Algorithm?!?" 
                << endreq;
            return StatusCode::FAILURE;
        }
        if (!m_sequencer) {
            log << MSG::ERROR
                << "GaudiSequencer not an algorithm??"
                << endreq;
            return StatusCode::FAILURE;
        }

        log << MSG::INFO
            << "Got algorithm " << m_sequencer->name() 
            << " setting properties on it"
            << endreq;

        IJobOptionsSvc* jos = svc<IJobOptionsSvc>("JobOptionsSvc");
        jos->setMyProperties(m_SeqName,m_sequencer);
        jos->release();
    }

    // Let init flow down to subalgs
    StatusCode sc = m_sequencer->initialize();
    if (sc.isFailure()) {
        log << MSG::ERROR
            << "GaudiSequencer::initialize() failed" << endreq;
        return sc;
    }
    log << MSG::DEBUG
        << "Got GaudiSequencer/" << m_sequencer->name() << endreq;

    // Although initialized to 0, however, no special meaning
    m_CurrentTime=0;

    m_DataList.clear();

    m_read_erase=true;

    return StatusCode::SUCCESS;
}
//------------------------------------------------------------------------------
StatusCode  Stage::finalize()
//------------------------------------------------------------------------------
{
    MsgStream log(msgSvc(), name());
    log << MSG::DEBUG << "finalizing ......" << endreq;

    // Let finalize flow down to subalgs
    return m_sequencer->finalize();
}

//------------------------------------------------------------------------------
Stage::~Stage( )
//------------------------------------------------------------------------------
{ 
    MsgStream log(msgSvc(), name());
    log << MSG::DEBUG << "destructing ......" << endreq;
}

// Local Variables:
// c-basic-offset: 4
// End:

---