RConverter.cpp

Go to the documentation of this file.

#define ROOTHISTCNV_RCONVERTER_CPP

// Include files
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/SmartIF.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/MsgStream.h"
#include "RConverter.h"
#include "RootObjAddress.h"

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

namespace  {
  std::map<std::string,TFile*> s_fileMap;
}

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

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

  std::string fil,cur,s;
  TDirectory *gDir = gDirectory;

  TFile *tf = nullptr;
  if ( findTFile(loc,tf).isSuccess() ) {
    tf->cd();
  }

  std::vector<std::string> lpath;
  int i = 1;

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

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

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

  for(const auto& litr : lpath ) {
    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/{INPUT_STREAM} or /stat/{INPUT_STREAM}
  std::string dir;
  long lf1 = loc.find("/NTUPLES/");
  long lf2 = loc.find("/stat/");
  long ll;
  if (lf1 != -1) {
    ll = loc.find("/",lf1+9);

  } else if (lf2 != -1) {
    ll = loc.find("/",lf2+6);

  } else {
    MsgStream log(msgSvc(), "RConverter");
    log << MSG::ERROR << "diskDirectory(" << loc << ")"
    << " --> no leading /NTUPLES/ or /stat/" << endmsg;
    return loc;
  }
  //  dir = loc.substr(ll+8);

  if (ll == -1) {
    dir = "/";
  } else {
    dir = loc.substr(ll);
  }

  return dir;
}

//-----------------------------------------------------------------------------
std::string RootHistCnv::RConverter::directory(const std::string& loc)
//-----------------------------------------------------------------------------
{
  return diskDirectory(loc);
}

//-----------------------------------------------------------------------------
void RootHistCnv::RConverter::setDirectory(const std::string& loc)
//-----------------------------------------------------------------------------
{
  MsgStream log(msgSvc(), "RConverter");
  TFile *tf = nullptr;

  std::string full = diskDirectory( loc );

  // get associated TFile
  if ( findTFile(loc,tf).isSuccess() ) {
    tf->cd();
  } else {
    log << MSG::ERROR << "error getting TFile name " << loc << endmsg;
  }

  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 << " from "
      << gDirectory->GetPath() << endmsg;
      return;
    }
    gDirectory->cd(sdir.c_str());

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

//-----------------------------------------------------------------------------
void RootHistCnv::RConverter::setDiskDirectory(const std::string& loc)
//-----------------------------------------------------------------------------
{
  setDirectory(loc);
}

//-----------------------------------------------------------------------------
std::string RootHistCnv::RConverter::getDirectory()
//-----------------------------------------------------------------------------
{
  return gDirectory->GetPath();
}


//-----------------------------------------------------------------------------
StatusCode RootHistCnv::RConverter::createAddress(DataObject* pObj,
                                                  TDirectory* pDir,
                                                  TObject* pTObj,
                                                  IOpaqueAddress*& refpAddr)
//-----------------------------------------------------------------------------
{
  // Get address again....it does not change
  IRegistry* pReg = pObj->registry();
  if ( pReg )    {
    refpAddr = pReg->address();
    if ( !refpAddr )    {
      refpAddr = new RootObjAddress(repSvcType(),
                    objType(),
                    pReg->name(),
                    "",
                    (unsigned long)(pDir),
                    (unsigned long)(pTObj),
                    pTObj);

      return StatusCode::SUCCESS;
    }
  }
  return StatusCode::FAILURE;
}

//--------------------------------------------------------------------------
StatusCode RootHistCnv::RConverter::createAddress(const std::string& rzdir,
                          const CLID& clid,
                          const std::string& title,
                          TObject* pTObj,
                          IOpaqueAddress*& refpAddress)
//--------------------------------------------------------------------------
{
  RootObjAddress* pA = new RootObjAddress(repSvcType(),
                      clid,
                      rzdir,
                      title,
                      0,
                      0,
                      pTObj );

  refpAddress = pA;
  return StatusCode::SUCCESS;
}


//--------------------------------------------------------------------------
StatusCode RootHistCnv::RConverter::createAddress(const std::string& rzdir,
                          const CLID& clid,
                          long id,
                          TObject* pTobj,
                          IOpaqueAddress*& refpAddress)
//--------------------------------------------------------------------------
{
  auto obj = std::to_string(id);
  StatusCode status = createAddress(rzdir, clid, obj, pTobj, refpAddress);
  if ( status.isSuccess() )   {
    unsigned long* ipar = (unsigned long*)refpAddress->ipar();
    ipar[0] = id;
  }
  return status;
}

//-----------------------------------------------------------------------------
TDirectory* RootHistCnv::RConverter::changeDirectory(DataObject* pObject)
//-----------------------------------------------------------------------------
{
  if ( pObject )    {
    IRegistry* pReg = pObject->registry();
    if ( pReg )    {
      auto dataMgr = dataProvider().as<IDataManagerSvc>();
      if ( dataMgr )    {
        IRegistry* pParentReg = nullptr;
        StatusCode status = dataMgr->objectParent(pReg, pParentReg);
        if ( status.isSuccess() )  {
          IOpaqueAddress* pParAddr = pParentReg->address();
          if ( pParAddr )   {
            TDirectory* pParentDir = (TDirectory*)pParAddr->ipar()[0];
            if ( pParentDir )   {
              gDirectory->cd(pParentDir->GetPath());
              return pParentDir;
            }
          }
        }
      }
    }
  }
  return nullptr;
}

//-----------------------------------------------------------------------------
StatusCode RootHistCnv::RConverter::createRep(DataObject* pObject,
                                              IOpaqueAddress*& pAddr)
//-----------------------------------------------------------------------------
{
  GlobalDirectoryRestore restore;
  pAddr = nullptr;
  try   {
    TDirectory* pParentDir = changeDirectory(pObject);
    if ( pParentDir )   {
      TObject* pTObj = createPersistent(pObject);
      if ( pTObj )   {
        pTObj->Write();
        delete pTObj;
        return createAddress(pObject, pParentDir, 0, pAddr);
      }
    }
  }
  catch (...)   {
  }
  MsgStream log (msgSvc(), "RConverter");
  log << MSG::ERROR << "Failed to create persistent Object!" << endmsg;
  return StatusCode::FAILURE;
}

//-----------------------------------------------------------------------------
StatusCode RootHistCnv::RConverter::readObject(IOpaqueAddress* /* pAddr */ ,
                                               DataObject*&   /* refpObj */ )
{
//    MsgStream log(msgSvc(), "RConverter::readObject");
//    log << MSG::WARNING << pAddr->par()[0] << " <> " << pAddr->par()[1]
//        << " <> "
//        << pAddr->ipar()[0] << " <> " << pAddr->ipar()[1] << " <> "
//        << pAddr->registry()->identifier() << endmsg;

  return StatusCode::SUCCESS;
}

//-----------------------------------------------------------------------------
TObject* RootHistCnv::RConverter::createPersistent(DataObject*   /* pObj */)
{
  return nullptr;
}


//-----------------------------------------------------------------------------
StatusCode RootHistCnv::RConverter::regTFile(const std::string id,
                         const TFile* tfile)
//-----------------------------------------------------------------------------
{
  auto imap = s_fileMap.find(id);
  if ( imap != s_fileMap.end() ) {
    MsgStream log(msgSvc(), "RConverter");
    log << MSG::ERROR << "cannot register TTree " << id
        << ": already exists" << endmsg;
    return StatusCode::FAILURE;
  }
  s_fileMap[id] = const_cast<TFile*>(tfile);

  return StatusCode::SUCCESS;
}

//-----------------------------------------------------------------------------
StatusCode RootHistCnv::RConverter::findTFile(const std::string id,
                          TFile*& tfile)
//-----------------------------------------------------------------------------
{
  MsgStream log(msgSvc(), "RConverter");
  tfile = nullptr;

  std::string idm;

  // make sure we only get first two parts of id
  int i1,i2,i3;
  i1 = id.find("/",0);
  if (i1 != 0) {
    log << MSG::ERROR << "Directory name does not start with \"/\": "
    << id << endmsg;
    return StatusCode::FAILURE;
  }
  i2 = id.find("/",i1+1);
  if (i2 == -1) {
    log << MSG::ERROR << "Directory name has only one part: " << id << endmsg;
    return StatusCode::FAILURE;
  }
  i3 = id.find("/",i2+1);
  if (i3 == -1) {
    idm = id;
  } else {
    idm = id.substr(0,i3);
  }

  auto imap = s_fileMap.find(idm);
  if ( imap == s_fileMap.end() ) return StatusCode::FAILURE;
  tfile = imap->second;
  return StatusCode::SUCCESS;
}
//-----------------------------------------------------------------------------
std::string RootHistCnv::RConverter::convertId(const std::string& id ) const
//-----------------------------------------------------------------------------
{
  bool forced = false;
  if ( id.size() > 0 && isdigit(id[0]) ) {
    try {
      BooleanProperty tmp;
      tmp.assign(conversionSvc().as<IProperty>()->getProperty( "ForceAlphaIds"));
      forced = tmp.value();
    }
    catch ( ... ) { }
  }
  if (forced )  return "h" + id;
  else          return id;
}
//-----------------------------------------------------------------------------
StatusCode RootHistCnv::RConverter::error(const std::string& msg)
//-----------------------------------------------------------------------------
{
  MsgStream log(msgSvc(), "RootHistCnv");
  log << MSG::ERROR << msg << endmsg;
  return StatusCode::FAILURE;
}