RNTupleCnv.cpp

Go to the documentation of this file.

// Include files
#include "RNTupleCnv.h"
#include "NTupleInfo.h"
#include "RootObjAddress.h"

#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/INTupleSvc.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/NTuple.h"
#include "GaudiKernel/SmartIF.h"

// Root
#include "TTree.h"

#ifdef __ICC
// disable icc remark #1572: floating-point equality and inequality comparisons are unreliable
//     they are intended
#pragma warning( disable : 1572 )
#endif

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

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

//-----------------------------------------------------------------------------
StatusCode RootHistCnv::RNTupleCnv::initialize()
{
  //-----------------------------------------------------------------------------
  StatusCode status = Converter::initialize();
  if ( status.isSuccess() ) {
    m_ntupleSvc                = serviceLocator()->service( "NTupleSvc" );
    if ( !m_ntupleSvc ) status = StatusCode::FAILURE;
  }
  return status;
}

//-----------------------------------------------------------------------------
StatusCode RootHistCnv::RNTupleCnv::finalize()
{
  //-----------------------------------------------------------------------------
  m_ntupleSvc.reset();
  return Converter::finalize();
}

//-----------------------------------------------------------------------------
StatusCode RootHistCnv::RNTupleCnv::updateObj( IOpaqueAddress* pAddress, DataObject* pObject )
//-----------------------------------------------------------------------------
{
  MsgStream log( msgSvc(), "RNTupleCnv" );

  StatusCode status = StatusCode::FAILURE;

  RootObjAddress* rAddr = dynamic_cast<RootObjAddress*>( pAddress );

  if ( !rAddr ) {
    log << MSG::ERROR << "Could not dynamic cast to RootObjAddress" << endmsg;
    return StatusCode::FAILURE;
  }

  TTree* rtree = (TTree*)rAddr->tObj();

  try {
    unsigned long* info = (unsigned long*)pAddress->ipar();
    setDirectory( pAddress->par()[0] );
    status = readData( rtree, dynamic_cast<INTuple*>( pObject ), info[1]++ );
  } catch ( ... ) {
  }
  return status;
}

//-----------------------------------------------------------------------------
StatusCode RootHistCnv::RNTupleCnv::createObj( IOpaqueAddress* pAddress, DataObject*& refpObject )
//-----------------------------------------------------------------------------
{
  MsgStream log( msgSvc(), "RNTupleCnv" );

  IRegistry* pReg = pAddress->registry();

  //    log << MSG::WARNING << "adr: " << pAddress->par()[0] << " <> "
  //        << pAddress->par()[1] << " <> " << pAddress->ipar()[0] << " <> "
  //        << pAddress->ipar()[1] << " <> " << hex << rAddr->tObj()
  //        << dec << " <> " << pReg->identifier() << endmsg;

  std::string ident = pReg->identifier();

  StatusCode status = readObject( pAddress, refpObject ); // Doesn't do anything
  if ( status.isSuccess() ) {
    RootObjAddress* rAddr = dynamic_cast<RootObjAddress*>( pAddress );
    if ( !rAddr ) {
      log << MSG::ERROR << "Could not cast to RootObjAddress" << endmsg;
      return StatusCode::FAILURE;
    }
    INTuple* nt = nullptr;
    TTree* tobj = (TTree*)rAddr->tObj();
    status      = load( tobj, nt );
    if ( status.isSuccess() ) {
      refpObject = dynamic_cast<DataObject*>( nt );
    } else {
      log << MSG::ERROR << "Problems loading ntuple id: " << pReg->identifier() << endmsg;
    }
  }
  return status;
}

//-----------------------------------------------------------------------------
StatusCode RootHistCnv::RNTupleCnv::createRep( DataObject* pObject, IOpaqueAddress*& pAddr )
//-----------------------------------------------------------------------------
{
  GlobalDirectoryRestore restore;
  pAddr = nullptr;
  try {
    IRegistry* pReg = pObject->registry();
    if ( pReg ) {
      pAddr = pReg->address();
      if ( !pAddr ) {
        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 ) {
                TTree* pTree    = nullptr;
                std::string dsc = pReg->name().substr( 1 );
                gDirectory      = pParentDir;
                status          = book( dsc, dynamic_cast<INTuple*>( pObject ), pTree );
                if ( !status.isSuccess() ) {
                  return status;
                }
                status = createAddress( pObject, gDirectory, pTree, pAddr );
                if ( !status.isSuccess() ) {
                  return status;
                }
                return writeData( pTree, dynamic_cast<INTuple*>( pObject ) );
              }
            }
          }
        }
      } else {
        TDirectory* pDir      = (TDirectory*)pAddr->ipar()[0];
        RootObjAddress* rAddr = dynamic_cast<RootObjAddress*>( pAddr );
        if ( !rAddr ) {
          MsgStream log( msgSvc(), "RNTupleCnv" );
          log << MSG::ERROR << "Could not cast to RootObjAddress" << endmsg;
          return StatusCode::FAILURE;
        }
        TTree* pTree = (TTree*)rAddr->tObj();
        gDirectory   = pDir;
        return writeData( pTree, dynamic_cast<INTuple*>( pObject ) );
      }
    }
  } catch ( ... ) {
  }
  MsgStream log( msgSvc(), "RNTupleCnv" );
  log << MSG::ERROR << "Failed to create persistent N-tuple!" << endmsg;
  return StatusCode::FAILURE;
}

//-----------------------------------------------------------------------------
StatusCode RootHistCnv::RNTupleCnv::updateRep( IOpaqueAddress* pAddr, DataObject* pObj )
//-----------------------------------------------------------------------------
{
  MsgStream log( msgSvc(), "RNTupleCnv" );
  if ( pAddr ) {
    GlobalDirectoryRestore restore;
    TDirectory* pDir      = (TDirectory*)pAddr->ipar()[0];
    RootObjAddress* rAddr = dynamic_cast<RootObjAddress*>( pAddr );
    if ( !rAddr ) {
      log << MSG::ERROR << "Could not cast to RootObjAddress" << endmsg;
      return StatusCode::FAILURE;
    }
    TTree* pTree = (TTree*)rAddr->tObj();
    if ( pDir && pTree ) {
      gDirectory->cd( pDir->GetPath() );
      pTree->Write( "", TObject::kOverwrite );
      return StatusCode::SUCCESS;
    }
  } else {
    log << MSG::WARNING << "empty ntuple: " << pObj->registry()->identifier() << endmsg;
    return createRep( pObj, pAddr );
  }
  return StatusCode::FAILURE;
}


//-----------------------------------------------------------------------------
std::string RootHistCnv::RNTupleCnv::rootVarType( int type )
{
  //-----------------------------------------------------------------------------
  switch ( type ) {
  case DataTypeInfo::BOOL:
    return "/O"; // bool
  case DataTypeInfo::SHORT:
    return "/S"; // short
  case DataTypeInfo::INT:
    return "/I"; // int
  case DataTypeInfo::LONG:
    return "/I"; // long
  case DataTypeInfo::LONGLONG:
    return "/L"; // longlong
  case DataTypeInfo::USHORT:
    return "/s"; // ushort
  case DataTypeInfo::UINT:
    return "/i"; // uint
  case DataTypeInfo::ULONG:
    return "/i"; // ulong
  case DataTypeInfo::ULONGLONG:
    return "/l"; // ulonglong
  case DataTypeInfo::FLOAT:
    return "/F"; // float
  case DataTypeInfo::DOUBLE:
    return "/D"; // double
  case DataTypeInfo::CHAR:
    return "/B"; // char
  case DataTypeInfo::UCHAR:
    return "/b"; // char
  default:
    return "";
  }
  // cannot reach this point
}

//-----------------------------------------------------------------------------
bool RootHistCnv::parseName( const 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 );
    return true;
  } else {
    blk = "AUTO_BLK";
    var = full;
    return false;
  }
}

//-----------------------------------------------------------------------------

#define INSTANTIATE( TYP )                                                                                             \
  template INTupleItem* createNTupleItem<TYP>( std::string itemName, std::string blockName, std::string index_name,    \
                                               int indexRange, int arraySize, TYP minimum, TYP maximum,                \
                                               INTuple* tuple )

namespace RootHistCnv
{

  template <class TYP>
  INTupleItem* createNTupleItem( std::string itemName, std::string blockName, std::string indexName, int indexRange,
                                 int arraySize, TYP min, TYP max, INTuple* ntup )
  {

    std::string varName;
    if ( blockName != "" ) {
      varName = blockName + "/" + itemName;
    } else {
      varName = itemName;
    }

    TYP null         = 0;
    INTupleItem* col = nullptr;

    if ( min == 0 && max == 0 ) {
      min = NTuple::Range<TYP>::min();
      max = NTuple::Range<TYP>::max();
    }

    if ( indexName == "" ) {

      if ( arraySize == 1 ) {
        // simple items
        col = NTuple::_Item<TYP>::create( ntup, varName, typeid( TYP ), min, max, null );

      } else {
        // Arrays of fixed size
        col = NTuple::_Array<TYP>::create( ntup, varName, typeid( TYP ), "", arraySize, min, max, null );
      }

    } else {

      if ( arraySize == 1 ) {
        // Arrays of variable size
        col = NTuple::_Array<TYP>::create( ntup, varName, typeid( TYP ), indexName, indexRange, min, max, null );
      } else {
        // Matrices
        col = NTuple::_Matrix<TYP>::create( ntup, varName, typeid( TYP ), indexName, indexRange, arraySize, min, max,
                                            null );
      }
    }

    return col;
  }

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