src/MimoteraReader.cc

Go to the documentation of this file.

// Author Antonio Bulgheroni, <mailto:antonio.bulgheroni@gmail.com>
// Copyright 2009 Antonio Bulgheroni

// $Rev:: 36                                                            $: Revision of the last commit
// $Author:: drhilbert                                                  $: Author of the last commit
// $Date:: 2009-09-07 18:51:31 +0200 (Mon, 07 Sep 2009)                 $: Date of the last commit

// This file is part of Mimotera++.
//
// Mimotera++ is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Mimotera++ is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Mimotera++.  If not, see <http://www.gnu.org/licenses/>.

// Mimotera includes ".hh"
#include "mimotera++/MimoteraReader.hh"
#include "mimotera++/MimoteraEvent.hh"
#include "mimotera++/MimoteraException.hh"
#include "mimotera++/MimoteraUtils.hh"

// system includes <>
#include <iostream>
#include <fstream>
#include <sys/types.h>
#include <sys/stat.h>
#include <cerrno>

using namespace std;

namespace Mimotera {


  MimoteraReader::MimoteraReader()  {

    // initialize
    init();

  }

  MimoteraReader::MimoteraReader( const char * filename )  {

    // initialize
    init();

    // open
    open( filename );

  }

  void MimoteraReader::init() {

    _iEvt = 0;
    _currentPosition = 0;
    _previousPosition = 0;
    _mimoteraFile = NULL ;
    _hasValidFile = false;
    _isEventReady = false;
    _mimoteraEvent = new MimoteraEvent;
  }

  bool MimoteraReader::readNextEvent() {

    _previousPosition = _currentPosition;


    // read the data
    _mimoteraFile->read( reinterpret_cast< char * > ( _mimoteraEvent->frameA() ), kSubFrameSize ) ;
    _mimoteraFile->read( reinterpret_cast< char * > ( _mimoteraEvent->frameB() ), kSubFrameSize ) ;
    _mimoteraFile->read( reinterpret_cast< char * > ( _tempHeader  ), kMimoteraInfoSize );

    // refurbish the header due to possibly wrong endianess
    unsigned short gl0s = getbigendian<unsigned short>( reinterpret_cast< const unsigned char * > ( &_tempHeader[1] ) );
    unsigned short gl1s = getbigendian<unsigned short>( reinterpret_cast< const unsigned char * > ( &_tempHeader[0] ) );
    _mimoteraEvent->info()->_globalFrameNo =  (( (int) gl1s ) << 16 ) + (int) gl0s;
    _mimoteraEvent->info()->_frameInPacket = getbigendian<unsigned short>( reinterpret_cast< const unsigned char *>( &_tempHeader[2] ));
    _mimoteraEvent->info()->_triggeredFrameAB = getbigendian<unsigned short>( reinterpret_cast< const unsigned char *>( &_tempHeader[3] ));
    _mimoteraEvent->info()->_triggerNo = getbigendian<unsigned short>( reinterpret_cast< const unsigned char *>( &_tempHeader[4] ));

    _mimoteraFile->seekg( _mimoteraFile->tellg() + (streampos) kTrashSize );
    if ( _mimoteraFile->eof() ) return false;

    _currentPosition  = _mimoteraFile->tellg();

    if (  ( _currentPosition - _previousPosition != kEventSize ) ) {
      MIMOTERA_THROWX( FileReadException, "Wrong event size (" + to_string( _currentPosition - _previousPosition ) + to_string( " bytes)." ));
    }

    ++_iEvt;

    // don't forget to change the status of the mimotera event array ready flag
    _mimoteraEvent->_areArraysReady = false;

    // and also set the flag for current event ready
    if ( !_isEventReady ) _isEventReady = true;

    return true;
  }

  MimoteraEvent * MimoteraReader::getEvent() {

    if ( ! _isEventReady ) MIMOTERA_THROWX( EventNotReady, "Before getting the event, you must call readNextEvent()" );

    return _mimoteraEvent;

  }

  off_t MimoteraReader::open( const char * filename ) {

    if ( _mimoteraFile ) {
      // it means that _mimoteraFile was already instanciated and points to some file
      // close it first, then delete it before continuing
      _mimoteraFile->close();
      delete _mimoteraFile;
      _mimoteraFile = NULL;
    }

    // before trying to open the file, first check if the file really exists
    struct stat statbuf;
    int status = stat( filename, &statbuf );
    if ( status == -1 ) {
      MIMOTERA_THROWX( FileNotFoundException, to_string( "Problem opening file " ) + to_string( filename )
                       + to_string(".\n errno = " ) + to_string( errno ) + to_string( " --> " ) + to_string( strerror( errno ) ) );
    }

    // now check that the filename is pointing to a regular file or at least a symlink
    if ( ! ( S_ISREG( statbuf.st_mode ))  || ( S_ISLNK( statbuf.st_mode ) ) ) {
      MIMOTERA_THROWX( NotRegularFileException, to_string( "File " ) + to_string( filename ) + " is not a regular file" );
    }

    // the last test is checking if the file size is an integer multiple of the event size
    off_t filesize  = statbuf.st_size;
    off_t eventsize = kEventSize;

    if ( filesize % eventsize != 0 ) {
      MIMOTERA_THROWX( WrongFileSizeException, to_string( "The actual file size is " ) + to_string( filesize ) +
                       to_string( " and it is not an integer multiple of the event size (" ) + to_string( kEventSize ) + to_string( ")."));
    }

    // create the new _mimoteraFile pointer and open the file
    _mimoteraFile = new ifstream( filename, ios::binary );

    if ( _mimoteraFile ) {
      _hasValidFile = true;
      cout << "File: " << filename << endl
           << "Size: " << filesize << endl
           << "Evt : " << filesize/eventsize << endl;

    } else {
      _hasValidFile = false;
      MIMOTERA_THROWX( FileException, "Unknown error opening file " + to_string( filename ) );
    }

    return filesize;

  }


  MimoteraReader::~MimoteraReader() {

    if ( ! _mimoteraFile ) delete _mimoteraFile;
    if ( ! _mimoteraEvent ) delete _mimoteraEvent;
  }

  // C++ wrappers of C functions
  MimoteraReader * MimoteraReader_create_cpp( const char * filename ) {
    return new MimoteraReader( filename );
  }

  void MimoteraReader_dispose_cpp( MimoteraReader * reader ) {
    if ( ! reader )    delete reader;
    reader = NULL;
  }

  void MimoteraReader_open_cpp( MimoteraReader * reader, const char * filename ) {
    if ( ! reader ) return;
    reader->open( filename );
  }

  int MimoteraReader_readNextEvent_cpp( MimoteraReader * reader ) {
    if ( ! reader ) return 0;
    if ( reader->readNextEvent() ) return 1;
    else return 0;
  }

  MimoteraEvent * MimoteraReader_getEvent_cpp( MimoteraReader * reader ) {
    if ( ! reader ) return NULL;
    return reader->getEvent();
  }


} // endof of Mimotera namespace

---