---

RCWNTupleCnv.cpp

Go to the documentation of this file.

#define ROOTHISTCNV_RCWNTUPLECNV_CPP

#define ALLOW_ALL_TYPES

// Compiler include files
#include <cstdio>

// Include files
#include "GaudiKernel/xtoa.h"
#include "GaudiKernel/CnvFactory.h"
#include "GaudiKernel/INTupleSvc.h"

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

#include "RCWNTupleCnv.h"

#include "TTree.h"

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

// Instantiation of a static factory class used by clients to create
// instances of this service
static CnvFactory<RootHistCnv::RCWNTupleCnv> s_factory;
const ICnvFactory& RootHistRCWNTupleCnvFactory = s_factory;


StatusCode RootHistCnv::RCWNTupleCnv::declare(long /* idh */, INTuple* /* nt */)  {
  MsgStream log(msgSvc(), "RCWNTupleCnv");
//    log << MSG::DEBUG << "RCWNTupleCnv::declare(id, ntup)" << endreq;

  return StatusCode::FAILURE;
}

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

template <class T> void analyzeItem(std::string typ, 
                                    const NTuple::_Data<T>* it, 
                                    std::string& desc,
                                    std::string& block_name,
                                    long& size)    {

  std::string full_name, var_name;
  full_name = it->name();
  RootHistCnv::parseName(full_name,block_name,var_name);

  long item_size = (sizeof(T) < 4) ? 4 : sizeof(T);
  long dimension = it->length();
  long ndim = it->ndim()-1;
  char text[132];
  desc += var_name;
  if ( it->hasIndex() || it->length() > 1 )   {
    desc += "[";
  }
  for ( int i = 0; i < ndim; i++ )   {
    desc += ::_itoa(it->dim(i), text, 10);
    desc += "][";
  }
  if ( it->hasIndex() )   {
    std::string ind_blk, ind_var;
    std::string ind = it->index();
    RootHistCnv::parseName(ind,ind_blk,ind_var);
    if (ind_blk != block_name) {
      std::cerr << "ERROR: Index for CWNT variable " << ind_var 
                << " is in a differnt block: " << ind_blk << std::endl;
    }
    desc += ind_var;
  }
  else if ( it->dim(ndim) > 1 )   {
    desc += ::_itoa(it->dim(ndim), text, 10);
  }

  if ( it->hasIndex() || it->length() > 1 )   {
    desc += "]";
  }

  desc += typ;
  size += item_size * dimension;

}

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

StatusCode RootHistCnv::RCWNTupleCnv::book(long /* idh */, const std::string& /* loc */, INTuple* nt)  {
  MsgStream log(msgSvc(), "RCWNTupleCnv");
//      log << MSG::DEBUG << "book(idh, loc, ntup)" << endreq;


  std::string rt_path, rt_fid, rt_id, rt_lid;
  TTree* rtree;

  DataObject* pObj = dynamic_cast<DataObject*>(nt);
  if (pObj != 0) {
    rt_lid = pObj->localPath();
    rt_id = "t" + rt_lid.substr(1,rt_lid.length()-1);
    rt_fid = pObj->fullpath();
    rt_path = pObj->location();
  } else {
    log << MSG::ERROR << "dynamic cast failed" << endreq;
    return StatusCode::FAILURE;
  }
  
  if (findNTuple(rt_fid,rtree).isFailure()) {

    rtree = new TTree(rt_id.c_str(),nt->title().c_str());
//      log << MSG::DEBUG << "created tree id: " << rtree->GetName() 
//      << "  title: "<< nt->title() << endreq;


    // Put it in the treemap
    regNTuple(rt_fid,rtree);
//      log << MSG::DEBUG << "added to treemap: " << rt_fid << endreq;

    // Loop over the items
    std::string block_name,var_name;
    long size = 0;
    long cursize, oldsize = 0;
    std::vector<long> item_size;
    std::vector<std::pair<std::string,std::string> > item_name;

    const INTuple::ItemContainer& cols = nt->items();
    for (INTuple::ItemContainer::const_iterator i = cols.begin(); 
         i != cols.end(); ++i )   {

      std::string item = "";
      switch( (*i)->type() )   {
        
      case DataTypeInfo::INT:               // int 
        analyzeItem(rootVarType( (*i)->type() ), 
                    dynamic_cast<const NTuple::_Data<int>*>(*i),item,
                    block_name,size);
        break;
      case DataTypeInfo::SHORT:             // short
        analyzeItem(rootVarType( (*i)->type() ), 
                    dynamic_cast<const NTuple::_Data<short>*>(*i),item,
                    block_name,size);
        break;
      case DataTypeInfo::LONG:              // long 
        analyzeItem(rootVarType( (*i)->type() ), 
                    dynamic_cast<const NTuple::_Data<long>*>(*i),item,
                    block_name,size);
        break;
      case DataTypeInfo::UCHAR:             // unsigned char 
        analyzeItem(rootVarType( (*i)->type() ), 
                    dynamic_cast<const NTuple::_Data<unsigned char>*>(*i),
                    item,block_name,size);
        break;
      case DataTypeInfo::USHORT:            // unsigned short
        analyzeItem(rootVarType( (*i)->type() ), 
                    dynamic_cast<const NTuple::_Data<unsigned short>*>(*i),
                    item,block_name,size);
        break;
      case DataTypeInfo::UINT:              // unsigned int 
        analyzeItem(rootVarType( (*i)->type() ), 
                    dynamic_cast<const NTuple::_Data<unsigned int>*>(*i),
                    item,block_name,size);
        break;
      case DataTypeInfo::ULONG:             // unsigned long 
        analyzeItem(rootVarType( (*i)->type() ), 
                    dynamic_cast<const NTuple::_Data<unsigned long>*>(*i),
                    item,block_name,size);
        break;
      case DataTypeInfo::DOUBLE:            // double 
        analyzeItem(rootVarType( (*i)->type() ), 
                    dynamic_cast<const NTuple::_Data<double>*>(*i),item,
                    block_name,size);
        break;
      case DataTypeInfo::FLOAT:             // float 
        analyzeItem(rootVarType( (*i)->type() ), 
                    dynamic_cast<const NTuple::_Data<float>*>(*i),item,
                    block_name,size);
        break;
      default:
        break;
      }
            
      item_name.push_back(std::pair<std::string,std::string>(block_name,item));
      cursize = size - oldsize;
      item_size.push_back(size-cursize);
      oldsize = size;
    }
    char* buff = new char[size];
    nt->setBuffer(buff);

    std::string block_desc = "";
    char *buf_pos = buff;

    std::vector<std::pair<std::string,std::string> >::const_iterator itr,itr1,end;
    end = item_name.end();
    int cnt = 0;
    int pos = 0;
    bool inblk;

    std::string cur_blk;

    // Loop over items, ad them to the Tree Branches
    for (itr=item_name.begin(); itr!=end; ++itr) {
      cur_blk = (*itr).first;
      inblk = true;
      itr1 = itr;
      block_desc = "";
      pos += cnt;
      cnt = 0;

      while ( inblk ) {
        if ( itr1+1 == end ) {            // next is end
          inblk = false;
        } else if ( (itr1+1)->first != cur_blk ) {        // next is new block
          inblk = false;
        }

        block_desc += itr1->second + ":";

        ++cnt;
        ++itr1;
      }

      itr = itr1 - 1;

      buf_pos = buff + item_size[pos];
      block_desc.erase(block_desc.length()-1,1);

//     log << MSG::DEBUG << "buf: " << (void*) buff << "  " << (void*)buf_pos
//         << endreq;
      
      rtree->Branch(item_name[pos].first.c_str(), const_cast<char*>(buf_pos), 
                    block_desc.c_str());
      log << MSG::INFO << "ID " << rt_id << ": added branch: " 
          << item_name[pos].first << " : " << block_desc << endreq;

    }


    log << MSG::INFO << "Booked TTree with ID: " << rt_id
        << " \"" << nt->title() << "\" in directory " 
        << getDirectory() << endreq;
    //  << rt_path << endreq;

    return StatusCode::SUCCESS;

  }

  log << MSG::ERROR << "Column wise ROOT Tree " << rt_fid << " already exists."
      << endreq;
  return StatusCode::FAILURE;
}

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

StatusCode RootHistCnv::RCWNTupleCnv::writeData(long /* idh */, INTuple* nt)   {

  MsgStream log(msgSvc(), "RCWNTupleCnv");
//      log << MSG::DEBUG << "writeData(idh, ntup)" << endreq;

  std::string rt_id, rt_fid, rt_path;
  TTree* rtree = 0;

  DataObject* pObj = dynamic_cast<DataObject*>(nt);
  if (pObj != 0) {
    rt_fid = pObj->fullpath();
    rt_path = pObj->location();
  } else {
    log << MSG::ERROR << "dynamic cast failed" << endreq;
    return StatusCode::FAILURE;
  }

  if ( findNTuple(rt_fid,rtree).isFailure() ) {
    log << MSG::ERROR << "tree ID: " << rt_fid << " not found in treemap"
        << endreq;
    return StatusCode::FAILURE;
  }
  
  const INTuple::ItemContainer& cols = nt->items();
  char * tar = nt->buffer();
  for (INTuple::ItemContainer::const_iterator i = cols.begin(); i != cols.end(); i++ )   {
    switch( (*i)->type() )   {
    case DataTypeInfo::BOOL:              // bool
      tar += saveItem(tar, (bool*)(*i)->buffer(),   (*i)->length());
      break;
    case DataTypeInfo::CHAR:              // char
      tar += saveItem(tar, (char*)(*i)->buffer(),   (*i)->length());
      break;
    case DataTypeInfo::SHORT:             // short
      tar += saveItem(tar, (short*)(*i)->buffer(),  (*i)->length());
      break;
    case DataTypeInfo::INT:             // short
      tar += saveItem(tar, (int*)(*i)->buffer(),    (*i)->length());
      break;
    case DataTypeInfo::LONG:             // short
      tar += saveItem(tar, (long*)(*i)->buffer(),   (*i)->length());
      break;
    case DataTypeInfo::UCHAR:             // unsigned char
      tar += saveItem(tar, (unsigned char*)(*i)->buffer(),  (*i)->length());
      break;
    case DataTypeInfo::USHORT:            // unsigned short
      tar += saveItem(tar, (unsigned short*)(*i)->buffer(), (*i)->length());
      break;
    case DataTypeInfo::UINT:            // unsigned short
      tar += saveItem(tar, (unsigned int*)(*i)->buffer(),   (*i)->length());
      break;
    case DataTypeInfo::ULONG:            // unsigned short
      tar += saveItem(tar, (unsigned long*)(*i)->buffer(),  (*i)->length());
      break;
    case DataTypeInfo::FLOAT:            // unsigned short
      tar += saveItem(tar, (float*)(*i)->buffer(), (*i)->length());
      break;
    case DataTypeInfo::DOUBLE:            // unsigned short
      tar += saveItem(tar, (double*)(*i)->buffer(), (*i)->length());
      break;
    default:
      break;
    }
  }

  // Fill the tree;
  rtree->Fill();

  nt->reset();
  
  return StatusCode::SUCCESS;

}

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

StatusCode RootHistCnv::RCWNTupleCnv::readData(long /* idh */, INTuple* /* ntup */, long /* ievt */)    {
  MsgStream log(msgSvc(), "RCWNTupleCnv");
//    log << MSG::DEBUG << "readData(idh, ntup, ievt)" << endreq;

  return StatusCode::FAILURE;
}

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

StatusCode RootHistCnv::RCWNTupleCnv::load(long /* idh */, INTuple*& /* refpObject */)   {
  //  MsgStream log(msgSvc(), "RootHistNTupleCnv");
  MsgStream log(msgSvc(), "RCWNTupleCnv");
//    log << MSG::DEBUG << "load(idh, refpObj)" << endreq;

  return StatusCode::FAILURE;

}

---