RawFileReader.cxx

Go to the documentation of this file.

#include "RawFile/RawFileReader.h"
#include "IRawFile/RawFileExceptions.h"
#include "RawFile/EvtIdxHandler.h"
#include "RawFile/RawFileTools.h"
#include "RawFile/raw_ifstream.h"
#include <cstdlib>
#include <unistd.h>
 
#define DefaultEventBufferSize 1024 * 32
#define EstimatedEventSize 1024 * 14
 
std::vector<int> RawFileReader::getEventNumber( const VFileNames_t& idxfnames ) {
  uint32_t         itmp[2];
  std::vector<int> vNevt;
 
  const VFileNames_t           newfnames = RawFileTools::wildcard_correct( idxfnames );
  VFileNames_t::const_iterator it        = newfnames.begin();
  while ( it != newfnames.end() )
  {
    if ( access( it->c_str(), F_OK ) < 0 )
    {
      std::cerr << "[RawFile] Invalid IDX file: " << *it << std::endl;
      exit( 1 );
    }
 
    std::ifstream fs( it->c_str(), std::ios::binary );
 
    fs.read( (char*)( itmp ), sizeof( uint32_t ) * 2 );
    if ( itmp[0] != EvtIdxHandler::IdxFileStartMarker() )
    {
      std::cerr << "[RawFile] Wrong IdxFileStartMarker!" << std::endl;
      exit( 1 );
    }
    vNevt.push_back( itmp[1] );
    ++it;
  }
 
  return vNevt;
}
 
RawFileReader::RawFileReader( const std::string& fname )
    : m_bufferSize( DefaultEventBufferSize )
    , m_buffer( new uint32_t[DefaultEventBufferSize] )
    , m_idxHandler( 0 ) {
  const VFileNames_t newfnames = RawFileTools::wildcard_correct( fname );
 
  // in case of idx files
  VFileNames_t datafnames;
  for ( int i = 0; i < newfnames.size(); ++i )
  {
    int size = newfnames[i].size();
    if ( size > 4 && newfnames[i].substr( size - 4 ) == ".idx" )
    { datafnames.push_back( newfnames[i].substr( 0, size - 4 ) ); }
  }
  if ( datafnames.size() == newfnames.size() )
  {
    m_rfs        = raw_ifstream::instance( datafnames );
    m_idxHandler = EvtIdxHandler::instance( newfnames );
  }
  else { m_rfs = raw_ifstream::instance( newfnames ); }
}
 
RawFileReader::RawFileReader( const VFileNames_t& fnames )
    : m_bufferSize( DefaultEventBufferSize )
    , m_buffer( new uint32_t[DefaultEventBufferSize] )
    , m_idxHandler( 0 ) {
  const VFileNames_t newfnames = RawFileTools::wildcard_correct( fnames );
 
  // in case of idx files
  VFileNames_t datafnames;
  for ( int i = 0; i < newfnames.size(); ++i )
  {
    int size = newfnames[i].size();
    if ( size > 4 && newfnames[i].substr( size - 4 ) == ".idx" )
    { datafnames.push_back( newfnames[i].substr( 0, size - 4 ) ); }
  }
  if ( datafnames.size() == newfnames.size() )
  {
    m_rfs        = raw_ifstream::instance( datafnames );
    m_idxHandler = EvtIdxHandler::instance( newfnames );
  }
  else { m_rfs = raw_ifstream::instance( newfnames ); }
}
 
RawFileReader::RawFileReader( const std::string& fname, const std::string& idxfname )
    : m_bufferSize( DefaultEventBufferSize )
    , m_buffer( new uint32_t[DefaultEventBufferSize] ) {
  const VFileNames_t newfnames    = RawFileTools::wildcard_correct( fname );
  const VFileNames_t newidxfnames = RawFileTools::wildcard_correct( idxfname );
 
  if ( newidxfnames.size() != newfnames.size() )
  {
    std::cerr << "[RawFile] Num(IdxFiles) != Num(DataFiles)" << std::endl;
    exit( 1 );
  }
 
  m_rfs        = raw_ifstream::instance( newfnames );
  m_idxHandler = EvtIdxHandler::instance( newidxfnames );
}
 
RawFileReader::RawFileReader( const VFileNames_t& fnames, const VFileNames_t& idxfnames )
    : m_bufferSize( DefaultEventBufferSize )
    , m_buffer( new uint32_t[DefaultEventBufferSize] ) {
  const VFileNames_t newfnames    = RawFileTools::wildcard_correct( fnames );
  const VFileNames_t newidxfnames = RawFileTools::wildcard_correct( idxfnames );
 
  if ( newidxfnames.size() != newfnames.size() )
  {
    std::cerr << "[RawFile] Num(IdxFiles) != Num(DataFiles)" << std::endl;
    exit( 1 );
  }
 
  m_rfs        = raw_ifstream::instance( newfnames );
  m_idxHandler = EvtIdxHandler::instance( newidxfnames );
}
 
RawFileReader::~RawFileReader() {
  delete[] m_buffer;
  raw_ifstream::release();
  EvtIdxHandler::release();
}
 
const uint32_t* RawFileReader::nextEvent() {
  // thread safe
  raw_ifstream::lock();
 
  try
  {
    if ( m_idxHandler == 0 ) { notSafeNextEvent(); }
    else { nextEvent( 0 ); }
  } catch ( ReachEndOfFileList& e )
  {
    raw_ifstream::unlock();
    throw e;
  } catch ( RawFileException& e )
  {
    raw_ifstream::unlock();
    e.print();
    throw e;
  }
 
  raw_ifstream::unlock();
 
  return m_buffer;
}
 
const uint32_t* RawFileReader::nextEvent( int nIgnore ) {
  // not thread safe !!!
  int nnIgnore = nIgnore;
 
  try
  {
    if ( m_idxHandler != 0 )
    {
      int nleft = m_idxHandler->nEvtLeft( nnIgnore );
      if ( nleft > 0 )
      {
        m_rfs->seekg( m_idxHandler->nextPos( nnIgnore ) );
        nnIgnore = 0;
      }
      else
      {
        nnIgnore = -nleft;
        throw ReachEndOfFile( currentFile().c_str() );
      }
    }
    else
    {
      while ( nnIgnore > 0 )
      {
        ( *m_rfs ) >> m_dataSeparatorRecord;
        uint32_t size = m_dataSeparatorRecord.getRecord().data_block_size;
        m_rfs->seekg( size + m_rfs->tellg() );
        --nnIgnore;
      }
    }
 
    read_one_event();
  } catch ( RawFileException& e )
  { nextFile( e ).nextEvent( nnIgnore ); }
 
  return m_buffer;
}
 
const uint32_t* RawFileReader::findEventById( uint32_t evtId ) {
  // not thread safe !!!
  // find an event by ID ( only backward !!! )
  try
  {
    if ( m_idxHandler == 0 )
    {
      while ( true )
      {
        read_one_event();
        uint32_t curEvtId = m_buffer[m_buffer[5] + 8];
        if ( curEvtId == evtId ) { break; }
      }
    }
    else
    {
      uint32_t pos = m_idxHandler->findPosById( evtId );
      if ( pos != 0 )
      {
        m_rfs->seekg( pos );
        read_one_event();
      }
      else { throw ReachEndOfFile( currentFile().c_str() ); }
    }
  } catch ( RawFileException& e )
  { return nextFile( e ).findEventById( evtId ); }
 
  return m_buffer;
}
 
const uint32_t* RawFileReader::roughlyNextEvent( int nIgnore, int evtByte ) {
  // not thread safe !!!
  if ( evtByte == 0 ) evtByte = EstimatedEventSize;
 
  assert( ( evtByte & 3 ) == 0 );
 
  uint32_t prePos = m_rfs->tellg();
  m_rfs->seekg( prePos + nIgnore * evtByte );
 
  uint32_t halfEvtWord = evtByte / 8;
  uint32_t halfEvtByte = halfEvtWord * 4;
 
  while ( m_rfs->read( (char*)m_buffer, halfEvtByte ).good() )
  {
    uint32_t i = 0;
    while ( i < halfEvtWord && m_buffer[i] != 0x1234cccc ) { ++i; }
    if ( i < halfEvtWord )
    {
      uint32_t curPos = m_rfs->tellg();
      m_rfs->seekg( curPos - ( halfEvtWord - i ) * 4 );
      read_one_event();
      return m_buffer;
    }
  }
 
  // reached the end of current data file! m_rfs->eof()
  m_rfs->clear();
  m_rfs->seekg( -40, std::ios::end ); // sizeof(FileEndRecord) == 40
  uint32_t curPos = m_rfs->tellg();
 
  int nnIgnore = nIgnore - ( curPos - prePos ) / evtByte;
  if ( nnIgnore < 0 ) nnIgnore = 0;
 
  ReachEndOfFile e( currentFile().c_str() );
  return nextFile( e ).roughlyNextEvent( nnIgnore, evtByte );
}
uint32_t RawFileReader::runNo() { return m_rfs->runNo(); }
 
std::string RawFileReader::currentFile() { return m_rfs->currentFile(); }
 
uint32_t RawFileReader::tellg() { return m_rfs->tellg(); }
 
uint32_t RawFileReader::stat() {
  uint32_t stat = 0;
 
  if ( m_rfs->eof() ) stat |= 1;
  if ( m_rfs->fail() ) stat |= 2;
  if ( m_rfs->bad() ) stat |= 4;
 
  return stat;
}
 
const uint32_t* RawFileReader::notSafeNextEvent() {
  try
  { read_one_event(); } catch ( RawFileException& e )
  { nextFile( e ).notSafeNextEvent(); }
 
  return m_buffer;
}
 
void RawFileReader::read_one_event() {
  ( *m_rfs ) >> m_dataSeparatorRecord;
 
  uint32_t size = m_dataSeparatorRecord.getRecord().data_block_size;
  if ( size > m_bufferSize * 4 )
  {
    while ( size > m_bufferSize * 4 ) { m_bufferSize *= 2; }
    delete[] m_buffer;
    m_buffer = new uint32_t[m_bufferSize];
  }
 
  m_rfs->read( (char*)m_buffer, size );
  if ( !m_rfs->good() )
  {
    // std::cerr << "[RawFile] Failed to read FullEventFragment to buffer" << std::endl;
    throw BadInputStream( "event_data_block" );
  }
}
 
RawFileReader& RawFileReader::nextFile( RawFileException& e ) {
  e.print();
 
  m_rfs->clear();
  m_rfs->next_file();
 
  if ( m_idxHandler != 0 ) { m_idxHandler->next_file(); }
 
  return *this;
}