In This Package:

TestInputLoadAlg.cc

Go to the documentation of this file.

#include "TestInputLoadAlg.h"

#include "Event/HeaderObject.h"

#include "GaudiKernel/MsgStream.h"

#include <sstream>

using namespace DayaBay;

TestInputLoadAlg::TestInputLoadAlg(const std::string& name, ISvcLocator* pSvcLocator)
    : GaudiAlgorithm(name,pSvcLocator)
{
    declareProperty("Loader", m_loader, "A IDybInputLoadTool");
    declareProperty("Policy", m_policy, "A IDybEntryPolicyTool");
    declareProperty("Path", m_path, "A TES-like path to the HeaderObject to load");
    declareProperty("TestType", m_test_type=0, "Which tests to run [0,1,2,3,4]");
}

TestInputLoadAlg::~TestInputLoadAlg()
{
}

StatusCode TestInputLoadAlg::initialize()
{
    MsgStream log(msgSvc(), "TestInputLoadAlg");

    {
        StatusCode sc = m_loader.retrieve();
        if (sc.isFailure()) {
            log << MSG::ERROR << "Failed to retrieve " << m_loader << endreq;
            return sc;
        }
    }

    {
        StatusCode sc = m_policy.retrieve();
        if (sc.isFailure()) {
            log << MSG::ERROR << "Failed to retrieve " << m_policy << endreq;
            return sc;
        }
    }
    return StatusCode::SUCCESS;
}

// Walk the input headers such that bucket gets filled with oldest
// HeaderObject first
void collect_input_headers(MsgStream& log, const HeaderObject* start, 
                           std::vector<const HeaderObject*> &bucket)
{
    std::vector<const IHeader*> ihlist = start->inputHeaders();

    for (size_t ind=0; ind<ihlist.size(); ++ind) {
        const HeaderObject* ho = dynamic_cast<const HeaderObject*>(ihlist[ind]);
        log << MSG::DEBUG << "Recursing on " 
            << const_cast<HeaderObject*>(ho)->defLoc() 
            << " with bucked filed to " << bucket.size()
            << endreq;
        collect_input_headers(log,ho,bucket);
    }

    log << MSG::DEBUG << "Saving " 
        << const_cast<HeaderObject*>(start)->defLoc() << endreq;
    bucket.push_back(start);

}

StatusCode TestInputLoadAlg::get_header(int entry, const std::string& path, bool input_headers)
{
    MsgStream log(msgSvc(), "TestInputLoadAlg");

    HeaderObject* ho = m_loader->get_header(entry,path,input_headers);
    if (!ho) {
        log << MSG::ERROR << "Failed to get HeaderObject at entry "
            << entry << " and path \"" << path << "\"" << endreq;
        return StatusCode::FAILURE;
    }
    log << MSG::DEBUG << "Found Header object at entry "
        << entry << " and path \"" << path << "\"" << endreq;
    log << MSG::DEBUG << ho->earliest() << endreq;
    std::vector<const HeaderObject*> bucket;
    collect_input_headers(log, ho, bucket);
    
    log << MSG::DEBUG << "Got " << bucket.size() << " HeaderObjects" << endreq;

    for (size_t ind=0; ind<bucket.size(); ++ind) {
        HeaderObject* hop = const_cast<HeaderObject*>(bucket[ind]);
        log << MSG::DEBUG << "Putting HeaderObject at " << hop->defLoc() << endreq;
        this->put(hop,hop->defLoc());
    }

    return StatusCode::SUCCESS;
}

StatusCode TestInputLoadAlg::get_frame(int entry, const std::string& path, bool input_headers)
{
    MsgStream log(msgSvc(), "TestInputLoadAlg");

    IDybInputLoadTool::ExecutionFrame ef = m_loader->get_frame(entry,path,input_headers);
    if (!ef.size()) {
        log << MSG::ERROR << "Failed to get non-empty ExecutionFrame at entry "
            << entry << " and path \"" << path << "\"" << endreq;
        return StatusCode::FAILURE;
    }
    log << MSG::DEBUG << "Found ExecutionFrame object at entry "
        << entry << " and path \"" << path << "\"" << endreq;
    
    log << MSG::DEBUG << "Got " << ef.size() << " HeaderObjects" << endreq;

    for (size_t ind=0; ind < ef.size(); ++ind) {
        log << MSG::DEBUG << ind << " " << ef[ind].first << endreq;
        this->put(ef[ind].second,ef[ind].first);
    }

    return StatusCode::SUCCESS;
}

StatusCode TestInputLoadAlg::execute()
{
    MsgStream log(msgSvc(), "TestInputLoadAlg");

    int entry = m_policy->next_entry();

    int which = entry%4;
    if (m_test_type) which = m_test_type-1;

    log << MSG::DEBUG << "test " << which << " loading entry " << entry << endreq;
    
    std::string rspath = "/Event/RegistrationSequence";

    switch(which) {
    case 0:
        return this->get_header(entry,m_path,false);
        break;
    case 1:
        return this->get_header(entry,m_path,true);
        break;
    case 2:
        return this->get_frame(entry,rspath,true);
        break;
    case 3:
        return this->get_frame(entry,rspath,true);
        break;
    }

    log << MSG::ERROR << "got unknown test code: " << which+1 << " should be in [0-4]" << endreq;
    return StatusCode::FAILURE;
}

StatusCode TestInputLoadAlg::finalize()
{
    return StatusCode::SUCCESS;
}

---