QtRootNTuple.cxx

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

// For truncation warning
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "QtRootNTuple.h"

#include "RootDataType.h"

#include "datasrcs/DataSourceException.h"

#ifdef HAVE_NUMARRAY
#include "numarray/num_util.h"
#endif

#include "qapplication.h"

#include <utility>

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


QtRootNTuple::
QtRootNTuple ( TTree * tree )
  : RootNTuple ( tree )
{
}

QtRootNTuple::
QtRootNTuple ( )
  : RootNTuple ( )
{
}

unsigned int
QtRootNTuple::
rows ()
{
  if ( qApp ) qApp -> lock ();
  unsigned int rows =  RootNTuple::rows ();
  if ( qApp ) qApp -> unlock ();

 return rows;
}

unsigned int
QtRootNTuple::
columns ()
{
  // doesn't call ROOT, so no need for lock
 return RootNTuple::columns ();
}

const vector < double > &
QtRootNTuple::
getColumn ( const std::string & name ) const
{
  static vector < double > temp;
  if ( qApp ) qApp -> lock ();
  try {
    const vector < double > & column = RootNTuple::getColumn ( name );
    if ( qApp ) qApp -> unlock ();

    return column;
  }
  catch ( const DataSourceException e ) {
    if ( qApp ) qApp -> unlock ();
    throw e;
  }
  return temp;
}

const vector < double > &
QtRootNTuple::
getColumn ( const std::string & name,
            const std::vector < int > & indexes ) const
{
  static vector < double > temp;
  if ( qApp ) qApp -> lock ();
  try {
    const vector < double > & column 
      = RootNTuple::getColumn ( name, indexes );
    if ( qApp ) qApp -> unlock ();

    return column;
  }
  catch ( const DataSourceException e ) {
    if ( qApp ) qApp -> unlock ();
    throw e;
  }
  return temp;
}

const vector < double > &
QtRootNTuple::
getColumn ( unsigned int index ) const
{
  static vector < double > temp;
  if ( qApp ) qApp -> lock ();
  try {
    const vector < double > & column = RootNTuple::getColumn ( index );
    if ( qApp ) qApp -> unlock ();
    return column;
  }
  catch ( const DataSourceException & e ) {
    if ( qApp ) qApp -> unlock ();
    throw e;
  }
 
  return temp;
}

int
QtRootNTuple::
addColumn ( const std::string & label,
            const std::vector < double > & column )
{
  return RootNTuple::addColumn ( label, column );
}

const std::vector < std::string > &
QtRootNTuple::
getLabels () const
{
  // doesn't call ROOT, so no lock needed
  return RootNTuple::getLabels ();
}

bool
QtRootNTuple::
isMultiDimensional ( const std::string & column ) const
{
  if ( qApp ) qApp -> lock ();
  try {
    bool yes = RootNTuple::isMultiDimensional ( column );
    if ( qApp ) qApp -> unlock ();
    return yes;
  }
  catch ( const DataSourceException & e ) {
    if ( qApp ) qApp -> unlock ();
    throw e;
  }
}

const std::vector < int > &
QtRootNTuple::
rowDataDimSize ( const std::string & column ) {
  if ( qApp ) qApp -> lock ();
  try {
    const vector < int > & dims = RootNTuple::rowDataDimSize ( column );
    if ( qApp ) qApp -> unlock ();
    return dims;
  }
  catch ( const DataSourceException & e ) {
    if ( qApp ) qApp -> unlock ();
    throw e;
  }
}

void
QtRootNTuple::
expandIfNeeded ( const std::vector < std::string > & labels ) const
{
  RootNTuple::expandIfNeeded ( labels );
}

std::string 
QtRootNTuple::
createBinding ( const std::string & name, 
                const std::vector < int > & indices ) const
{
  return RootNTuple::createBinding ( name, indices );
}


using namespace hippodraw;

#ifdef HAVE_NUMARRAY
using namespace boost::python;

numeric::array
QtRootNTuple::
valueAt ( unsigned int row, const std::string & variable )
{
  RootNTuple::throwIfInvalidLabel ( variable );
  int column = RootNTuple::indexOf ( variable );
  vector < int > shape =  RootNTuple::getColumnShape ( column );

  RootData::Type type = RootNTuple::getType ( column );
  switch ( type ) {
  case RootData::Double:
    {
      double * array =RootNTuple::doubleArrayAt ( row, column );
      numeric::array na = num_util::makeNum ( array, shape );
      return na;
    }
    break;
  case RootData::Float:
    {
      float * array = RootNTuple::floatArrayAt ( row, column );
      numeric::array na = num_util::makeNum ( array, shape );
      return na;
    }
    break;
  case RootData::Int:
    {
      int * array = RootNTuple::intArrayAt ( row, column );
      numeric::array na = num_util::makeNum ( array, shape );
      return na;
    }
    break;
  default:
    assert ( false );
    break;
  }
  return num_util::makeNum ( 1, PyArray_DOUBLE );
}
#endif

---