SenecaFileParser.cc

Go to the documentation of this file.

#include "SenecaFileParser.h"

#include <string>
#include <iostream>
#include <cstdlib>
#include <string.h>

#include <utl/AugerException.h>

using namespace std;
using namespace io;
using namespace utl;


SenecaFileParser::SenecaFileParser(const std::string& FileName, io::Mode mode) :
  SenecaFile()
{
  //DebugFile.open("SenecaFileParser.debug");
  FileOpen = EventHeaderValid = FileHeaderValid = ParticleRecordValid = false;
  SenecaFileName = "";
  OpenSenecaFile(FileName, mode);
}


SenecaFileParser::SenecaFileParser() :
  SenecaFile()
{
  //DebugFile.open("SenecaFileParser.debug");
  SenecaFileName = "";
  FileOpen = EventHeaderValid = FileHeaderValid = ParticleRecordValid = false;
}


SenecaFileParser::~SenecaFileParser()
{
  //DebugFile.close();
}


Status
SenecaFileParser::OpenSenecaFile(const std::string& FileName, Mode mode)
{
  unsigned char RecordBuffer[48];
  string msg;

  if (SenecaFile.is_open()) {
    string msg = "Seneca IO Exception: Failed to open " + FileName +
                 " because " + SenecaFileName + " is already open.\n";
    throw utl::IOFailureException(msg);
  }

  if (!SenecaFile) {
    msg = "Seneca IO Exception: Failed to open " + FileName + ".\n";
    throw utl::IOFailureException(msg);
  }

  if (mode != eRead) {
    //string msg = str(format("The Seneca implementation is currently read only."));
    //ERROR(msg);
    string msg = "Seneca IO Exception: Failed to open " + FileName +
                 " for writing. Currently read only.\n";
    throw utl::IOFailureException(msg);
  }
        
  FileOpen = false;

  SenecaFile.open(FileName.c_str(), ios::binary | ios::in);
        
  if (!SenecaFile) {
    msg = "Seneca IO Exception: Failed to open " + FileName + ". Does it exist?\n";
    throw utl::IOFailureException(msg);
  }
        
  //DebugFile << "SenecaFileParser: Opened file " << FileName << endl;
  SenecaFile.read((char*)RecordBuffer, 48);     //Seneca files have a 48byte header.
        
  FileHeaderValid = false;
  EventHeaderValid = false;
  ParticleRecordValid = false;
        
  if (DecodeFileHeader(RecordBuffer) == eFail) {
    SenecaFile.close();
    //msg = str(format("Error reading from the Seneca file. It isn't a Seneca file or is an unsupported version."));
    //ERROR(msg);
    msg = "Seneca IO Exception: Error reading from " + FileName + ". Either not a Seneca file or unsupported version.\n";
    throw utl::IOFailureException(msg);
  }

  //DebugFile << "SenecaFileParser: Read file header from " << FileName << endl;
  FileOpen = true;
  CurrentPosition = SenecaFile.tellg();
  CurrentEvent = NextEvent = 0;
  EventPositions[0] = CurrentPosition;
  SenecaFile.seekg(0, ios::end);
  FileSize = SenecaFile.tellg();
  SenecaFile.seekg(EventPositions[0]);

  return ProcessFile();
  //DebugFile << "SenecaFileParser: Successfully processed " << FileName << endl;
  //return eSuccess;
}


void
SenecaFileParser::CloseSenecaFile()
{
  SenecaFile.close();
  SenecaFile.clear();
  SenecaFileName = "";
  FileOpen = EventHeaderValid = FileHeaderValid = ParticleRecordValid = false;
}


unsigned int
SenecaFileParser::GetCurrentPosition()
{
  if (FileOpen)
    return SenecaFile.tellg();
  else
    return 0;
}


Status
SenecaFileParser::ProcessFile()
{
  unsigned char Buffer[24];
  int EventHeaderCheck = 0;
  unsigned int TempPosition;
        
  if (!FileOpen)
    return eFail;
        
  NumberEvents = 0;
        
  SenecaFile.seekg((EventPositions[0]));
  TempPosition = SenecaFile.tellg();
  while (TempPosition < FileSize) {
    SenecaFile.read((char*)Buffer, 24);
                
    EventHeaderCheck = SenecaDecodeInt(Buffer);
    if (EventHeaderCheck == -990) {
      SenecaFile.read((char*)Buffer, 24);
      EventHeaderCheck = SenecaDecodeInt(Buffer);
      if (EventHeaderCheck == -998) {
        EventPositions[NumberEvents] = TempPosition;
        ++NumberEvents;
      }
      TempPosition += 24;
    }
                
    TempPosition += 24;
  }
  SenecaFile.clear();
  SenecaFile.seekg(CurrentPosition);
        
  return eSuccess;
}


SenecaHeaderRecord*
SenecaFileParser::GetFileHeader()
{
        if (!FileOpen || FileHeaderValid==false)
        {
                return NULL;
        }
        else
        {
                return &FileHeader;
        }
}

io::SenecaEventHeaderRecord* io::SenecaFileParser::GetCurrentEventHeader()
{
        if (!FileOpen || EventHeaderValid==false)
        {
                return NULL;
        }
        else
        {
                return &EventHeader;
        }
}

io::SenecaParticleRecord* io::SenecaFileParser::GetParticleRecord()
{
        if (!FileOpen || ParticleRecordValid==false)
        {
                return NULL;
        }
        else
        {
                return &ParticleRecord;
        }
}

io::Status io::SenecaFileParser::GotoPosition(unsigned int thePosition)
{
        if (!FileOpen)
        {
                return eFail;
        }
        else if (thePosition > FileSize)
        {
                return eEOF;
        }
        else
        {
                SenecaFile.seekg(thePosition);
                return eSuccess;
        }
}

unsigned int io::SenecaFileParser::GetPosition()
{
        return SenecaFile.tellg();
}

io::Status io::SenecaFileParser::GotoEvent(unsigned int theEventNumber)
{
        unsigned char EventHeaderBuffer[48];
//      DebugFile << "SenecaFileParser: Trying to read event number " << theEventNumber << "." << endl;
        if (!FileOpen)
        {
                return eFail;
        }
        else if (theEventNumber>NumberEvents)
        {
//              cout << theEventNumber << " " << NumberEvents << endl;
//              DebugFile << "SenecaFileParser: " << theEventNumber << "is not a valid event. End of file reached." << endl;
                return eEOF;
        }
        else if (theEventNumber<1)
        {
                return eFail;
        }
        else
        {
                SenecaFile.seekg(EventPositions[theEventNumber-1], ios::beg);
                SenecaFile.read((char*)EventHeaderBuffer,48);
                CurrentPosition=SenecaFile.tellg();
                if (DecodeEventHeader(EventHeaderBuffer)==eSuccess)
                {
                        EventHeader.ID=theEventNumber-1;
                        EventHeaderValid=true;
                        CurrentEvent=theEventNumber-1;
                        NextEvent=theEventNumber;
//                      if (NextEvent>NumberEvents)
//                              NextEvent=NumberEvents;
//                      DebugFile << "SenecaFileParser: Successfully read event " << theEventNumber << endl;
                        return eSuccess;
                }
                else
                {
                        EventHeaderValid=false;
                        CurrentEvent=0;
                        return eFail;
                }
        }
}

io::Status io::SenecaFileParser::GetNextEvent()
{
        return GotoEvent(NextEvent+1);
}

io::Status io::SenecaFileParser::ReadParticle()
{
        unsigned char ParticleBuffer[24];
//      DebugFile << "SenecaFileParser: Trying to read a particle." << endl;
        if (!FileOpen || EventHeaderValid==false)
        {
//              DebugFile << "SenecaFileParser: The file is invalid trying to read the particle!" << endl;
                return eFail;
        }
        else
        {
//              cout << "Trying to read a particle record." << endl;
                SenecaFile.read((char*)ParticleBuffer,24);
                CurrentPosition=SenecaFile.tellg();
                if (DecodeParticleRecord(ParticleBuffer)==eSuccess)
                {
//                      cout << "Read a particle ok." << endl;
                        ParticleRecordValid=true;
//                      DebugFile << "SenecaFileParser: Read a particle." << endl;
                        return eSuccess;
                }
                else
                {
//                      cout << "Failed to read a particle." << endl;
//                      DebugFile << "SenecaFileParser: Couldn't read a particle!" << endl;
                        ParticleRecordValid=false;
                        return eFail;
                }
        }
}


io::Status io::SenecaFileParser::FileStatus()
{
        if (!SenecaFile.is_open())
        {
                return eFail;
        }
        else if (SenecaFile.eof())
                return eEOF;
        else
        {
                return eSuccess;
        }
}

io::Status io::SenecaFileParser::DecodeEventHeader(unsigned char* FileData)
{
        EventHeader.ID=SenecaDecodeInt(FileData);
//      DebugFile << "SenecaFileParser: Trying to decode event header." << endl;
        if (EventHeader.ID==-990)
        {
                EventHeader.E0=SenecaDecodeFloat(FileData+3+24);
                EventHeader.ID0=SenecaDecodeInt(FileData+6+24);
                EventHeader.Theta=SenecaDecodeFloat(FileData+9+24);
                EventHeader.Phi=SenecaDecodeFloat(FileData+12+24);
                EventHeaderValid=true;
//              DebugFile << "SenecaFileParser: Successfully decoded event header." << endl;
                return eSuccess;
        }
        else
        {
                EventHeaderValid=false;
                return eFail;
        }
}

io::Status io::SenecaFileParser::DecodeFileHeader(unsigned char* FileData)
{
        FileHeader.ID=SenecaDecodeInt(FileData);
//      DebugFile << "SenecaFileParser: Trying to decode file header." << endl;
        if (FileHeader.ID!=0x006e6573)
                return eFail;
        
        FileHeader.SenecaVersion=atof((char*)(FileData+7));
        
        if (!strncmp((char*)(FileData+11),"QGS98",5))
                FileHeader.HadronicSim=eSenecaQGS98;
        else if (!strncmp((char*)(FileData+11),"QGS01",5))
                FileHeader.HadronicSim=eSenecaQGS01;
        else if (!strncmp((char*)(FileData+11),"SIB21",5))
                FileHeader.HadronicSim=eSenecaSib21;
        else if (!strncmp((char*)(FileData+11),"NEX2",4))
                FileHeader.HadronicSim=eSenecaNex2;
        else if (!strncmp((char*)(FileData+11),"NEX397",6))
                FileHeader.HadronicSim=eSenecaNex397;
        else
                FileHeader.HadronicSim=eSenecaUnknown;
        
        if (!strncmp((char*)(FileData+17),"GHEISHA",7))
                FileHeader.EMSim=eSenecaGheisha;
        else if (!strncmp((char*)(FileData+17),"GFLUKA",7))
                FileHeader.EMSim=eSenecaGFluka;
        else if (!strncmp((char*)(FileData+17),"GCALOR",6))
                FileHeader.EMSim=eSenecaGCalor;
        else if (!strncmp((char*)(FileData+17),"URQMD",5))
                FileHeader.EMSim=eSenecaURQMD;
        else
                FileHeader.EMSim=eSenecaUnknown;

        FileHeader.ID=SenecaDecodeInt(FileData+24);
                
        if (FileHeader.ID==-999)
        {
                FileHeader.HGround=SenecaDecodeFloat(FileData+3+24);
                FileHeader.HObs=SenecaDecodeFloat(FileData+6+24);
                FileHeader.HCore=SenecaDecodeFloat(FileData+9+24);
                FileHeader.HINJ=SenecaDecodeFloat(FileData+12+24);
                FileHeader.ILowHadr=SenecaDecodeInt(FileData+15+24);
                FileHeader.IOHadr=SenecaDecodeInt(FileData+18+24);
                FileHeader.IVersion=SenecaDecodeInt(FileData+21+24);
        }
        
        FileHeaderValid=true;
//      DebugFile << "SenecaFileParser: Successfully decoded file header." << endl;
        return eSuccess;
}

io::Status io::SenecaFileParser::DecodeParticleRecord(unsigned char* FileData)
{
        ParticleRecord.ID=SenecaDecodeInt(FileData);
//      DebugFile << "SenecaFileParser: Trying to decode a particle record." << endl;
        if (ParticleRecord.ID==-990 || ParticleRecord.ID==-999 || ParticleRecord.ID==-998)
                return eFail;
        ParticleRecord.Weight=SenecaDecodeFloat(FileData+3);
        ParticleRecord.X=SenecaDecodeFloat(FileData+6);
        ParticleRecord.Y=SenecaDecodeFloat(FileData+9);
        ParticleRecord.T=SenecaDecodeFloat(FileData+12);
        ParticleRecord.Px=SenecaDecodeFloat(FileData+15);
        ParticleRecord.Py=SenecaDecodeFloat(FileData+18);
        ParticleRecord.Pz=SenecaDecodeFloat(FileData+21);
        
        ParticleRecordValid=true;
//      DebugFile << "SenecaFileParser: Successfully decoded a particle record." << endl;
        return eSuccess;
}



/*
Seneca data files have floating point numbers in a 3 byte form. SenecaDecodeFloat
takes a pointer to the 3 byte float (in the form of an char* so that each byte can
be accessed individually) and returns a C float with the value encoded in the 3
byte form.
*/
float io::SenecaFileParser::SenecaDecodeFloat(unsigned char* FileData)
{
        unsigned char sign;
        unsigned int mantissa, shift1, shift2, shifted;
        signed char exponent;
        float decoded;
        
        if (FileData[0]==0 && FileData[1]==0 && FileData[2]==0)
                return 0.0;
        
        sign=FileData[2]>>7;
        exponent=(signed char)( (unsigned char)(FileData[2] & 0x7f) );
        mantissa=(unsigned int)FileData[1];
        mantissa<<=8;
        mantissa+=(unsigned int)FileData[0];
        
        shift1=(unsigned int)sign;
        shift2=(unsigned int)(exponent+64);
        shift1<<=31;
        shift2<<=23;
        mantissa<<=7;
        shifted=shift1+shift2+mantissa;
        
        memcpy(&decoded,&shifted,4);
        
        return decoded;
}

/*
Seneca data files have integers in a 3 byte form. SenecaDecodeInt takes a pointer
to the 3 byte integer (in the form of an char* so that each byte can be accessed
individually) and returns a C int with the value encoded in the 3 byte form.
*/

int io::SenecaFileParser::SenecaDecodeInt(unsigned char* FileData)
{
        unsigned int holder;
        signed int decoded;
        
        holder=(unsigned int)FileData[2];
        holder<<=8;
        holder+=(unsigned int)FileData[1];
        holder<<=8;
        holder+=(unsigned int)FileData[0];
        
        if (holder & 0x800000)
        {
                if (holder & 0x400000)
                        decoded=(signed int)(holder^0xff000000);
                else
                        decoded=-1*(signed int)( holder ^ 0x800000 );
        }
        else
                decoded=(signed int)holder;
        
        return decoded;
}

unsigned int io::SenecaFileParser::GetNumberEvents()
{
//      DebugFile << "SenecaFileParser: The are " << NumberEvents << " events in this file." << endl;
        if (!SenecaFile.is_open())
        {
                string msg="Seneca IO Exception: No file is open. No number of events.\n";
                throw utl::IOFailureException(msg);
        }
        return NumberEvents;
}
unsigned int io::SenecaFileParser::GetCurrentEvent()
{
//      DebugFile << "SenecaFileParser: The are " << NumberEvents << " events in this file." << endl;
        if (!SenecaFile.is_open())
        {
                string msg="Seneca IO Exception: No file is open. No event open.\n";
                throw utl::IOFailureException(msg);
        }
        return CurrentEvent+1;
}