FDasEventFile.cc

Go to the documentation of this file.

#include <AugerEvent.h>
#include <io/FDasEventFile.h>
#include <io/VROOTFile.h>
#include <io/FDasToOfflineEventConverter.h>
#include <EyeEvent.hh>
#include <EyeEventFile.hh>
#include <evt/Event.h>
#include <fevt/FEvent.h>
#include <fevt/Eye.h>
#include <fevt/EyeHeader.h>

#include <utl/ErrorLogger.h>

#include <cstddef>
#include <sstream>
#include <map>

using namespace std;
using namespace io;
using namespace fevt;


FDasEventFile::~FDasEventFile()
{
  for (const auto& f : fEyeEventFile)
    delete f.second;
  delete fCurEyeEvent;
}


FDasEventFile::FDasEventFile(const std::string& filename, const Mode mode, utl::Branch* const b) :
  VEventFile(),
  fCurEyeEvent(new TEyeEvent)
{
  Open(filename, mode, b);
}


void
FDasEventFile::Open(const std::string& filename, const Mode mode, utl::Branch* const /*b*/)
{
  fFilename = filename;
  fMode = mode;

  if (fMode == io::eRead) {

    TEyeEventFile* const tmpFile =
      new TEyeEventFile(filename.c_str(),
                        VROOTFile::GetRootMode(fMode).c_str());

    if (tmpFile->IsZombie()) {
      std::ostringstream mess;
      mess << "Unable to open file " << filename;
      throw utl::IOFailureException(mess.str());
    }

    if (!tmpFile->GetNEvents()) {
      std::ostringstream mess;
      mess << "File is empty " << filename;
      throw utl::IOFailureException(mess.str());
    }

    TEyeEvent* tmpEvent = new TEyeEvent();
    tmpFile->ReadEvent(&tmpEvent);
    const unsigned int eyeId = tmpEvent->GetEventHeader()->GetEyeNo();
    delete tmpEvent;

    tmpFile->Rewind();

    fEyeEventFile[eyeId] = tmpFile;

  }
}


void
FDasEventFile::Close()
{
  for (const auto& f : fEyeEventFile) {
    f.second->Close();
    delete f.second;
  }
  fEyeEventFile.clear();
}


Status
FDasEventFile::Read(evt::Event& event)
{
  int countEvents = 0;

  for (const auto& f : fEyeEventFile) {

    if (!event.HasFEvent())
      event.MakeFEvent();

    fCurEyeEvent->Clear();

    if (f.second->ReadEvent(&fCurEyeEvent)) {

      /*
        copy the TEyeEvent into the AugerEvent embedded into the Offline
        evt::Event, that should be the only source of raw data

        Take care, because AugerEvent::PushEvent makes no check
        for duplicate-eyes, do this here, to prevent big lists of EyeEvents.
      */

      const unsigned int eyeId = fCurEyeEvent->GetEventHeader()->GetEyeNo();

      if (!event.HasRawEvent())
        event.MakeRawEvent();

      AugerEvent& raw = event.GetRawEvent();

      AugerEvent::EyeIterator eyeIter;
      for (eyeIter = raw.EyesBegin(); eyeIter != raw.EyesEnd(); ++eyeIter)
        if (eyeIter->GetEventHeader()->GetEyeNo() == eyeId)
          break;

      if (eyeIter == raw.EyesEnd())
        raw.PushEvent(*fCurEyeEvent);
      else
        *eyeIter = *fCurEyeEvent;

      event << *fCurEyeEvent;

      ++countEvents;
    }

    //return eSuccess;

  }

  return (countEvents > 0) ? eSuccess : eEOF;
}


void
FDasEventFile::Write(const evt::Event& event)
{
  if (fMode == eRead) {
    ERROR("File is ReadOnly");
    throw utl::IOFailureException("File is Read Only");
  }

  fCurEyeEvent->Clear();

  evt::Event& ncEvent = const_cast<evt::Event&>(event);

  if (!ncEvent.HasRawEvent() ||
      (ncEvent.GetRawEvent().EyesBegin() == ncEvent.GetRawEvent().EyesEnd())) {
    INFO("No raw FD event to write");
    return;
  }

  AugerEvent& raw = ncEvent.GetRawEvent();

  for (AugerEvent::EyeIterator eyeIter = raw.EyesBegin();
       eyeIter != raw.EyesEnd(); ++eyeIter) {

    unsigned int eyeId = eyeIter->GetEventHeader()->GetEyeNo();

    if (!fEyeEventFile.count(eyeId)) {

      ostringstream eyeFileName;
      eyeFileName << fFilename.substr(0, fFilename.rfind('.'))
                  << ".eye" << eyeId << ".root";

      fEyeEventFile[eyeId] =
        new TEyeEventFile(eyeFileName.str().c_str(),
                          VROOTFile::GetRootMode(fMode).c_str());

    }

    *fCurEyeEvent = *eyeIter;
    fEyeEventFile[eyeId]->WriteEvent(&fCurEyeEvent);

  }
}


int
FDasEventFile::GetNEvents()
{
  int nEvents = 0;
  bool first = true;
  for (const auto& f : fEyeEventFile) {
    const int n = f.second->GetNEvents();
    if (first) {
      nEvents = n;
      first = false;
    } else if (n < nEvents)
      nEvents = n;
  }
  return nEvents;
}


Status
FDasEventFile::GotoPosition(const unsigned int position)
{
  for (const auto& f : fEyeEventFile)
    f.second->Seek(position);
  return eSuccess;
}


Status
FDasEventFile::FindEvent(const unsigned int eventid)
{
  for (const auto& f : fEyeEventFile) {
    auto& file = *f.second;
    file.Rewind();
    unsigned int posInTree = 0;
    TEyeEventHeader* header = nullptr;
    while (file.ReadEventHeader(&header)) {
      if (eventid == header->GetEventNo()) {
        file.Seek(posInTree);
        return io::eSuccess;
      }
      ++posInTree;
    }
  }
  return eFail;
}