LdfController.cxx

Go to the documentation of this file.

#include "RootController.h"

#include "RootNTuple.h"

#include "datasrcs/DataSourceController.h"

#include "TFile.h"
#include "TKey.h"
#include "TTree.h"

#include <fstream>

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

typedef std::map < std::string, TFile * > ::iterator FileMapIterator_t;

RootController * RootController::s_instance = 0;

RootController *
RootController::
instance ()
{
  if ( s_instance == 0 ) {
    s_instance = new RootController ();
  }
#ifdef _MSC_VER
  TTree * tree = new TTree (); // force loading of dll
  delete tree;
#endif
  return s_instance;
}

RootController::
~RootController()
{
}

const std::string &
RootController::
version () const
{
  m_version = ROOT_RELEASE;
  return m_version;
}

TFile *
RootController::
openFile ( const std::string & name )
{
  TFile * file = 0;
  FileMapIterator_t first = m_file_map.find ( name );

  if ( first == m_file_map.end() ) {
    ifstream test ( name.c_str (), std::ios::in );
    if ( test.is_open () == false ) {
      string what ( "RootController: File `" );
      what += name;
      what += "' was not found.";
      throw DataSourceException ( what );
    }
    file = new TFile ( name.c_str() );
    m_file_map [ name ] = file;
  }
  else {
    file = first -> second;
  }

  return file;
}

void
RootController::
closeFile ( const std::string & name )
{
  FileMapIterator_t where = m_file_map.find ( name );
  if ( where != m_file_map.end () ) {
    m_file_map.erase ( where );
    TFile * file = where -> second;
    delete file;
  }
}

const vector < string > & 
RootController::
getNTupleNames ( const std::string & file_name )
{
  m_ntuple_names.clear();

  TFile * file = openFile ( file_name );

  if ( file != 0 ) {
    TList * keys = file -> GetListOfKeys ();
    Int_t size = keys -> GetSize ();

    for ( Int_t i = 0; i < size; i++ ) {
      TObject * obj = keys -> At ( i );
      TKey * key = dynamic_cast < TKey * > ( obj );
      const string class_name = key -> GetClassName ();
      if ( class_name == "TTree" ) {
        const string name = key -> GetName ();
        m_ntuple_names.push_back ( name );
      }
    }
  }

  return m_ntuple_names;
}

TTree *
RootController::
getTree ( const std::string & filename,
          const std::string & treename )
{
  TFile * file =  openFile ( filename );
  TObject * object = file ->Get ( treename.c_str() );
  TTree * tree = dynamic_cast < TTree * > ( object );

  return tree;
}

DataSource *
RootController::
createNTuple ( const std::string & filename, const std::string & treename )
{
  string ds_name = filename;
  ds_name += ": ";
  ds_name += treename;

  DataSourceController * controller = DataSourceController::instance();
  DataSource * ntuple = controller -> getDataSource ( ds_name );

  if ( ntuple == 0 ) {
    TTree * tree = getTree ( filename, treename );
    ntuple = new RootNTuple ( tree );
    ntuple -> setTitle ( treename );

    ntuple -> setName ( ds_name );
    controller -> registerNTuple ( ntuple );
    controller -> registerDataSourceFile ( ntuple );
  }

  return ntuple;
}

DataSource *
RootController::
createNTuple ( const std::string & name )
{
  DataSource * rtuple = 0;

  string::size_type pos = name.find_last_of ( ':' );
  if ( pos == string::npos ) {
    const vector < string > & tree_names = getNTupleNames ( name );
    rtuple = createNTuple ( name, tree_names[0] );
  }
  else {
    const string filename = name.substr ( 0, pos );
    string tree_name = name.substr ( pos + 1 );
    pos = tree_name.find_first_not_of ( ' ' );
    tree_name.erase ( 0, pos );
    rtuple = createNTuple ( filename, tree_name );
  }

  return rtuple;
}

void
RootController::
fillDimSize ( std::vector < int > & dims, 
              const DataSource * source,
              const std::string & column )
{
  const RootNTuple * rtuple = dynamic_cast < const RootNTuple * > ( source );
  if ( rtuple != 0 ) {
    dims = rtuple -> rowDataDimSize ( column );
  }
}

bool
RootController::
smartExpandRootNTuple ( DataSource * source, std::string & column )
{
  bool yes = false;
  RootNTuple * rtuple = dynamic_cast < RootNTuple * > ( source );
  if ( rtuple != 0 ) {
    rtuple -> smartExpandRootNTuple ( column );
    yes = true;
  }

  return yes;
}

---