RawCorsikaFile.cc

Go to the documentation of this file.

#include <io/RawCorsikaFile.h>
#include <io/CorsikaBlock.h>
#include <io/CorsikaIOException.h>
#include <utl/ErrorLogger.h>

#include <string>
#include <sstream>
#include <iostream>

using namespace std;
using std::string;
using namespace io::Corsika;


RawFile::RawFile(const std::string& name) :
  fDiskStream(name.c_str())
{
  if (!fDiskStream) {
    const string msg = "Error opening Corsika file '" + name + "'.";
    ERROR(msg);
    throw io::CorsikaIOException(msg);
  }
}


bool
RawFile::Open(const std::string& name, const bool noException)
{
  if (fDiskStream.is_open()) {
    if (!noException) {
      const string msg = "Cannot open Corsika file '" + name +
        "' - *this is already open";
      ERROR(msg);
      throw io::CorsikaIOException(msg);
    }
    return false;
  }

  fDiskStream.open(name.c_str());

  if (!fDiskStream.is_open()) {
    if (!noException) {
      const string msg = "Error opening Corsika file '" + name + "'.";
      ERROR(msg);
      throw io::CorsikaIOException(msg);
    }
    return false;
  }

  // RU Mo 10. Okt 01:47:15 CEST 2016
  // search for string RUNH in first bytes of file.
  // the offset to RUNH is '4' in 32 bit linux, but different on different systems.
  // if RUNH is not found, the file is most certainly corrupt and will fail later
  bool foundRUNH = false;
  unsigned int posRUNH = 0;

  const unsigned int toRead = 20;
  char buff[toRead] = { '\0' };
  if (fDiskStream.read(buff, toRead)) {
    for ( ; posRUNH+3 < toRead; ++posRUNH) {
      if (buff[posRUNH+0] == 'R' &&
          buff[posRUNH+1] == 'U' &&
          buff[posRUNH+2] == 'N' &&
          buff[posRUNH+3] == 'H') {
        foundRUNH = true;
        break;
      }
    }
  }

  if (!foundRUNH) { // did not find anything. This is no corsika data.
    //fPaddingSize = 4;
    fDiskStream.close();
    return false;
  }

  fPaddingSize = posRUNH;

  fDiskStream.seekg(0, std::ios::beg); // now go back to beginning

  fCurrentBlockNumber = 0;
  fIndexInDiskBlock   = 0;
  fBlockBufferValid = false;
  return true;
}


void
RawFile::Close()
{
  if (fDiskStream.is_open())
    fDiskStream.close();
}


bool
RawFile::GetNextBlock(Block& block)
{
  const bool thinned = true;

  if (!fBlockBufferValid && !ReadDiskBlock(thinned))
    return false;

  block = fDiskThinnBlockBuffer.fBlock[fIndexInDiskBlock];
  if (++fIndexInDiskBlock >= kBlocksInDiskBlock) {
    ++fCurrentBlockNumber;
    fIndexInDiskBlock = 0;
    fBlockBufferValid = false;
  }

  return true;
}


bool
RawFile::GetNextBlockUnthinned(BlockUnthinned& block)
{
  const bool thinned = false;

  if (!fBlockBufferValid && !ReadDiskBlock(thinned))
    return false;

  block = fDiskUnthinnBlockBuffer.fBlock[fIndexInDiskBlock];
  if (++fIndexInDiskBlock >= kBlocksInDiskBlock) {
    ++fCurrentBlockNumber;
    fIndexInDiskBlock = 0;
    fBlockBufferValid = false;
  }

  return true;
}



bool
RawFile::ReadDiskBlock(const bool thinned)
{
  if (fDiskStream.tellg() < 0)
    fDiskStream.clear();

  const unsigned int size = thinned ? sizeof(ThinnedDiskBlock) : sizeof(UnthinnedDiskBlock);
  const unsigned int sizeDisk = size + 2*fPaddingSize;

  if (!fDiskStream.seekg(fCurrentBlockNumber * sizeDisk))
    return false;

  char padding[fPaddingSize];
  if (!fDiskStream.read(padding, fPaddingSize))
    return false;

  char* const buff = thinned ?
    reinterpret_cast<char*>(&fDiskThinnBlockBuffer) : reinterpret_cast<char*>(&fDiskUnthinnBlockBuffer);

  if (!fDiskStream.read(buff, size))
    return false;

  if (!fDiskStream.read(padding, fPaddingSize))
    return false;

  fBlockBufferValid = true;
  return true;
}


RawFile::PositionType
RawFile::GetNextPosition()
  const
{
  return fIndexInDiskBlock + kBlocksInDiskBlock * fCurrentBlockNumber;
}


void
RawFile::SeekTo(const PositionType position, const bool reset)
{
  PositionType newBlockNumber = position / kBlocksInDiskBlock;
  if (fCurrentBlockNumber != newBlockNumber) {
    fCurrentBlockNumber = newBlockNumber;
    fBlockBufferValid = false;
  }
  fIndexInDiskBlock = position % kBlocksInDiskBlock;
  if (reset)
    fBlockBufferValid = false;
}


bool
RawFile::IsOpen()
  const
{
  return fDiskStream.is_open();
}