EventFile.cc

Go to the documentation of this file.

#include <io/EventFile.h>
#include <utl/config.h>

#include <io/VEventFile.h>
#include <io/StreamerSwitch.h>

#include <io/OfflineROOTFile.h>
#include <io/CDASEventFile.h>
#include <io/FDasEventFile.h>
#include <io/CorsikaShowerFile.h>
#include <io/SenecaShowerFile.h>
#include <io/ArtificialShowerFile.h>

#include <IoAuger.h>
// Seneca header include added by Jeff Allen (jda292@nyu.edu) on Dec. 5th, 2006
#ifdef HAVE_AIRES
#  include <io/AiresShowerFile.h>
#endif
#include <io/CONEXFile.h>
#include <io/CONEXRandomFile.h>
#include <io/IoAugerEventFile.h>
#include <io/ZHAireSFile.h>
#include <io/REASFile.h>
#include <io/REASH5File.h>
#include <io/EVAFile.h>
#include <io/RadioFileAERA.h>
#include <io/RadioFileAERAroot.h>
#include <io/SELFASFile.h>
#include <evt/Event.h>

#include <cstddef>
#include <iostream>

using namespace std;
using namespace io;


const StreamerSwitch EventFile::kDefaultSwitch;


EventFile::EventFile(const Type type, utl::Branch* const /*b*/) :
  fType(type),
  fStreamerSwitch(kDefaultSwitch)
{ }


EventFile::EventFile(const std::string& filename,
                     const Mode mode,
                     const Type type,
                     utl::Branch* const b,
                     const StreamerSwitch& streamerSwitch) :
  fVEventFile(EventFile::Factory(filename, mode, type, b, streamerSwitch)),
  fType(type),
  fStreamerSwitch(streamerSwitch)
{ }


EventFile::~EventFile()
{
  Close();
  delete fVEventFile;
}


VEventFile*
EventFile::Factory(const string& filename,
                   const Mode mode,
                   const Type type,
                   utl::Branch* const b,
                   const StreamerSwitch& streamerSwitch)
{
  switch (type) {
  case eOffline:
    return new OfflineROOTFile(filename, mode, b, streamerSwitch);
  case eCDas:
    return new CDASEventFile(filename, mode, b);
  case eFDas:
    return new FDasEventFile(filename, mode, b);
  case eCorsika:
    return new CorsikaShowerFile(filename, mode, b);
  // Added by Jeff Allen (jda292@nyu.edu) on Dec. 5th, 2006. Seneca file
  case eSeneca:
    return new SenecaShowerFile(filename, mode, b);
  case eArtificial:
    return new ArtificialShowerFile(filename, mode, b);
#ifdef HAVE_AIRES
  case eAires:
    return new AiresShowerFile(filename, mode, b);
#endif
  case eIoAuger:
    return new IoAugerEventFile(filename, mode, b);
  case eCONEX:
    return new CONEXFile(filename, mode, b);
  case eCONEXRandom:
    return new CONEXRandomFile(filename, mode, b);
  case eZHAireS:
    return new ZHAireSFile(filename, mode, b);
  case eREAS:
    return new REASFile(filename, mode, b);
  case eREASH5:
    return new REASH5File(filename, mode, b);
  //case eReAires:
  //  return new ReAiresFile(filename, mode);
  case eEVA:
    return new EVAFile(filename, mode, b);
  case eRadioAERA:
    return new RadioFileAERA(filename, mode, b);
  case eRadioAERAroot:
    return new RadioFileAERAroot(filename, mode, b);  
  case eSELFAS:
    return new SELFASFile(filename, mode, b);
  default:
    throw utl::IOFailureException("Unknown file type specified");
  }
}


void
EventFile::Open(const std::string& filename, const Mode mode, utl::Branch* const b)
{
  if (!fVEventFile)
    fVEventFile = EventFile::Factory(filename, mode, fType, b, fStreamerSwitch);

  fVEventFile->Open(filename, mode, b);
}


void
EventFile::Close()
{
  if (fVEventFile)
    fVEventFile->Close();
}


void
EventFile::Write(const evt::Event& event)
{
  if (!fVEventFile)
    throw utl::IOFailureException("Open file before calling Write()");

  fVEventFile->Write(event);
}


Status
EventFile::Read(evt::Event& event)
{
  if (!fVEventFile)
    throw utl::IOFailureException("Open file before calling Read()");

  event = evt::Event();

  return fVEventFile->Read(event);
}



Status
EventFile::FindEvent(const unsigned int eventId)
{
  if (!fVEventFile)
    throw utl::IOFailureException("Open file before calling FindEvent()");

  return fVEventFile->FindEvent(eventId);
}


Status
EventFile::GotoPosition(const unsigned int position)
{
  if (!fVEventFile)
    throw utl::IOFailureException("Open file before calling GotoPosition()");

  return fVEventFile->GotoPosition(position);
}


int
EventFile::GetNEvents()
{
  return fVEventFile ? fVEventFile->GetNEvents() : -1;
}


const std::string&
EventFile::GetFilename()
  const
{
  static const string empty;

  return fVEventFile ? fVEventFile->GetFilename() : empty;
}