In This Package:

HeaderObjectCnv.cc

Go to the documentation of this file.

#include "PerBaseEvent/HeaderObjectCnv.h"
#include "PerBaseEvent/TemporalDataObjectCnv.h"
#include "Context/Context.h"
#include "Event/RegistrationSequence.h"
#include "GaudiKernel/IDataProviderSvc.h" 
#include "GaudiKernel/MsgStream.h"
#include "GaudiMessages/GaudiMessages.h"
#include "DybKernel/IEvtStoreQuery.h"
// get a service pointer in a static function
#include "GaudiKernel/ServiceHandle.h"

#include <string>
#include <vector>

using namespace DayaBay;
using namespace std;

HeaderObjectCnv::HeaderObjectCnv(ISvcLocator* svc)
    : RootIOTypedCnv<PerHeaderObject,HeaderObject>("PerHeaderObject",classID(),svc)
{
}

HeaderObjectCnv::~HeaderObjectCnv()
{
}

void HeaderObjectCnv::clear()
{
    PerHeaderObject* objs[3] = {
        &getPerInputObject(),
        &getPerOutputObject(),
        0
    };
    const char* label[] = { "input", "output", 0 };
    for (int ind=0; objs[ind]; ++ind) {
        PerHeaderObject& tho = *objs[ind];
        tho.context = Context();
        tho.context.SetTimeStamp(TimeStamp(0.0)); // default is sets to "now"
        tho.execNumber = -1;
        tho.jobId = DayaBay::JobId();
        tho.randomState.clear();

        MsgStream log(msgSvc(), "HeaderObjectCnv::clear");
        log << MSG::VERBOSE
            << "clearing " << tho.inputHeaders.size() << " input headers from "
            << label[ind] << " PerHeaderObject"
            << endreq;
        tho.inputHeaders.clear();
    }
}


StatusCode HeaderObjectCnv::toTran(const PerHeaderObject& perobj,
                                   HeaderObject& tranobj)
{
    StatusCode sc = TemporalDataObjectCnv::toTran(perobj,tranobj);
    if (sc.isFailure()) return sc;

    // do header copy
    tranobj.setContext(perobj.context);
    tranobj.setExecNumber(perobj.execNumber);
    tranobj.setJobId(perobj.jobId);
    tranobj.setRandomState(perobj.randomState);
    tranobj.setInputHeaders(vector<const DayaBay::IHeader*>());
    return StatusCode::SUCCESS;
}

StatusCode HeaderObjectCnv::toPer(const HeaderObject& tranobj,
                                  PerHeaderObject& perobj)
{
    StatusCode sc = TemporalDataObjectCnv::toPer(tranobj,perobj);
    if (sc.isFailure()) return sc;

    // do header copy

    perobj.context = tranobj.context();
    perobj.execNumber = tranobj.execNumber();
    perobj.jobId = tranobj.jobId();
    perobj.randomState = tranobj.randomState();
    perobj.inputHeaders.clear();
    return StatusCode::SUCCESS;
}


StatusCode HeaderObjectCnv::fillPer(IRootIOSvc* rioSvc, 
                                    const DayaBay::HeaderObject& ho,
                                    PerHeaderObject& tho)
{
    GaudiMsgStreams log("HeaderObjectCnv::fillPer");

    tho.inputHeaders.clear();
    size_t siz = ho.inputHeaders().size();
    if( siz <= 0 ) return StatusCode::SUCCESS;

    for (size_t ind = 0; ind<siz; ++ind) {
        const IHeader* ihead = ho.inputHeaders()[ind];
        const HeaderObject* other_ho = 
            dynamic_cast<const HeaderObject*>(ihead);

        const GenericAddress* gad=other_ho->outputAddress();
        if(!gad) {
            static map<string,int> errorMap;
            string other_ho_name = other_ho->name();
            if (!errorMap[other_ho_name]) {
                log.warning()
                    << MSG::WARNING
                    << "Failed to get output address for " << other_ho_name
                    << ", skipping and won't tell you about it again." << endreq;
            }
            errorMap[other_ho_name] = 1;
            continue; // skip this one
        }

        const RootOutputAddress*  roa=dynamic_cast<const RootOutputAddress*>(gad);
        tho.inputHeaders.push_back(PerRef(roa->entry(),roa->tespath()));
    }
    return StatusCode::SUCCESS;
}



StatusCode HeaderObjectCnv::fillRepRefs(IOpaqueAddress* /*addr*/,
                                        DataObject* tranobj)
{
    HeaderObject* ho = dynamic_cast<HeaderObject*>(tranobj);
    PerHeaderObject& tho = getPerOutputObject();
    return HeaderObjectCnv::fillPer(m_rioSvc, *ho, tho);
}

StatusCode HeaderObjectCnv::fillTran(IRootIOSvc* rioSvc, 
                                     const PerHeaderObject& tho,
                                     DayaBay::HeaderObject& ho)
{
    GaudiMsgStreams log("HeaderObjectCnv::fillTran");

    static IEvtStoreQuery* s_evtStoreQuery=0;
    // get a service pointer in a static function
    if (s_evtStoreQuery==0) {
        ServiceHandle<IEvtStoreQuery> msgh("EvtStoreQuery","HeaderObjectCnv");
        s_evtStoreQuery = msgh.operator->();
    }

    // Get current RegistrationSequence
    string rs_path = RegistrationSequence::defaultLocation();
    DataObject *rs_tranobj = 0;
    StatusCode sc = rioSvc->dataSvc()->retrieveObject(rs_path,rs_tranobj);
    if (sc.isFailure()) {
        return sc;
    }
    RegistrationSequence* rsobj = dynamic_cast<RegistrationSequence*>(rs_tranobj);
    if (!rsobj)return StatusCode::FAILURE;

    vector<const DayaBay::IHeader*> inputs;

    size_t siz = tho.inputHeaders.size();
    for (size_t ind=0; ind < siz; ++ind) {
        const PerRef& pref = tho.inputHeaders[ind];

        log.debug()
            << s_evtStoreQuery << "\t" << pref.path() << "\t" << pref.entry() 
            << endreq;
        const DataObject* pOBJ = s_evtStoreQuery->queryInputAddress(pref.path(),pref.entry());

        if(pOBJ!=0) {
            const IHeader* ihead = dynamic_cast<const IHeader*>(pOBJ);
            inputs.push_back(ihead);
        } 
        else {
            static int headerWarningCount = 0;
            if( headerWarningCount < 10 ){
              log.warning()
                <<"An inputHeader " << pref.path() << ", " << pref.entry() << " not found."
                << " Consider using a longer AES window."
                << endreq;
              headerWarningCount++;
              if(headerWarningCount==10){
                log.warning()
                  <<" (Further missing inputHeader messages suppressed.)" 
                  << endreq;
              }
            }
        }
    }
    ho.setInputHeaders(inputs);
    return StatusCode::SUCCESS;
}

StatusCode HeaderObjectCnv::fillObjRefs(IOpaqueAddress* /*addr*/,
                                        DataObject* tranobj)
{
    PerHeaderObject& tho = getPerInputObject();
    HeaderObject* ho = dynamic_cast<HeaderObject*>(tranobj);
    return HeaderObjectCnv::fillTran(m_rioSvc, tho, *ho);
}


StatusCode HeaderObjectCnv::PerToTran(const PerHeaderObject& perobj, 
                                      HeaderObject& tranobj)
{
    return HeaderObjectCnv::toTran(perobj,tranobj);
}

StatusCode HeaderObjectCnv::TranToPer(const HeaderObject& tranobj, 
                                      PerHeaderObject& perobj)
{
    return HeaderObjectCnv::toPer(tranobj,perobj);
}

---