RawFileReader Class Reference

#include <RawFileReader.h>

Inheritance diagram for RawFileReader:

Public Types
typedef const VFileNames_t	ReaderArgType

Public Member Functions
	RawFileReader (const std::string &fname)
	RawFileReader (const VFileNames_t &fnames)
	RawFileReader (const std::string &fname, const std::string &idxfname)
	RawFileReader (const VFileNames_t &fnames, const VFileNames_t &idxfnames)
virtual	~RawFileReader ()
const uint32_t *	nextEvent ()
const uint32_t *	currentEvent () const
const uint32_t *	nextEvent (int nIgnore)
const uint32_t *	findEventById (uint32_t evtId)
const uint32_t *	roughlyNextEvent (int nIgnore, int evtByte=0)
uint32_t	runNo ()
std::string	currentFile ()
uint32_t	tellg ()
uint32_t	stat ()
Public Member Functions inherited from IRawReader
virtual	~IRawReader ()

Static Public Member Functions
static std::vector< int >	getEventNumber (const VFileNames_t &idxfnames)

Detailed Description

Definition at line 16 of file RawFileReader.h.

Member Typedef Documentation

ReaderArgType

const VFileNames_t RawFileReader::ReaderArgType

Definition at line 20 of file RawFileReader.h.

Constructor & Destructor Documentation

RawFileReader() [1/4]

RawFileReader::RawFileReader

(

const std::string &

fname

)

Definition at line 39 of file RawFileReader.cxx.

   : 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);
   }
}

Referenced by RawFileReader(), RawFileReader(), RawFileReader(), and RawFileReader().

RawFileReader() [2/4]

RawFileReader::RawFileReader

(

const VFileNames_t &

fnames

)

Definition at line 63 of file RawFileReader.cxx.

   : 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() [3/4]

RawFileReader::RawFileReader	(	const std::string &	fname,
		const std::string &	idxfname )

Definition at line 87 of file RawFileReader.cxx.

   : 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() [4/4]

RawFileReader::RawFileReader	(	const VFileNames_t &	fnames,
		const VFileNames_t &	idxfnames )

Definition at line 103 of file RawFileReader.cxx.

   : 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::~RawFileReader ( )

virtual

Definition at line 119 of file RawFileReader.cxx.

{
   delete[] m_buffer;
   raw_ifstream::release();
   EvtIdxHandler::release();
}

Member Function Documentation

currentEvent()

const uint32_t * RawFileReader::currentEvent ( ) const

inlinevirtual

Implements IRawReader.

Definition at line 33 of file RawFileReader.h.

{ return m_buffer; }

Referenced by MixerAlg::nextEvent().

currentFile()

std::string RawFileReader::currentFile ( )

virtual

Implements IRawReader.

Definition at line 263 of file RawFileReader.cxx.

{
   return m_rfs->currentFile();
}

Referenced by MixerAlg::execute(), findEventById(), main(), nextEvent(), and roughlyNextEvent().

findEventById()

const uint32_t * RawFileReader::findEventById

(

uint32_t

evtId

)

Definition at line 189 of file RawFileReader.cxx.

{
   // 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;
}

Referenced by findEventById(), and main().

getEventNumber()

std::vector< int > RawFileReader::getEventNumber ( const VFileNames_t & idxfnames )

static

Definition at line 12 of file RawFileReader.cxx.

{
   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;
}

Referenced by MixerAlg::execute().

nextEvent() [1/2]

const uint32_t * RawFileReader::nextEvent ( )

virtual

Implements IRawReader.

Definition at line 126 of file RawFileReader.cxx.

{
   // 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;
}

Referenced by main(), MixerAlg::nextEvent(), nextEvent(), nextEvent(), and RawEventReader::readEvent().

nextEvent() [2/2]

const uint32_t * RawFileReader::nextEvent

(

int

nIgnore

)

Definition at line 154 of file RawFileReader.cxx.

{
   // 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;
}

roughlyNextEvent()

const uint32_t * RawFileReader::roughlyNextEvent	(	int	nIgnore,
		int	evtByte = 0 )

Definition at line 221 of file RawFileReader.cxx.

{
   // 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);
}

Referenced by MixerAlg::nextEvent(), and roughlyNextEvent().

runNo()

uint32_t RawFileReader::runNo ( )

virtual

Implements IRawReader.

Definition at line 258 of file RawFileReader.cxx.

{
    return m_rfs->runNo();
}

stat()

uint32_t RawFileReader::stat ( )

virtual

Implements IRawReader.

Definition at line 273 of file RawFileReader.cxx.

{
   uint32_t stat = 0;
 
   if ( m_rfs->eof() )  stat |= 1;
   if ( m_rfs->fail() ) stat |= 2;
   if ( m_rfs->bad() )  stat |= 4;
 
   return stat;
}

Referenced by stat().

tellg()

uint32_t RawFileReader::tellg

(

)

Definition at line 268 of file RawFileReader.cxx.

{
   return m_rfs->tellg();
}

Referenced by main().

---

The documentation for this class was generated from the following files:

• RawFileReader.h
• RawFileReader.cxx