LdfColumn.cxx

Go to the documentation of this file.

#include "RootBranch.h"

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

#include <TLeaf.h>


#include <vector>
#include <string>

#include <cassert>

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

using namespace hippodraw;

RootBranch::
RootBranch ( TBranch * branch )
  : m_branch ( branch ),
    m_releventIndex ( -1 ),
    m_branch_set ( false )
{
  TObjArray * leaves = branch -> GetListOfLeaves ();
  m_number_leaves = leaves -> GetEntries ();
  
  if ( m_number_leaves == 1 )
    {
      TObject * object = leaves -> At ( 0 );
      m_leaf = dynamic_cast < TLeaf * > ( object );
      assert ( m_leaf != 0 );
      const string type = m_leaf -> GetTypeName ();

      if ( type == "Double_t" ) m_leaf_type = RootData::Double;
      else if ( type == "Float_t" ) m_leaf_type = RootData::Float;
      else if ( type == "Int_t" ) m_leaf_type = RootData::Int;
      else if ( type == "UInt_t" ) m_leaf_type = RootData::UInt;
      else assert ( false );

      m_number_elements = m_leaf -> GetLen();
    }
  
  if( m_number_elements > 1 ) // we are dealing with multidimensional data
    getDimSize( m_leaf -> GetTitle() );
}

RootBranch::
RootBranch ()
  : m_branch ( 0 ),
    m_releventIndex ( -1 ),
    m_branch_set ( false )
{
}

RootBranch::
~RootBranch()
{
}

unsigned int
RootBranch::
size () const
{
  assert ( false ); // branch doesn't know its size yet

  return 0;
}


bool
RootBranch::
empty () const
{
  return false;
}

bool
RootBranch::
isFilled ( ) const
{
  return true;
}

bool
RootBranch::
isMultiDimensional() const
{
  return ! ( m_number_elements == 1 );
}


int
RootBranch::
numberOfElements() const
{
  return m_number_elements;
}

TBranch *
RootBranch::
getTBranch()
{
  return m_branch;
}
  
int
RootBranch::
getDimSize( const char* title )
{
  string s( title );
  
  //Creating the list of dropped delimiters. 
  boost::char_separator< char > sep( "][" );  

  // A tokenizer with above dropped delimiters.
  typedef boost::tokenizer< boost::char_separator< char > >  tokenizer;
  tokenizer tok( s, sep );
  
  // Start extracting the dimension sizes.
  for( tokenizer::iterator tok_iter = tok.begin();
       tok_iter != tok.end();
       ++tok_iter )
    if( tok_iter != tok.begin() )
      m_dims.push_back( boost::lexical_cast< unsigned int >( *tok_iter ) );
  
  return EXIT_SUCCESS; 
}

void
RootBranch::
setBranchAddress () const
{
  if( m_number_elements == 1 )
    {
      switch ( m_leaf_type )
        {
        case RootData::Double:
          m_branch -> SetAddress ( & m_double_data );
          break;
        case RootData::Float:
          m_branch -> SetAddress ( & m_float_data );
          break;
        case RootData::Int:
          m_branch -> SetAddress ( & m_int_data );
          break;
        case RootData::UInt:
          m_branch -> SetAddress ( & m_uint_data );
          break;
        default:
          assert ( false );
          break;
        }
    }

  else if( m_number_elements > 1 )
    {
     switch ( m_leaf_type )
       {
       case RootData::Double:
          m_vector_double_data = new Double_t [ m_number_elements ];
          m_branch -> SetAddress ( m_vector_double_data );
          break;
       case RootData::Float:
          m_vector_float_data = new Float_t [ m_number_elements ];
          m_branch -> SetAddress ( m_vector_float_data );
          break;
      case RootData::Int:
          m_vector_int_data = new Int_t [ m_number_elements ];
          m_branch -> SetAddress ( m_vector_int_data );
          break;
      case RootData::UInt:
          m_vector_uint_data = new UInt_t [ m_number_elements ];
          m_branch -> SetAddress ( m_vector_uint_data );
          break;
       default:
         assert ( false );
         break;
       }

    }
  
  m_branch_set = true;
}

unsigned int 
RootBranch::
rowDataDimension() const
{
  unsigned int size = 0;
  if ( m_number_elements > 1 ) { // we are dealing with multidimensional data
    size = m_dims.size();
  }

  return size;
}

const vector < int > &
RootBranch::rowDataDimSize()
{
  return m_dims;
}

void
RootBranch::
setReleventIndex( const std::vector< unsigned int > & index )
{
  // This function makes sense only for multi dimenstional data
  assert( rowDataDimension() > 0 );
  
  // Index should completely specify the entry of the data in the matrix
  // So it should have as many enteries as the dimensions of the data
  assert( rowDataDimension() == index.size() );
  
  // Clear old relevent entry and put in this new ones.
  m_releventIndex = index[0];
  for ( unsigned int d = 1; d < rowDataDimension(); d++ ) {
    m_releventIndex = m_releventIndex * m_dims [ d ] + index[ d ];
  }
}

double
RootBranch::
valueAt ( unsigned int row ) const
{
  if ( m_branch_set == false ) setBranchAddress ();
  
  Int_t entry = row;
  //Int_t bytes =
    m_branch -> GetEntry ( entry, 1 );
  
  double value = -1;
  if( m_number_elements == 1 )
    {
      switch ( m_leaf_type )
        {
        case RootData::Double:
          value = m_double_data;
          break;
        case RootData::Float:
          value = m_float_data;
          break;
        case RootData::Int:
          value = m_int_data;
          break;
        case RootData::UInt:
          value = m_uint_data;
          break;
        default:
          assert ( false );
          break;
        }
    }
  else
    {
      if ( m_releventIndex < 0 ||  m_number_elements <= m_releventIndex )
        {
          std::string what ( "RootBranch: `" );
          what += m_leaf -> GetTitle ();
          what += "' indices not set properly.";
          throw DataSourceException ( what );
        }

      // The basic conversion formulae
      switch ( m_leaf_type )
        {
        case RootData::Double:
          value = m_vector_double_data [ m_releventIndex ];
          break;
        case RootData::Float:
          value = m_vector_float_data [ m_releventIndex ];
          break;
        case RootData::Int:
          value = m_vector_int_data [ m_releventIndex ];
          break;
        case RootData::UInt:
          value = m_vector_uint_data [ m_releventIndex ];
          break;
        default:
          assert ( false );
        }
    }

  return value;
}

double *
RootBranch::
doubleArrayAt ( unsigned int row )
{
  if ( m_branch_set == false ) setBranchAddress ();
  Int_t entry = row;
  // Int_t bytes =
  m_branch -> GetEntry ( entry, 1 );

  return m_vector_double_data;
}

float *
RootBranch::
floatArrayAt ( unsigned int row )
{
  if ( m_branch_set == false ) setBranchAddress ();
  Int_t entry = row;
  // Int_t bytes =
  m_branch -> GetEntry ( entry, 1 );

  return m_vector_float_data;
}

int *
RootBranch::
intArrayAt ( unsigned int row )
{
  if ( m_branch_set == false ) setBranchAddress ();
  Int_t entry = row;
  // Int_t bytes =
  m_branch -> GetEntry ( entry, 1 );

  return m_vector_int_data;
}



RootData::Type
RootBranch::
getType () const
{
  return m_leaf_type;
}

---