---

RConverter.cpp

Go to the documentation of this file.

#define ROOTHISTCNV_RCONVERTER_CPP


// Include files
#include "GaudiKernel/xtoa.h"
#include "GaudiKernel/CnvFactory.h"
#include "GaudiKernel/GenericAddress.h"
#include "GaudiKernel/IDataProviderSvc.h"

#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/RegistryEntry.h"
#include "GaudiKernel/NTuple.h"
#include "RConverter.h"

#include "TDirectory.h"
#include "TFile.h"
#include "TTree.h"
#include <string>
#include <list>

// Statics:
TFile *RootHistCnv::RConverter::m_rootfile = 0;
std::map<std::string,TTree*> RootHistCnv::RConverter::m_treeMap;



//------------------------------------------------------------------------------
//
// Implementation of class :  RootHistCnv::RConverter
//
// Author :                   Charles Leggett
//
//------------------------------------------------------------------------------


// Create ROOT sub directories if they do not exist according to the 
// store location
StatusCode RootHistCnv::RConverter::createSubDirs(const std::string& /* top */, const std::string& /* loc */)    {
  MsgStream log(msgSvc(), "RConverter");
//    log << MSG::DEBUG << "createSubDirs(" << top << ", " << loc << ")" << endreq;

  return StatusCode::SUCCESS;
}


StatusCode RootHistCnv::RConverter::createDirectory(const std::string& loc)    {
  MsgStream log(msgSvc(), "RConverter");

  // Get rid of leading /NTUPLES
  std::string full;
  full = diskDirectory( loc );
//    log << MSG::DEBUG << "createDirectory(" <<  full << ")" << endreq;

  int p,i;
  std::string fil,cur,s;
  TDirectory *gDir;

  gDir = gDirectory;

  std::list<std::string> lpath;
  i = 1;

  if ( (p=full.find(":",0)) != -1 ) {
    fil = full.substr(0,p);
    i = p+1;
    fil += ":/";
    gDirectory->cd(fil.c_str());
  }

  while ( (p = full.find("/",i)) != -1) {
    s = full.substr(i,p-i);
    lpath.push_back(s);
    i = p+1;
  }
  lpath.push_back( full.substr(i,full.length()-i) );

  if ( full.substr(0,1) == "/") {
    gDirectory->cd("/");
  }

  std::list<std::string>::const_iterator litr;
  for(litr=lpath.begin(); litr!=lpath.end(); ++litr) {
    cur = *litr;
    if (! gDirectory->GetKey(litr->c_str()) ) { 
      gDirectory->mkdir(litr->c_str()); 
    }
    gDirectory->cd(litr->c_str());
  }

  gDirectory = gDir;

  return StatusCode::SUCCESS;
}


std::string RootHistCnv::RConverter::diskDirectory(const std::string& loc)   {

  // Get rid of leading /NTUPLES
  std::string dir;
  long ll = loc.find("/NTUPLES/");
  if (ll == -1) {
    MsgStream log(msgSvc(), "RConverter");
    log << MSG::ERROR << "diskDirectory(" << loc << ")" 
        << " --> no leading /NTUPLES/" << endreq;
    return loc;
  }
  dir = loc.substr(ll+8,loc.length()-ll-8);

  return dir;
}


std::string RootHistCnv::RConverter::directory(const std::string& loc)   {

  return ( diskDirectory(loc) );

}


// Set RZ sub directories if they do not exist according to the store location
void RootHistCnv::RConverter::setDirectory(const std::string& loc)    {
  MsgStream log(msgSvc(), "RConverter");
//    log << MSG::DEBUG << "setDirectory(" << loc << ") " 
//        << directory(loc) << endreq;

  std::string full;
  
  // Get rid of leading /NTUPLES
  full = diskDirectory( loc );

  int p,i=1;
  std::string cur,sdir;

  gDirectory->cd("/");
  while ( (p = full.find("/",i)) != -1) {
    sdir = full.substr(i,p-i);
    if (! gDirectory->GetKey(sdir.c_str()) ) { 
      log << MSG::ERROR << "cannot cd to " << full << endreq;
      return;
    }
    gDirectory->cd(sdir.c_str());

    i = p+1;
  }
  gDirectory->cd( full.substr(i,full.length()-i).c_str() );

//    log << MSG::DEBUG << "  now in: " << gDirectory->GetPath() << endreq;

}


// Set sub directories if they do not exist according to the store location
void RootHistCnv::RConverter::setDiskDirectory(const std::string& loc)    {
  MsgStream log(msgSvc(), "RConverter");
//    log << MSG::DEBUG << "setDiskDirectory(" << loc << ") " 
//        << diskDirectory(loc) << endreq;

  setDirectory(loc);

  //  ::HCDIR(diskDirectory(loc), " ");
}

std::string RootHistCnv::RConverter::getDirectory() {

  std::string dir = gDirectory->GetPath();

  return (dir);

}
  

StatusCode RootHistCnv::RConverter::createAddress(DataObject* pObject, long id, IOpaqueAddress*& refpAddress)  {
  // Get address again....it does not change
  refpAddress = pObject->address();
  if ( 0 == refpAddress )    {
    std::string db;
    DataObject* parent = pObject->parent();
    if ( parent )   {
      IOpaqueAddress* pA = parent->address();
      if ( pA )   {
        db = pA->dbName();
      }
    }
    return createAddress(objType(), db, pObject->fullpath(), id, refpAddress);
  }
  return StatusCode::SUCCESS;
}


StatusCode RootHistCnv::RConverter::createAddress(DataObject* pObject, const std::string& title, IOpaqueAddress*& refpAddress)  {
  // Get address again....it does not change
  const std::string loc = pObject->location();
  refpAddress = pObject->address();
  if ( 0 == refpAddress )    {
    std::string db;
    const std::string& path = pObject->fullpath();
    DataObject* parent = pObject->parent();
    if ( parent )   {
      IOpaqueAddress* pA = parent->address();
      if ( pA )   {
        db = pA->dbName();
      }
    }
    return createAddress(objType(), db, path, title, refpAddress);
  }
  return StatusCode::SUCCESS;
}


StatusCode RootHistCnv::RConverter::createAddress(const CLID& clid, const std::string& /* db */, const std::string& loc, const std::string& obj, IOpaqueAddress*& refpAddress)   {
  GenericAddress* pA = new GenericAddress(repSvcType() , clid);
  std::string fullname = loc;
  if ( obj[0] != '/' ) fullname += "/";
  fullname += obj;
  pA->genericInfo()->m_info[0] = 0;
  pA->setContainerName(loc);
  pA->setObjectName(fullname);
  refpAddress = pA;
  return StatusCode::SUCCESS;
}


StatusCode RootHistCnv::RConverter::createAddress(const CLID& clid, const std::string& db, const std::string& loc, long id, IOpaqueAddress*& refpAddress)   {
  char obj[32];
  StatusCode status = createAddress(clid, db, loc, ::_itoa(id, obj, 10), refpAddress);
  if ( status.isSuccess() )   {
    refpAddress->genericLink()->genericInfo()->m_info[0] = id;
  }
  return status;
}


StatusCode RootHistCnv::RConverter::readObject(const std::string& loc, long /* id */)   {
  if ( createDirectory(loc).isSuccess() )     {
    setDiskDirectory(loc);
    setDirectory(loc);
    //    ::HRIN(id, icycle, ioff);
//      if ( ::HEXIST( id ) )    {
//        return StatusCode::SUCCESS;
//      }
  }
  return StatusCode::FAILURE;
}

StatusCode RootHistCnv::RConverter::writeObject(const std::string& loc, long id)   {

  TTree *tree;

  MsgStream log(msgSvc(), "RConverter");
//    log << MSG::INFO << "writeObject(" << loc << ")" << endreq;
//    log << MSG::DEBUG << "   file: " << m_rootfile->GetName() << endreq;

  setDirectory( loc );
  setDiskDirectory( loc );

  char tmp[80];
  std::string rt_fid = loc + "/" + _itoa(id,tmp,10);
  if (findNTuple(rt_fid,tree).isSuccess()) {

    //    tree->Write();

//      log << MSG::INFO;
//      if ( log.isActive() ) {
//        tree->Print();
//      }
//      log << endreq;

  }

  return StatusCode::SUCCESS;
}

StatusCode RootHistCnv::RConverter::regNTuple(const std::string id, const TTree* tree) {

  MsgStream log(msgSvc(), "RConverter");
//    log << MSG::DEBUG << "regNTuple(" << id << ")" << endreq;

  std::map<std::string,TTree*>::const_iterator imap;
  imap = m_treeMap.find(id);

  if ( imap != m_treeMap.end() ) {
    log << MSG::ERROR << "cannot register Ntuple " << id << ": already exists"
        << endreq;
    return StatusCode::FAILURE;
  }

  m_treeMap[id] = const_cast<TTree*>(tree);

  return StatusCode::SUCCESS;

}

StatusCode RootHistCnv::RConverter::findNTuple(const std::string id, TTree*& tree) {

  MsgStream log(msgSvc(), "RConverter");
//    log << MSG::DEBUG << "findNTuple(" << id << ")" << endreq;
  std::map<std::string,TTree*>::const_iterator imap;
  imap = m_treeMap.find(id);

  if ( imap == m_treeMap.end() ) {
//      log << MSG::ERROR << "cannot find Ntuple " << id << endreq;
    tree = 0;
    return StatusCode::FAILURE;
  }
  
  tree = (*imap).second;

  return StatusCode::SUCCESS;
}


const unsigned char RootHistCnv::RConverter::storageType()      {
  return ROOT_StorageType;
}


RootHistCnv::RConverter::RConverter( const CLID& clid, ISvcLocator* svc )
: Converter(RootHistCnv::RConverter::storageType(), clid, svc)  {
}


RootHistCnv::RConverter::~RConverter()                          {
}

---