---

RNTupleCnv.cpp

Go to the documentation of this file.

#define ROOTHISTCNV_RNTUPLECNV_CPP


// Include files
#include "GaudiKernel/CnvFactory.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/GenericLink.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/INTupleSvc.h"

#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/NTuple.h"
#include "NTupleInfo.h"
#include "RNTupleCnv.h"

#include <list>
#include "TROOT.h"
#include "TDirectory.h"
#include "TFile.h"

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


RootHistCnv::RNTupleCnv::RNTupleCnv( ISvcLocator* svc, const CLID& clid )
: RConverter(clid, svc), m_ntupleSvc(0)         {
}


RootHistCnv::RNTupleCnv::~RNTupleCnv()             {
}


StatusCode RootHistCnv::RNTupleCnv::initialize()   {
  StatusCode status = Converter::initialize();
  if ( status.isSuccess() )   {
    status = serviceLocator()->getService( "NTupleSvc", IID_INTupleSvc, (IInterface*&)m_ntupleSvc);
  }
  return status;
}


StatusCode RootHistCnv::RNTupleCnv::finalize()     {
  if ( m_ntupleSvc != 0 )     {
    //    m_ntupleSvc->release();
  }
  m_ntupleSvc = 0;
  return Converter::finalize();
}


StatusCode RootHistCnv::RNTupleCnv::updateObj(IOpaqueAddress* pAddress, DataObject* pObject)   {
  StatusCode status = StatusCode::FAILURE;
  try   {
    GenericLinkBase::GENERIC* gen = pAddress->genericLink()->genericInfo();
    setDirectory(pAddress->containerName());
    status = readData(gen->m_info[0], dynamic_cast<INTuple*>(pObject), ++gen->m_info[1]);
  }
  catch (...)   {
  }
  return status;
}


StatusCode RootHistCnv::RNTupleCnv::createObj(IOpaqueAddress* pAddress, DataObject*& refpObject)   {
  long id = pAddress->genericLink()->genericInfo()->m_info[0];
  StatusCode status = readObject( pAddress->containerName(), id );
  if ( status.isSuccess() )   {
    MsgStream log(msgSvc(), "RNTupleCnv");
    INTuple* nt = 0;
//      log << MSG::DEBUG;
    //    if ( log.isActive() ) ::HPRINT (id);
    status = load(id, nt);
    refpObject = dynamic_cast<DataObject*>(nt);
  }
  return status;
}


StatusCode RootHistCnv::RNTupleCnv::createRep(DataObject* pObject, IOpaqueAddress*& pAddr)  {
  MsgStream log (msgSvc(), "RNTupleCnv");
//    log << MSG::DEBUG << "createRep(pObj, pAddr)" << endreq;
  
  pAddr = 0;
  try   {
    long id = 0;
    const std::string& loc = pObject->location();
    // Get address again....it does not change
    pAddr = pObject->address();
    if ( 0 == pAddr )    {
      char* stop = 0;
      const char* desc = pObject->localPath().data()+1;
      id = ::strtol(desc, &stop, 10);
      StatusCode status = createDirectory(loc);
      if ( !status.isSuccess() )   {
        return status;
      }
      //      setDirectory(loc);
      setDiskDirectory(loc);
      status = book(id, diskDirectory(loc), dynamic_cast<INTuple*>(pObject));
      if ( !status.isSuccess() )   {
        return status;
      }
      status = createAddress( pObject, id, pAddr );
      if ( !status.isSuccess() )   {
        return status;
      }
    }
    //    setDirectory(loc);    // Don't need to do this
    id = pAddr->genericLink()->genericInfo()->m_info[0];
    return writeData(id, dynamic_cast<INTuple*>(pObject));
  }
  catch (...)   {
  }
  return StatusCode::FAILURE;
}


StatusCode RootHistCnv::RNTupleCnv::updateRep(IOpaqueAddress* pAddress, DataObject* pObject)    {
  if ( 0 != pAddress )    {
    MsgStream log(msgSvc(), "RNTupleCnv");
    long id = pAddress->genericLink()->genericInfo()->m_info[0];

    std::string file = m_rootfile->GetName();
    file += ":/";
    gDirectory->cd(file.c_str());

    std::string full = pObject->fullpath();
//      TTree* tree;
//      log << MSG::INFO << "Saving ID: t" << id << " " << full << endreq;
//      log << MSG::INFO << "  gDirectory: " << gDirectory->GetPath() << endreq;
//      log << MSG::INFO << "  exists: " << findNTuple(full, tree) << endreq;
    return writeObject( pObject->location(), id );
  }
  return StatusCode::FAILURE;
}



std::string RootHistCnv::RNTupleCnv::rootVarType(int type) {

  std::string type_name;
  
  switch( type ) {
  case DataTypeInfo::SHORT:              // short
    type_name = "/S";
    break;
  case DataTypeInfo::INT:                // int
    type_name = "/I";
    break;
  case DataTypeInfo::LONG:               // long
    type_name = "/I";
    break;
  case DataTypeInfo::USHORT:             // ushort
    type_name = "/s";
    break;
  case DataTypeInfo::UINT:               // uint
    type_name = "/i";
    break;
  case DataTypeInfo::ULONG:              // ulong
    type_name = "/i";
    break;
  case DataTypeInfo::FLOAT:              // float
    type_name = "/F";
    break;
  case DataTypeInfo::DOUBLE:             // double
    type_name = "/D";
    break;
  default:
    break;
  }

  return ( type_name );

}

bool RootHistCnv::parseName(std::string full, std::string &blk, 
                            std::string &var) {
  int sp;
  if ( (sp=full.find("/")) != -1 ) {
    blk = full.substr(0,sp);
    var = full.substr(sp+1,full.length());
    return true;
  } else {
    blk = "AUTO_BLK";
    var = full;
    return false;
  }

}


#define INSTANTIATE(TYP)  \
template INTupleItem* createNTupleItem<TYP>(NTUPLEINFO& tags, long i, INTuple* tuple, TYP minimum, TYP maximum, long& size);

namespace RootHistCnv  {
  template<class TYP>
  INTupleItem* createNTupleItem (NTUPLEINFO& tags, long i, INTuple* tuple, TYP minimum, TYP maximum, long& size)   {
    size = 0;
    INTupleItem* col = 0;
    if ( tags.isRangeWithin(i, minimum,maximum)) {
      long ind = tags.getIndex(tags.index[i]);
      long dim1 = 1, dim2 = 1;
      TYP min, max, null;
      tags.getBounds(i, min, max, null); 
      switch( tags.dim[i] )   {
      case 0:            
        col = NTuple::_Item<TYP>::create (tuple, tags.name[i], min, max, null);
        break;            
      case 1:             
        dim1 = (ind>=0) ? tags.idist(ind) : tags.theDim[i][0];
        col = NTuple::_Array<TYP>::create (tuple, tags.name[i], tags.index[i], dim1, min, max, null);\
        break;           
      case 2:              
        dim1 = (ind>=0) ? tags.idist(ind) : tags.theDim[i][0];
        dim2 = (ind>=0) ? tags.theDim[i][0] : tags.theDim[i][1];
        col = NTuple::_Matrix<TYP>::create (tuple, tags.name[i],tags.index[i],dim1,dim2,min,max,null);\
        break;
      default:
        break;
      }
      size += dim1 * dim2 * ((sizeof(TYP) < 4) ? 4 : sizeof(TYP)); 
    }
    return col;
  }

  INSTANTIATE(float)
  INSTANTIATE(double)
  INSTANTIATE(bool)
  INSTANTIATE(char)
  INSTANTIATE(int)
  INSTANTIATE(short)
  INSTANTIATE(long)
  INSTANTIATE(unsigned char)
  INSTANTIATE(unsigned int)
  INSTANTIATE(unsigned short)
  INSTANTIATE(unsigned long)
};

---