In This Package:

Alg1 Namespace Reference

Functions
	Alg1 (const std::string &name, ISvcLocator *ploc)
StatusCode	initialize ()
StatusCode	execute ()
	Goal of execute(): Consumer&Producer: Push an element into StageData.
StatusCode	finalize ()
StatusCode	beginRun ()
StatusCode	endRun ()

---

Function Documentation

Alg1::Alg1	(	const std::string &	name,
		ISvcLocator *	ploc
	)

Definition at line 16 of file Alg1.cpp.

           : Algorithm(name, ploc) {
//------------------------------------------------------------------------------
  m_initialized = false;
  
  declareProperty("ThisStageName",m_ThisStageName, "Name of this stage");
  declareProperty("LowerStageName",m_LowerStageName, "Name of the lower stage");

}

StatusCode Alg1::initialize

(

)

Definition at line 27 of file Alg1.cpp.

                            {
//------------------------------------------------------------------------------
  // avoid calling initialize more than once
  if( m_initialized ) return StatusCode::SUCCESS;

  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "initializing...." << endreq;
  log << MSG::DEBUG << "Current Stage " <<m_ThisStageName <<endreq;
  log << MSG::DEBUG << "Lower Stage " <<m_LowerStageName <<endreq;

  StatusCode sc;

  // =========
  sc= toolSvc()->retrieveTool("Stage",m_ThisStageName,m_ThisStage);
  if( sc.isFailure() ) {
    log << MSG::ERROR << "Error retrieving the public tool" << endreq;
  }
  // =========
  int diff;
  diff = m_LowerStageName.compare("null");
  if(diff!=0) {
    sc= toolSvc()->retrieveTool("Stage",m_LowerStageName,m_LowerStage);
    if( sc.isFailure() ) {
      log << MSG::ERROR << "Error retrieving the public tool" << endreq;
    }
  } else {
    m_LowerStage=0;
  }

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

  m_FakeDataList.clear();

  m_initialized = true;

  m_Start=true;

  return StatusCode::SUCCESS;
}

StatusCode Alg1::execute

(

)

Goal of execute(): Consumer&Producer: Push an element into StageData.

It might consume many elements from lower stage. It might store many elements. Producer: Get one element into StageData.

=====))))) Consumer&Producer:

Principle: make sure the data provided is really the earliest (with smallest time)

the core part begins ///////// determine localtime, it is not m_CurrentTime

localtime must go beyond lower stage to make sure output is safe

pulling event from lower stage

fake code begins //////////////////

destroy the data pulled out generate some new data This process is like to take some input after use then produce new data

find out the min time

get the data with smallest time push it into current stage and delete it.

=====))))) Producer: generate data by myself

fake code begins ////////////////// The following should be replace by real stuff.

update my current time

push it into StageData

Definition at line 78 of file Alg1.cpp.

                         {
//------------------------------------------------------------------------------
  MsgStream  log( msgSvc(), name() );
  log << MSG::DEBUG << "begin of execute()" << endreq;

  FakeDataList::iterator pfakedatalist;

  FFTimeStamp localtime(0,0);

  // Random number (to generate random integer 0,1,2,3)
  Rndm::Numbers flat(randSvc(),Rndm::Flat(0,3.1));

  if(m_LowerStage!=0) {
    log << MSG::DEBUG << "Consumer&Producer" << endreq;
    if(m_Start||m_CurrentTime<=m_ThisStage->currentTime()) {
      
      if(m_Start) {
        // nothing to do
      } else {
        pfakedatalist=m_FakeDataList.begin();
        localtime=pfakedatalist->first;
      }

      while(m_Start||localtime>=m_LowerStage->currentTime()) {
        m_Start=false;
        log << MSG::DEBUG << "In while loop, pulling data from lower Stage ......" << endreq;   
        
        IStageData* pIStageData=0;
        StatusCode sc = m_LowerStage->nextElement(pIStageData);  // pulling out
        if (sc.isFailure()) {
            log << MSG::ERROR
                << "Failed to get next element from lower stage" << endreq;
            return StatusCode::FAILURE;
        }
        
        FakeData* pFakeData=dynamic_cast<FakeData*>(pIStageData);
        if (!pFakeData) {
            log << MSG::ERROR
                << "Recieved unknown type of data from lower stage"
                << endreq;
            return StatusCode::FAILURE;
        }

        //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
        // destroy the used one
        FFTimeStamp dt=flat();

        FFTimeStamp tm=pFakeData->time();
        log << MSG::DEBUG << "data pulled out from lower stage has time: "<<tm<<endreq;
        delete pFakeData;
        log << MSG::DEBUG << "data from lower stage is consumed"<<endreq;
        // generate new one
        FakeData* pFD=new FakeData(tm+dt);
        log << MSG::DEBUG << "new data generated at time: "<< pFD->time()<< endreq;
        //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

        // push back into a local store
        m_FakeDataList.insert(FakeDataList::value_type(pFD->time(),pFD));

        pfakedatalist=m_FakeDataList.begin();
        localtime=pfakedatalist->first;
      }

      m_CurrentTime=localtime;
      log << MSG::DEBUG << "m_CurrentTime= "<< m_CurrentTime << endreq;

      if (m_FakeDataList.size()) {
          pfakedatalist=m_FakeDataList.begin();
          log << MSG::DEBUG << "new data pushed out at time " << pfakedatalist->first << endreq;
          
          m_ThisStage->pushElement(pfakedatalist->second);
          m_FakeDataList.erase(pfakedatalist);
      }
      else {
          log << MSG::WARNING 
              << "I have no more data to give" << endreq;
      }

    }
  }

  
  if(m_LowerStage==0) {
    log << MSG::DEBUG << "Producer" << endreq;
    if(m_Start||m_CurrentTime<=m_ThisStage->currentTime()) {
      
      m_Start=false;
      FFTimeStamp dt=flat();
      FakeData* pFD=new FakeData(m_CurrentTime+dt);
      
      m_CurrentTime=pFD->time();
      m_ThisStage->pushElement(pFD);
      log << MSG::DEBUG << "a data is generated: time = "<< pFD->time() <<endreq; 
    }
  }

  log << MSG::DEBUG << "execute() end "<<endreq;
  return StatusCode::SUCCESS;
}

StatusCode Alg1::finalize

(

)

Definition at line 205 of file Alg1.cpp.

                          {
//------------------------------------------------------------------------------
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "finalizing...." << endreq;

  m_initialized = false;
  return StatusCode::SUCCESS;
}

StatusCode Alg1::beginRun

(

)

Definition at line 214 of file Alg1.cpp.

                          {
//------------------------------------------------------------------------------
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "beginning new run...." << endreq;
  
  m_initialized = true;
  return StatusCode::SUCCESS;
}

StatusCode Alg1::endRun

(

)

Definition at line 225 of file Alg1.cpp.

                        {
//------------------------------------------------------------------------------
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "ending new run...." << endreq;
  
  m_initialized = true;
  return StatusCode::SUCCESS;
}

---