In This Package:

DybBaseAlg.cc

Go to the documentation of this file.

#include "DybAlg/DybBaseAlg.h"
#include "DataUtilities/DybArchiveList.h"
#include "GaudiKernel/IRndmGenSvc.h"
#include "GaudiKernel/IRndmEngine.h"
#include "GaudiKernel/StreamBuffer.h"

#include "Context/TimeStamp.h"

#include "DataSvc/IJobInfoSvc.h"

DybBaseAlg::DybBaseAlg(const std::string& name, ISvcLocator* pSvcLocator)
    : GaudiAlgorithm(name,pSvcLocator)
    , m_headerObject(0)
    , m_jobInfoSvc(0)
{
    declareProperty("ExecutionNumber",m_execNum = 1,
                    "The starting execution number.");
    declareProperty("SaveRandomState",m_saveRandomState = false,
                    "Set true/false to save the random state.");

    m_pullMode=false;  

}

DybBaseAlg::~DybBaseAlg()
{
}

StatusCode DybBaseAlg::sysInitialize()
{
    // Call parent
    StatusCode sc = this->GaudiAlgorithm::initialize();
    if (sc.isFailure()) return sc;

    // This insinuates on GaudiAlgorithm's operation in order to do
    // any "dybish" initialization:
    // do_dybstuff_init();

    // Trigger calling subclass, back to your regularly scheduled operations
    sc = this->Algorithm::sysInitialize();    
    if (sc.isFailure()) return sc;

    return StatusCode::SUCCESS;
}

StatusCode DybBaseAlg::sysExecute()
{
  if(!m_pullMode) {
    if(preExecute().isFailure()) return StatusCode::FAILURE;
  }

  // Trigger subclass's execute();                                                                             
  if (this->Algorithm::sysExecute().isFailure()) return StatusCode::FAILURE;

  if(!m_pullMode) {
    if(postExecute().isFailure()) return StatusCode::FAILURE;
  }

  return StatusCode::SUCCESS;
}

StatusCode DybBaseAlg::preExecute()
{
    if (!m_saveRandomState) return StatusCode::SUCCESS;

    // Get random state
    IRndmEngine *engine = 0;
    if (randSvc()->queryInterface(IID_IRndmEngine,(void**)&engine).isFailure()) {
        warning() << "Could not get IRndmEngine interace from random service, "
            "no state saved!" << endreq;
    }
    else {
        engine->rndmState(m_state);
        debug () << "Storing random state: [";
        for (size_t ind=0; ind<m_state.size(); ++ind) {
            debug () << " " << m_state[ind];
        }
        debug () << " ]" << endreq;
    }
    
    return StatusCode::SUCCESS;
}

StatusCode DybBaseAlg::postExecute()
{
    // Set some base HeaderObject values
    if (m_headerObject) {
        m_headerObject->setRandomState(m_state);
        const std::vector<const DayaBay::IHeader*> iheaders(m_inputHeaders.begin(),m_inputHeaders.end());
        m_headerObject->setInputHeaders(iheaders);


        // Add to TES.  This must be done after algorithm has chance to
        // fill earliest/latest with non-default values as this put()
        // triggers an insert() into the RegistrationSequence.
        
        if (!m_pullMode) {
            put(m_headerObject,m_location);
        }
    }

    // Prepare alg for next execution cycle
    debug() <<"Clearing " << m_inputHeaders.size() << " cached input headers" << endreq;
    m_inputHeaders.clear();
    ++m_execNum;
    m_headerObject = 0;               // owned by TES

    return StatusCode::SUCCESS;
}

StatusCode DybBaseAlg::sysFinalize()
{
    if (this->finalize().isFailure()) {
        return StatusCode::FAILURE;
    }
    return this->GaudiAlgorithm::finalize();
}


void DybBaseAlg::InitializeHeader(DayaBay::HeaderObject* header)
{
  // Set some standard parameters for this header

  // Set execution number
  header->setExecNumber(m_execNum);    
  
  // Document the ID of the job which made this header
  if(!m_jobInfoSvc){
    // Get the job information service
    m_jobInfoSvc = svc<IJobInfoSvc>("JobInfoSvc",true);
  }
  if(m_jobInfoSvc){
    header->setJobId(m_jobInfoSvc->currentJobInfo()->jobId());
  }else{
    warning() << "MakeHeaderObject, failed to get current job ID" << endreq;
  }
  // Set the header time range
  header->setEarliest(TimeStamp::GetBOT());
  header->setLatest(TimeStamp::GetBOT());
}

void DybBaseAlg::AppendInputHeader(const DayaBay::HeaderObject* header) const
{
    m_inputHeaders.push_back(header);
}


IDataProviderSvc* DybBaseAlg::arcSvc() const
{
    return 0;                   // fixme
}

void DybBaseAlg::putTES(DataObject* obj, std::string location) const
{
    // Look for pre-existing header object or make new one, creating
    // the supporting path as we go.
    std::string::size_type ind = location.find("/"); // skip initial "/".
    while (true) {
        ind = location.find("/",ind+1);
        if (ind == std::string::npos) {
            debug() << "Putting final: " << location << endreq;
            put(obj,location);
            break;
        }
        else {
            // make the supporting path from simple DataObjects
            debug() << "Making intermediate: " << location.substr(0,ind)
                   << endreq;
            getOrCreate<DataObject,DataObject>(location.substr(0,ind));
        }
    }
}


std::vector<DataObject*> DybBaseAlg::getAEScollection(std::string location) const
{
    DybArchiveList* lst = get<DybArchiveList>(arcSvc(),location);
    if (!lst) return std::vector<DataObject*>();
    return std::vector<DataObject*>(lst->begin(),lst->end());
}

---