RootNTuple.cxx

Go to the documentation of this file.

#include "RootNTuple.h"

#include "RootBranch.h"

#include "axes/Range.h"
#include "datasrcs/DataSourceException.h"

#include "TLeaf.h"
#include "TBranch.h"
#include "TTree.h"
#include "TObjArray.h"

#ifdef _MSC_VER
#define isinf _isinf
#endif

#ifdef SSTREAM_DEFECT
#include <strstream>
using std::ostrstream;
#else
#include <sstream>
using std::ostringstream;
#endif

#include <vector>

#include <cmath>

#include <cassert>

using std::string;
using std::vector;

RootNTuple::
RootNTuple ( TTree * tree )
  : DataSource ( false ),
    m_tree ( tree ),
    m_cur_entry ( UINT_MAX )
{
  initBranches ();
}

RootNTuple::
RootNTuple ( )
  : DataSource ( false ),
    m_tree ( 0 ),
    m_cur_entry ( UINT_MAX )
{
}

RootNTuple::~RootNTuple()
{
}

void
RootNTuple::
copy ( const DataSource & )
{
  assert ( false );
}

void 
RootNTuple::
initBranches( )
{
  TObjArray * branches = m_tree -> GetListOfBranches ();
  Int_t number = branches -> GetEntries ();
  
  for ( Int_t i = 0; i < number; i++ )
    {
      TObject * object = branches -> At ( i );
      TBranch * branch = dynamic_cast < TBranch * > ( object );
      if ( branch != 0 )
        {
          branch -> SetBasketSize ( 320000 );
          
          RootBranch * h_branch = new RootBranch ( branch );
          const string name = object -> GetName ();

          addColumn ( name, h_branch );
          m_multiDimensional.push_back( h_branch -> isMultiDimensional() );
          
        }
    }
}

bool
RootNTuple::
rotateWheels( std::vector < int > & wheels,
              const std::vector < int > & sz,
              unsigned int d )
{
  bool full = false;
  
  if( d < sz.size() - 1 ) // Still not at the last wheel...
    {
      if( rotateWheels( wheels, sz, d + 1 ) == true )
        {
          wheels[d]++;

          full = ( wheels[d] == static_cast< int >( sz[d] )  ) ? true : false;

          if( full )
            wheels[d] = 0;
          
          return full;
        }
    }
  else // Finally at the last wheel. Phew!
    {
      wheels[ d ]++;
      full = ( wheels[d] == static_cast< int >( sz[d] )  ) ? true : false;

      if( full )
        wheels[ d ] = 0;
      return full;
    }
  
  return full;
}

void
RootNTuple::
notifyObservers ( ) const
{
  Observable::notifyObservers ();
}

unsigned int
RootNTuple::
rows() const
{
  Double_t number =  m_tree -> GetEntries ();
  return static_cast < unsigned int > ( number );
}

void
RootNTuple::
fillDataCache ( unsigned int column )
{
  unsigned int size = rows ();
  vector < double > * cache = new vector < double > ( size );
  RootBranch * data = m_data [ column ];
  for ( unsigned int row = 0; row < size; row++ ) {
    double value = data -> valueAt ( row );
    cache -> operator [] ( row ) = value;
  }
  m_data_cache [ column ] = cache;
}

bool
RootNTuple::
empty () const
{
  return rows () == 0;
}

double
RootNTuple::
valueAt ( unsigned int row, unsigned int column ) const
{
  if ( m_data_cache [ column ] == 0 ) {
    RootNTuple * rtuple = const_cast < RootNTuple * > ( this );
    rtuple -> fillDataCache ( column );
  }
  const vector < double > & cache = *m_data_cache [ column ];

  return cache[row];
}

using namespace hippodraw;

RootData::Type
RootNTuple::
getType ( unsigned int column ) const
{
  RootBranch * data = m_data [ column ];

  return data -> getType ();
}

double *
RootNTuple::
doubleArrayAt ( unsigned int row, unsigned int column ) const
{
  RootBranch * data = m_data [ column ];

  return data -> doubleArrayAt ( row );
}

float *
RootNTuple::
floatArrayAt ( unsigned int row, unsigned int column ) const
{
  RootBranch * data = m_data [ column ];

  return data -> floatArrayAt ( row );
}

int *
RootNTuple::
intArrayAt ( unsigned int row, unsigned int column ) const
{
  RootBranch * data = m_data [ column ];

  return data -> intArrayAt ( row );
}


void
RootNTuple::
clear ()
{
  for ( unsigned int i = 0; i < m_data_cache.size (); i++ ) {
    if ( m_data_cache[i] != 0 ) {
      delete m_data_cache [i];
    }
    m_data_cache[i] = 0;
  }
//   m_rows = 0;
}

void
RootNTuple::
reserve ( unsigned int )
{
  // does nothing.
}

void
RootNTuple::
addRow ( const std::vector < double > & row )
{
  assert ( false );
}

double
RootNTuple::
operator [] ( std::vector < unsigned int > & indices ) const
{
  assert ( false );
  return 0.;
}

const vector < double > &
RootNTuple::
getRow ( unsigned int row ) const
{
  unsigned int size = m_data.size();
  m_array.resize ( size );
  for ( unsigned int column = 0; column < size; column++ ) {
    m_array [ column ] = valueAt ( row, column );
  }

  return m_array;
}

int
RootNTuple::
addColumn ( const std::string & label,
            RootBranch * branch )
{
  // Check if label already exists.
  int index = indexOf ( label );
  if ( index >= 0 ) {
    string what ( "RootNTuple Attempt to add a column whose label"
                  " is same as other column." );
    throw DataSourceException ( what );
  }

  m_data.push_back ( branch );
  m_data_cache.push_back ( 0 );
  addLabel ( label );
  
  return m_data.size() - 1;
}

int
RootNTuple::
addColumn ( const std::string & label,
            const std::vector < double > & col )
{
  // Check if label already exists.
  int index = indexOf ( label );
  if ( index >= 0 ) {
    string what ( "RootNTuple Attempt to add a column whose label"
                  " is same as other column." );
    throw DataSourceException ( what );
  }

  unsigned int new_size = col.size ();
  //  Check if column has right size.
    if ( m_data.empty () == false ) {
      unsigned int old_size = rows ();
  
      if ( old_size != 0 && old_size != new_size ) {
        string what ( "RootNTuple Attempt to add a column whose size"
                    " is not equal to other columns." );
        throw DataSourceException ( what );
      }
    }
  vector < double > * vec = new vector < double > ( col );
  m_data_cache.push_back ( vec );
  m_multiDimensional.push_back ( false );
    
  addLabel ( label );

  return m_data.size() - 1;
}

void
RootNTuple::
replaceColumn ( unsigned int col,
                const std::vector < double > & data )
{
  unsigned int size = columns ();
  if ( col >= size ) {
    const string what
      ( "RootNTuple: Attempt to replace non-existant column." );
    throw DataSourceException ( what );
  }

  size = rows ();
  unsigned int new_size = data.size ();
  if ( size != 0 && size != new_size ) {
    const string what
      ( "RootNTuple: Attempt to replace column with one whose "
        "size is not equal to other columns." );
      throw DataSourceException ( what );
  }
  m_data_cache [ col ] -> resize ( new_size );
  std::copy ( data.begin(), data.end(), m_data_cache [ col ] -> begin() );

  notifyObservers ();
}

void
RootNTuple::
replaceColumn ( const std::string & label,
                const std::vector < double > & data )
{
  unsigned int index = indexOf ( label );

  replaceColumn ( index, data );
}

void
RootNTuple::
setShape ( std::vector < unsigned int > & shape )
{
  assert ( false ); // not tested
  unsigned int size = 1;
  for ( unsigned int i = 0; i < shape.size(); i++ ) {
    size *= shape[i];
  }

  m_shape = shape;
}

const vector < unsigned int > &
RootNTuple::
getShape () const
{
  assert ( false ); // not tested
  return m_shape;
}

unsigned int
RootNTuple::getRank () const
{
  assert ( false ); // not tested
  return m_shape.size();
}

bool
RootNTuple::
isMultiDimensional ( const std::string & column ) const
{
  unsigned int colIndex = indexOf( column );

  return m_multiDimensional[ colIndex ];
}

const vector < int > &
RootNTuple::
rowDataDimSize( const std::string & column ) const
{
  int colIndex = indexOf ( column );
  if ( colIndex >= 0 ) {
     return getColumnShape ( static_cast<unsigned int>(colIndex) );
  } else {
     std::string what ( "DataSource: column label not found" );
     throw DataSourceException ( what );
  }
}

const vector < int > &
RootNTuple::
getColumnShape ( unsigned int column ) const
{
  RootBranch * col = m_data [ column ];
  
  return col -> rowDataDimSize();
}

bool
RootNTuple::
setReleventIndex( const std::string & column,
                  const std::vector< unsigned int >& index )
{
  // Do not call this function on scalars
  assert( isMultiDimensional( column ) );
  
  unsigned int colIndex = indexOf ( column );
  RootBranch * col = m_data [ colIndex ];

  col -> setReleventIndex( index );

  return true;
}


TBranch *
RootNTuple::
getTBranch( const std::string & column )
{
  unsigned int colIndex = indexOf ( column );
  RootBranch * col = m_data [ colIndex ];
  
  return col -> getTBranch();
}


void
RootNTuple::
smartExpandRootNTuple ( const std::string & column ) const
{
  // Expansion is --SURELY NOT-- needed if the data is not multidimensional
  if ( isMultiDimensional( column ) == true )
    {
      // Has the expansion of this column already taken place?
      bool flag = false;
      const vector< string > & label = getLabels();
      
      for( unsigned int i = 0; i < label.size(); i++ ) {
        if( label[ i ].find( column + "[" ) != string::npos ) {
          flag = true;
        }
      }
      
      // If no then go ahead and expand
      if( flag == false )
        {
          unsigned int colIndex = indexOf ( column );
          RootBranch * colRootBranch = m_data [ colIndex ];
          TBranch * colTBranch = colRootBranch -> getTBranch();
          
          unsigned int dims = colRootBranch -> rowDataDimension();
          const vector < int > & sz =colRootBranch -> rowDataDimSize();
          int nelems = colRootBranch -> numberOfElements();

          vector< unsigned int > indx( dims, 0);
          
          vector< int > wheels( dims, 0);
          wheels[ dims - 1 ] = -1;
          RootNTuple * rtuple = const_cast < RootNTuple * > ( this );
          
          for( int i = 0; i < nelems; i++ )
            {
              std::ostringstream namestream;
              
              namestream << column;
              
              rtuple ->  rotateWheels( wheels, sz, 0 );
              for( unsigned int j = 0; j < dims; j++ )
                namestream << "[" << wheels[ j ] << "]";
              
              colTBranch -> SetBasketSize ( 320000 );
              RootBranch * h_branch = new RootBranch ( colTBranch );
              
              for( unsigned int k = 0; k < wheels.size(); k++ )
                indx[ k ] = static_cast< unsigned int > ( wheels[ k ] );
              h_branch -> setReleventIndex( indx );
              
              rtuple -> addColumn ( namestream.str(), h_branch );
              rtuple -> m_multiDimensional.push_back( false );
            }
        }
    }
}

void
RootNTuple::
expandIfNeeded ( const std::string & column ) const
{
  string::size_type pos = column.find_first_of ( '[' );

  if ( pos != string::npos ) {
    const string label = column.substr ( 0, pos );

    if (isMultiDimensional ( label ) ) {
      smartExpandRootNTuple ( label );
    }
  }
}

void
RootNTuple::
expandIfNeeded ( const std::vector < std::string > & labels ) const
{
  unsigned int size = labels.size ();

  for ( unsigned int i = 0; i < size; i++ ) {
    const string & column = labels [ i ];
    expandIfNeeded ( column );
  }
}

const vector < double > &
RootNTuple::
getColumn ( const std::string & name ) const
{
  expandIfNeeded ( name );
  throwIfInvalidLabel ( name );

  int index = indexOf ( name );

  return getColumn ( index );
}

const vector < double > &
RootNTuple::
getColumn ( const std::string & name,
            const std::vector < int > & indices ) const
{
  const string label = createBinding ( name, indices );

  return getColumn ( label );
}

const vector < double > &
RootNTuple::
getColumn ( unsigned int index ) const
{
//  if ( index >= m_data.size () ) {
  if ( index >= m_data_cache.size () ) {
    string what ( "RootNTuple: index out of range" );
    throw DataSourceException ( what );
  }

  if ( m_data_cache [ index ] == 0 ) {
    RootNTuple * rtuple = const_cast < RootNTuple * > ( this );
    rtuple -> fillDataCache ( index );
  }

  return *m_data_cache [ index ];
}

std::string
RootNTuple::
createBinding ( const std::string & label, 
                const std::vector < int > & indices ) const
{
#ifdef SSTREAM_DEFECT
  ostrstream strm_text;
#else
  ostringstream strm_text;
#endif
  strm_text << label;
  unsigned int size = indices.size();
  for ( unsigned int i = 0; i < size; i++ ) {
    strm_text << "[" << indices [i] <<"]";
  }
  // Adding the std::ends seems to abb a "^@" to end of stream
  //   strm_text << std::ends;
  const string binding = strm_text.str();
  return binding;
}

---