In This Package:

RootIOCnvSvc.cc

Go to the documentation of this file.

#include "RootIOSvc/RootIOCnvSvc.h"
#include "RootIOSvc/RootIOAddress.h"
#include "RootIOSvc/RootIOBaseCnv.h"
#include "RootOutputFileManager.h"

#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/SmartIF.h"
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/ISvcManager.h"
#include "GaudiKernel/MsgStream.h"

#include "Event/RegistrationSequence.h"

using namespace std;

RootIOCnvSvc::RootIOCnvSvc(const string& name, ISvcLocator* svc)
    : ConversionSvc(name,svc,ROOT_StorageType)
    , m_dataSvc(0)
{
    declareProperty("OutputStreams",m_outputFileMap,
                    "Map of TES location to output filename");
    declareProperty("DefaultOutput",m_defaultOutputFilename="",
                    "Name of output file to store unregistered paths.");

    declareProperty("InputStreams",m_inputFileMap,
                    "Map of TES location to input filename");
    declareProperty("DefaultInput",m_defaultInputFilenames,
                    "Name of input file to store unregistered paths.");

    declareProperty("ForceReadout",m_forceReadout=false,
                    "True if Readout object should be written to output.");

    declareProperty("EventDataService",m_dataSvcName="EventDataSvc",
                    "Name of event data service.");
}
RootIOCnvSvc::~RootIOCnvSvc()
{
}

StatusCode RootIOCnvSvc::reinitialize()
{
    MsgStream log(msgSvc(), "RootIOCnvSvc");
    log << MSG::DEBUG << "reinitializing @" << (void*)this << endreq;
    StatusCode sc = ConversionSvc::initialize();
    if (sc.isFailure()) {
        log << MSG::ERROR << "parent class failed to initialize" << endreq;
        return sc;
    }
    sc= this->doInitialize();
    log << MSG::DEBUG << "reinitialized @" << (void*)this << endreq;
    return sc;
}
StatusCode RootIOCnvSvc::initialize()
{
    MsgStream log(msgSvc(), "RootIOCnvSvc");
    log << MSG::DEBUG << "initializing @" << (void*)this << endreq;
    StatusCode sc = ConversionSvc::initialize();
    if (sc.isFailure()) {
        log << MSG::ERROR << "parent class failed to initialize" << endreq;
        return sc;
    }
    sc= this->doInitialize();
    log << MSG::DEBUG << "initialized @" << (void*)this << endreq;
    return sc;
}

StatusCode RootIOCnvSvc::doInitialize()
{
    MsgStream log(msgSvc(), "RootIOCnvSvc");

    if (0 == m_defaultInputFilenames.size()  && 0 == m_inputFileMap.size() &&
        "" == m_defaultOutputFilename && 0 == m_outputFileMap.size())
    {
        log << MSG::WARNING 
            << "No input nor output files specified.  Why am I here?"
            << endreq;
        return StatusCode::FAILURE;
    }
        

    // --- ouput --- //
    {                           
        map<string,string>::iterator it, done = m_outputFileMap.end();
        log << MSG::INFO 
            << " default output = \"" << m_defaultOutputFilename << "\""
            << " output file map (" << m_outputFileMap.size() << " entries):";
        for (it = m_outputFileMap.begin(); it != done; ++it) {
            log << "\n\t\"" << it->first << "\" ==> \"" << it->second << "\"";
        }
        log << endreq;
    }
    if (m_defaultOutputFilename.size()) { // if set, it should override "default" in map
        m_outputFileMap["default"] = m_defaultOutputFilename;
    }
    else { 
        map<string,string>::iterator it = m_outputFileMap.find("default");
        if (it == m_outputFileMap.end()) {
            log << MSG::WARNING 
                << " no \"default\" output file name specified, "
                "unregistered TES paths will not be saved." << endreq;
        }
        else {
            m_defaultOutputFilename = it->second;
        }
    }
    
    // If we have output, configure the output file manager
    if (m_outputFileMap.size()) {
        IIncidentSvc *incsvc = 0;
        StatusCode sc = service("IncidentSvc", incsvc, true);
        if(sc.isFailure()){
            log << MSG::ERROR << "Unable start IncidentSvc service" 
                << endreq;
            return sc;
        }
        RootOutputFileManager::get().setIncidentSvc(incsvc);

        // make sure we get finalized before IncidentSvc does.
        // SmartIF<ISvcManager> mgr(IID_ISvcManager, serviceLocator());
        // int pri_inc = mgr->getPriority("IncidentSvc");
        // log << MSG::INFO << "Setting my priority to one more than IncidentSvc (" << pri_inc << ")" << endreq;
        // mgr->setPriority("RootIOCnvSvc",pri_inc + 1);
    }


    // --- input --- //
    {
        map<string,vector<string> >::iterator it, done = m_inputFileMap.end();
        string defin =  "";
        if (m_defaultInputFilenames.size()) defin = m_defaultInputFilenames[0];
        log << MSG::INFO
            << " default input = \"" << defin << "\""
            << " input file map (" << m_inputFileMap.size() << " entries):";
        for (it = m_inputFileMap.begin(); it != done; ++it) {
            log << "\t" << it->first << " : [";
            vector<string>& vec = it->second;
            for (size_t ind = 0; ind < vec.size(); ++ind) {
                log << " " << vec[ind];
            }
            log << "]\n";
        }
        log << endreq;
    }

    if (0 == m_defaultInputFilenames.size()) {
        map<string,vector<string> >::iterator it = m_inputFileMap.find("default");
        if (it == m_inputFileMap.end()) {
            log << MSG::WARNING
                << " no \"default\" input file name specified, "
                "unregistered TES paths will not be saved." << endreq;
        }
        else {
            m_defaultInputFilenames = it->second;
        }
    }
    {
        map<string,vector<string> >::iterator it, done = m_inputFileMap.end();
        for (it = m_inputFileMap.begin(); it != done; ++it) {
            if (it->first == "default") continue;
            if (!it->second.size()) {
                log << MSG::WARNING
                    << "Skipping input stream with no files: "
                    << it->first << endreq;
                continue;
            }
            initializeInputStream(it->first,it->second);
        }
        if (m_defaultInputFilenames.size())
            initializeInputStream("default",m_defaultInputFilenames);
    }
    
    log << MSG::DEBUG << "Initialized input and output streams." << endreq;

    // Get DataSvc
    log << MSG::DEBUG << "Getting " << m_dataSvcName << " as IService" << endreq;
    IService* isvc = 0;
    StatusCode sc = service(m_dataSvcName, isvc, true);
    if(sc.isFailure()){
        log << MSG::ERROR << "Unable start EventData service" 
            << m_dataSvcName << endreq;
        return sc;
    }
    isvc->addRef();

    log << MSG::DEBUG << "Querying " << m_dataSvcName << " for IID_IDataProviderSvc" << endreq;
    sc = isvc->queryInterface(IID_IDataProviderSvc, (void**)&m_dataSvc);
    if(sc.isFailure()){
        log << MSG::ERROR << "EventData service " << m_dataSvcName 
            << "not an IDataProviderSvc" << endreq;
        return sc;
    }

    log << MSG::DEBUG << "Querying " << m_dataSvcName << " for IID_IDataManagerSvc" << endreq;
    sc = isvc->queryInterface(IDataManagerSvc::interfaceID(),
                              (void**)(&m_dataMgr));
    if (sc.isFailure()) {
        log << MSG::ERROR << "EventData service " << m_dataSvcName 
            << "not an IDataManagerSvc" << endreq;
        return sc;
    }

    return StatusCode::SUCCESS;
}

void RootIOCnvSvc::initializeInputStream(const string& path, 
                                         const string& filename)
{
    vector<string> vec;
    vec.push_back(filename);
    this->initializeInputStream(path,vec);
}

void RootIOCnvSvc::initializeInputStream(const string& path, 
                                         const vector<string>& filenames)
{
    MsgStream log(msgSvc(), "RootIOCnvSvc");

    // If "default" root through all paths in the file and register them.
    if (path == "default") {
        // Use the first filename to find all TES paths it represents.
        // This could be a problem if a series of files get written
        // and a particular path doesn't show up until after the first
        // file.....
        vector<string> tespaths = RootInputFile::TreePaths(filenames[0]);

        if (!tespaths.size()) {
            log << MSG::WARNING 
                << "initializeInputStream found no Trees in " << filenames[0]
                << endreq;
            return;
        }
        for (size_t ind=0; ind<tespaths.size(); ++ind) {
            log << MSG::DEBUG << "found " << tespaths[ind] << " in file " 
                << filenames[0] << endreq;
            initializeInputStream(tespaths[ind],filenames);
        }
        return;
    }

    map<string,RootInputStream*>::iterator it = m_inputStreamMap.find(path);
    if (it != m_inputStreamMap.end()) {
        log << MSG::WARNING << "path " 
            << path << " already has an input stream so not reinitializing file " 
            << filenames[0] << ", ..." << endreq;
        return;
    }
    
    // Sanity check
    string branchname = RootIO::branchname(path);
    int clid = RootInputFile::TestForObject(filenames[0],path,branchname);
    if (!clid) {
        log << MSG::WARNING << "failed to get nonzero class id from path "
            << path << ", branch " << branchname << " in file " << filenames[0] << endreq;
        return;
    }
    
    RootInputAddress ria(clid,path);
    
    RootInputStream* ris = this->inputStream(ria);
    if (!ris) {
        log << MSG::WARNING << "failed to get input stream for " << path
            << " in " << filenames[0] << endreq;
        return;
    }
    
    m_inputStreamMap[path] = ris;
    log << MSG::DEBUG << "retrieving " << path 
        << " from " << filenames[0] << endreq;
    return;
}


void RootIOCnvSvc::associateOutput(const char* filename, const char* streamname)
{
    m_outputFileMap[streamname] = filename;
    if (string("default") == streamname) {
        m_defaultOutputFilename = filename;
    }
}
IRootIOSvc::FileMap RootIOCnvSvc::fileMap()
{
    return m_outputFileMap;
}

RootOutputStream* RootIOCnvSvc::outputStream(const RootOutputAddress& roa)
{
    MsgStream log(msgSvc(), "RootIOCnvSvc");

    const string& filename = this->outputFilename(roa.tespath());
    if ("" == filename) {
        log << MSG::ERROR << "Bad (empty) output filename, no ouput stream for " 
            << roa.tespath() << endreq;
        return 0;
    }

    RootOutputStream* os = m_outputStreamMap[roa.tespath()];
    if (os) {
        os->newFile(filename); // noop unless filename differs from old one
        log << MSG::DEBUG << "outputStream for " << roa.tespath() 
            << " cached, file = " << filename << endreq;
        return os;
    }

    IConverter*  cnv  = converter(roa.clID());
    if (!cnv) {
        log << MSG::WARNING
            << "Failed to get converter for class ID = " << roa.clID()
            << " tespath = " << roa.tespath() << endreq;
        return 0;
    }

    RootIOBaseCnv* riocnv = dynamic_cast<RootIOBaseCnv*>(cnv);
    if (!riocnv) {
        log << MSG::WARNING 
            << "Converter not a RootIOBaseCnv for class ID = " << roa.clID()
            << " tespath = " << roa.tespath() << endreq;
        return 0;
    }

    os = riocnv->makeOutputStream(roa);
    if (!os) {
        log << MSG::WARNING
            << "Converter failed to make new output stream for class ID = " 
            << roa.clID()
            << " tespath = " << roa.tespath() << endreq;
        return 0;
    }

    m_outputStreamMap[roa.tespath()] = os;
    os->newFile(filename);
    log << MSG::DEBUG << "outputStream for " << roa.tespath() 
        << " new, file = " << filename << endreq;
    return os;
}

RootInputStream* RootIOCnvSvc::inputStream(const RootInputAddress& ria)
{
    MsgStream log(msgSvc(), "RootIOCnvSvc");

    vector<string> filenames = this->inputFilenames(ria.tespath());
    if (0 == filenames.size()) {
        log << MSG::DEBUG << "Bad (empty) input filename, no input stream for " 
            << ria.tespath() << endreq;
        return 0;
    }

    RootInputStream* ris = m_inputStreamMap[ria.tespath()];
    if (ris) {
        log << MSG::DEBUG << "inputStream for " << ria.tespath()
            << " cached, files = [";
        for (size_t ind=0; ind<filenames.size(); ++ind) {
            log << " " << filenames[ind];
        }
        log << "]" << endreq;
        return ris;
    }

    IConverter*  cnv  = converter(ria.clID());
    if (!cnv) {
        log << MSG::WARNING
            << "Failed to get converter for class ID = " << ria.clID()
            << " tespath = " << ria.tespath() << endreq;
        return 0;
    }

    RootIOBaseCnv* riocnv = dynamic_cast<RootIOBaseCnv*>(cnv);
    if (!riocnv) {
        log << MSG::WARNING 
            << "Converter not a RootIOBaseCnv for class ID = " << ria.clID()
            << " tespath = " << ria.tespath() << endreq;
        return 0;
    }

    ris = riocnv->makeInputStream(ria);
    if (!ris) {
        log << MSG::WARNING
            << "Converter failed to make new input stream for class ID = " 
            << ria.clID()
            << " tespath = " << ria.tespath() << endreq;
        return 0;
    }

    for (size_t ind = 0; ind < filenames.size(); ++ind) {
        bool okay = ris->append(filenames[ind]);
        if (!okay) {
            log << MSG::ERROR
                << "failed to append file " << filenames[ind] << " to input stream for " 
                << ria.tespath() << endreq;
            return 0;
        }
    }

    m_inputStreamMap[ria.tespath()] = ris;

    log << MSG::DEBUG << "inputStream for " << ria.tespath() 
        << " new, files = [";
    for (size_t ind=0; ind<filenames.size(); ++ind) {
        log << " " << filenames[ind];
    }
    log << "]" << endreq;

    return ris;    
}

const string& RootIOCnvSvc::outputFilename(const string& tespath)
{
    map<string,string>::iterator it = m_outputFileMap.find(tespath);
    if (it == m_outputFileMap.end()) return m_defaultOutputFilename;
    return it->second;
}

vector<string> RootIOCnvSvc::inputFilenames(const string& tespath)
{
    map<string,vector<string> >::iterator it = m_inputFileMap.find(tespath);
    if (it == m_inputFileMap.end()) {
        return m_defaultInputFilenames;
    }
    return it->second;
}

StatusCode RootIOCnvSvc::createAddress(long svc_type,
                                       const CLID& clid,
                                       const string* par, 
                                       const unsigned long* ip,
                                       IOpaqueAddress*& refpAddress)
{
    MsgStream log(msgSvc(), "RootIOCnvSvc");
    log << MSG::ERROR << "generic createAddress("
        << svc_type << ", " << clid 
        << ",[" << par[0] << "," << par[1] << "], " << ip[0] << ")"
        << " unimplemented"
        << endreq;
    //refpAddress = new RootIOAddress(svc_type,clid,par[0],par[1],ip[0]);
    refpAddress = 0;
    return StatusCode::FAILURE;
}


StatusCode RootIOCnvSvc::createAddress(DataObject* obj, RootOutputAddress*& newAddr)
{
    // wangzhe: There is no ObjectReg created for RegistrationSequence
    // So there is no ganrantee there is Registry alive for each RegistrationSequence
    string tespath;
    if(obj->clID()==DayaBay::RegistrationSequence::classID()) {
      tespath=DayaBay::RegistrationSequence::defaultLocation();
    } else {
      tespath = obj->registry()->identifier();
    }
    // wz

    string filename = m_defaultOutputFilename;
    map<string,string>::iterator it = m_outputFileMap.find(tespath);
    if (it != m_outputFileMap.end()) 
        filename = it->second;

    if ("" == filename) {
        MsgStream log(msgSvc(), "RootIOCnvSvc");
        static map<string,int> errorMap;
        if (!errorMap[tespath]) {
            log << MSG::WARNING
                << "Can not create address for " << tespath
                << " no output file specified, I won't tell you again." 
                << endreq;
            errorMap[tespath] = 1;
        }
        return StatusCode::FAILURE;
    }

    newAddr = new RootOutputAddress(obj->clID(),tespath);
    return StatusCode::SUCCESS;
}


StatusCode RootIOCnvSvc::finalize()
{
    map<string,RootOutputStream*>::iterator it, done = m_outputStreamMap.end();
    for (it = m_outputStreamMap.begin(); it != done; ++it) {
        bool okay = it->second->close();
        if (!okay) {
            MsgStream log(msgSvc(), "RootIOCnvSvc");
            log << MSG::WARNING
                << "error in closing file for " << it->first
                << endreq;
        }            
    }
    if (m_outputStreamMap.size()) {
        RootOutputFileManager::get().setIncidentSvc(0); // trigger a release
    }
    return ConversionSvc::finalize();
}

bool RootIOCnvSvc::isReadoutForced() const
{
    return m_forceReadout;
}

StatusCode RootIOCnvSvc::queryInterface(const InterfaceID& riid, void** ppint)
{
    MsgStream log(msgSvc(), "RootIOCnvSvc");

    if (IID_IRootIOSvc.versionMatch(riid)) {
        log << MSG::DEBUG << "queryInterface("<<riid<<") --> (IRootIOSvc*)" 
            << (void*)this
            << endreq;
        *ppint = (IRootIOSvc*)this;
    }
    else if (IID_IConversionSvc.versionMatch(riid)) {
        log << MSG::DEBUG << "queryInterface("<<riid<<") --> (IConversionSvc*)"
            << (void*)this
            << endreq;        
        *ppint = (IConversionSvc*)this;
    }
    else {
        return this->ConversionSvc::queryInterface(riid,ppint);
    }
    addRef();
    return StatusCode::SUCCESS;
}

---