NTupleController.cxx

Go to the documentation of this file.

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

// for truncation warning in debug mode
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "NTupleController.h"

#include "CircularBuffer.h"
#include "DataSourceController.h"

#include <algorithm>
#include <fstream>

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

#include <utility>
#include <cassert>

using std::endl;
using std::map;
using std::ofstream;
using std::string;
using std::vector;

NTupleController * NTupleController::s_instance = 0;

NTupleController::NTupleController ( )
{
}

NTupleController::NTupleController ( const NTupleController & )
{
  assert ( false );
}

NTupleController * NTupleController::instance ( )
{
  if ( s_instance == 0 ) {
    s_instance = new NTupleController ( );
  }
  return s_instance;
}

string::size_type
NTupleController::
findWhite ( const std::string & line, unsigned int left, bool tabs_only )
{
  string::size_type right = line.find( '\t', left );

  if( line.find( '\n', left ) < right ) right = line.find( '\n', left );

  if ( tabs_only == false ) { 
    if( line.find( ' ', left ) < right ) right = line.find( ' ', left );
  }

  return right;
}

int
NTupleController::
readAsciiNTuple ( NTuple * ntuple, const std::string & filename )
{
  string dir_name = filename;
  vector<double> vals;

  string::size_type pos = dir_name.find_last_of( '/' );
  if ( pos == string::npos ) {
    dir_name = ".";
  } else {
    dir_name.erase( pos );
  }
  dir_name += "/";

  std::ifstream infile( filename.c_str() );
  if( !infile.is_open() ) {
    return -1; 
  }
  string line;
  if( !std::getline( infile, line ) ) {
    return -2;
  }
  while( findWhite( line, 0, false ) == 0 ) line = line.substr( 1 );
  ntuple->setTitle ( line );


  if( !std::getline( infile, line ) ) {
    return -2;
  }

  string::size_type size = line.size ();
  if ( line[size-1] == '\r' ) { // CR on Windows written file
    line.erase ( size-1 );
  }
  line += "\n";

  string::size_type right = findWhite( line, 0, true );

  vector< string > labels;

  string::size_type left = 0;
  while( right != line.npos ){
    if( right == left ){
      left++;
      right = findWhite( line, left, true );
      continue;
    }
    string label = line.substr( left, right - left );
    labels.push_back ( label );

    left = right + 1;
    right = findWhite( line, left, true );
  }
  if ( labels.size () == 0 ) {
    return -2;
  }

  ntuple->setLabels ( labels );

  vals.resize ( labels.size() );
  string::size_type col = 0;
  while( std::getline( infile, line ) ) {
    line += "\n";
    left = 0;
    right = findWhite( line );
    while( right != line.npos ){
      if( right == left ){
        left++;
        right = findWhite( line, left );
        continue;
      }
      vals[col++] = atof( line.substr( left, right - left ).c_str() );
      if( col == labels.size() ){
        col = 0;
        ntuple->addRow ( vals );
      }
      left = right + 1;
      right = findWhite( line, left );
    }
  }
  if( col != 0 ){
    // ERROR READING NTUPLE.
    return -2;
  }
  vector < unsigned int > shape ( 2 );
  shape[0] = ntuple -> rows();
  shape[1] = ntuple -> columns ();
  ntuple -> setShape ( shape );

  return 0;
}

DataSource * 
NTupleController::
createNTuple ( const std::string & filename )
{
  unsigned int columns = 0;
  NTuple * nt = new NTuple ( columns  );
  int retval = readAsciiNTuple ( nt, filename );

  if ( retval < 0 ) {
    std::string what ( "NTupleController: File\n" );
    what += filename + "\n";
    if ( retval == -1 ) {
      what += "could not be found.";
    }
    else {
      what += "has bad format.";
    }
    delete nt;
    throw DataSourceException ( what );
  }

  DataSourceController * controller = DataSourceController::instance ();
  DataSource * ds = controller -> getDataSource ( filename );

  // create uniquie name if file is already opened.
  string name ( filename );
  while ( ds != 0 ) {
    name += "tnt";
    ds = controller -> getDataSource ( name );
  }

  nt->setName ( name ); // before registering.
  controller -> registerNTuple ( name, nt );
  controller -> registerDataSourceFile ( nt );

  return nt;
}

NTuple * 
NTupleController::
createNTuple ( const std::vector < std::string > & labels )
{
  NTuple * nt = new NTuple ( labels );
  DataSourceController * controller = DataSourceController::instance ();
  controller -> registerNTuple ( nt );

  return nt;
}

CircularBuffer * 
NTupleController::
createCircularBuffer ( const std::vector < std::string > & labels )
{
  CircularBuffer * nt = new CircularBuffer ( labels );
  DataSourceController * controller = DataSourceController::instance ();
  controller -> registerNTuple ( nt );

  return nt;
}

NTuple * 
NTupleController::
createNTuple ( unsigned int columns )
{
  NTuple * nt = new NTuple ( columns );
  DataSourceController * controller = DataSourceController::instance ();
  controller -> registerNTuple ( nt );

  return nt;
}

CircularBuffer * 
NTupleController::
createCircularBuffer ( unsigned int columns )
{
  CircularBuffer * nt = new CircularBuffer ( columns );
  DataSourceController * controller = DataSourceController::instance ();
  controller -> registerNTuple ( nt );

  return nt;
}

NTuple * 
NTupleController::
createNTuple ( )
{
  NTuple * nt = new NTuple ();
  DataSourceController * controller = DataSourceController::instance ();
  controller -> registerNTuple ( nt );

  return nt;
}

CircularBuffer * 
NTupleController::
createCircularBuffer ( )
{
  CircularBuffer * nt = new CircularBuffer ();
  DataSourceController * controller = DataSourceController::instance ();
  controller -> registerNTuple ( nt );

  return nt;
}

DataSource * 
NTupleController::
findDataSource ( const std::string & name ) const
{
  DataSourceController * controller = DataSourceController::instance ();

  return controller -> findDataSource ( name );
}

void
NTupleController::
changeName ( DataSource * ntuple, const std::string & new_name )
{
  ntuple -> setName ( new_name );
}

int 
NTupleController::
writeNTupleToFile ( const std::string & name,
                    const std::string & filename )
{
  DataSourceController * controller = DataSourceController::instance ();
  DataSource * ntuple 
    = controller -> findDataSource ( name ); // throws exception if not found
  if ( ntuple == 0 ) return -1;

  return writeNTupleToFile ( ntuple, filename );
}

int 
NTupleController::
writeNTupleToFile ( DataSource * ntuple, 
                    const std::string & filename )
{
  ofstream file ( filename.c_str() );
  if ( file.is_open () == false ) {
    return 1;
  }
  file << ntuple->title() << endl;

  const vector < string > & labels = ntuple->getLabels ();
#ifdef ITERATOR_MEMBER_DEFECT
  std::
#endif
  vector < string > ::const_iterator first = labels.begin ();
  string label = *first++;
  file << label;
  while (  first != labels.end() ) {
    label = *first++;
    file << "\t" << label;
  }
  file << endl;

  unsigned int rows = ntuple->rows ();
  for ( unsigned int i = 0; i < rows; i++ ) {
    const vector < double > & row = ntuple->getRow ( i );

#ifdef ITERATOR_MEMBER_DEFECT
    std::
#endif
      vector < double > ::const_iterator first = row.begin();
    while ( first != row.end() ) {
      file << "\t" << *first++;
    }
    file << endl;
  }

  return 0;
}

void
NTupleController::
saveNTuples ( const std::string & fileprefix, const std::string & filesuffix )
{
  string::size_type pos = fileprefix.find_last_of ( '/' );
  const string path = fileprefix.substr ( 0, pos + 1 );
  const string basename = fileprefix.substr ( pos + 1 );

  DataSourceController * controller = DataSourceController::instance ();
  const vector < DataSource * > & tuples 
    = controller->getDataSources ( false ); // only non files
  unsigned int  size = tuples.size();

  for ( unsigned int i = 0; i < size; i++ ) {
    DataSource * ntuple = tuples[i];
    const string & tuple_name = ntuple->getName ();

#ifdef SSTREAM_DEFECT
    ostrstream strm_text;
#else
    ostringstream strm_text;
#endif
    strm_text << basename
              << i
              << filesuffix
              << std::ends;
    const string filename ( strm_text.str() );
    string tuple_file ( path );
    tuple_file += filename;

    NTupleController::instance () 
      -> writeNTupleToFile ( tuple_name, tuple_file );
    controller -> changeName ( tuple_name, filename );
  }
}

string
NTupleController::
registerNTuple ( DataSource * ds )
{
  DataSourceController * controller = DataSourceController::instance ();
  controller -> registerNTuple ( ds );

  return ds -> getName ();
}

void
NTupleController::
registerNTuple ( const std::string & key, DataSource * ntuple )
{
  DataSourceController * controller = DataSourceController::instance ();
  controller -> registerNTuple ( key, ntuple );
}

---