FDasToOfflineEventConverter.cc

Go to the documentation of this file.

#include <AugerEvent.h>
#include <EyeEvent.hh>
#include <EyeEventHeader.hh>
#include <FadcData.hh>
#include <FdNumbering.hh>
#include <FDEventLibVersion.hh>

#include <io/FDasToOfflineEventConverter.h>

#include <evt/Event.h>
#include <evt/Header.h>

#include <fevt/FEvent.h>
#include <fevt/Header.h>
#include <fevt/Eye.h>
#include <fevt/EyeHeader.h>
#include <fevt/Telescope.h>
#include <fevt/Channel.h>
#include <fevt/Pixel.h>

#include <utl/Trace.h>
#include <utl/TimeStamp.h>
#include <utl/TabulatedFunction.h>
#include <utl/AugerUnits.h>

#include <utl/ErrorLogger.h>
#include <algorithm>
#include <sstream>

using namespace fevt;
using namespace std;

namespace io {
    
  void
  operator<<(evt::Event& theEvent, const TEyeEvent& theData)
  {
    if (!theEvent.HasFEvent()) 
      theEvent.MakeFEvent();
    
    fevt::FEvent& fevent = theEvent.GetFEvent();
        
    TEyeEventHeader* const eyeheader = 
      const_cast<TEyeEvent&>(theData).GetEventHeader();

    const unsigned int sec = eyeheader->GetTimeStamp()->GetGPSSec();
    const unsigned int nsec = eyeheader->GetTimeStamp()->GetNanoSec();
    
    const utl::TimeStamp tstamp(sec, nsec); 

    const int eyeid = eyeheader->GetEyeNo();
    
#if FDEVENTLIB_VERSION_CODE < ModuleVersionCode(4, 0, 0)
    if (eyeid > 4) {
      ostringstream msg;
      msg << "Trying to read data with eye ids > 4 (HEAT) using an "
          << "FDEventLib older than v4r0. Old FDEventLibs do not support "
          << "HEAT data. I will skip this eye (id=" << eyeid << ").";
      WARNING(msg.str());
      return;
    }
#endif

    if (fevent.HasEye(eyeid)) {
      
      ostringstream err;
      err << "\n\n\n\n"
             " *************************************************************\n"
             " *************************************************************\n"
             " *  FDAS raw-eye with Id=" << eyeid << " added twice!"
             " *  Report corrupt data, or check your input files!\n"
             " *************************************************************\n"
             " *************************************************************"
             "\n\n\n";
      ERROR(err.str());
    }
    fevent.MakeEye(eyeid);

    // ----------- do the EyeHeader ---------------

    if (!fevent.GetEye(eyeid).HasHeader()) 
      fevent.GetEye(eyeid).MakeHeader(); 
    
    EyeHeader& headerEye = fevent.GetEye(eyeid).GetHeader();
    Header& headerFEvent = fevent.GetHeader();
        
    // Fill offline header
        
    const unsigned int runno = eyeheader->GetRunNo();
    const unsigned int evno  = eyeheader->GetEventNo();
    const int eclass         = eyeheader->GetEventClass();
    const int etype          = eyeheader->GetEventType();
    
    // fill evt::Header of Event
    evt::Header& evtHeader = theEvent.GetHeader();
    const utl::TimeStamp& previous_time = evtHeader.GetTime();
    const std::string& previous_str = evtHeader.GetId();

    if (!previous_time.GetGPSSecond() ||
        previous_time > tstamp)
      theEvent.GetHeader().SetTime(tstamp);

    ostringstream id_str;
    if (!previous_str.empty())
      id_str << previous_str << "__";
    id_str << "eye" << eyeid
           << "_run" << runno
           << "_event" << evno;
    theEvent.GetHeader().SetId(id_str.str());

    // Fill header of FEvent
    headerFEvent.SetId(eyeid); // to be set
    headerFEvent.SetNEyes(headerFEvent.GetNEyes() + 1);
    headerFEvent.SetTime(tstamp);  
    // Fill header of eye  
    headerEye.SetTimeStamp(tstamp);
    headerEye.SetEventNumber(evno);
    headerEye.SetRunNumber(runno);
    headerEye.SetEventType(static_cast<fevt::EyeHeader::EventType>(etype));
    headerEye.SetEventClass(static_cast<fevt::EyeHeader::EventClass>(eclass));

    // copy the telescope time offset into the Offline data structure
    for (unsigned int i = FdUtil::Fd::kEYE_FIRST_MIRROR;
         i <=  FdUtil::Fd::kEYE_LAST_MIRROR; ++i)

      if (eyeheader->IsMirrorDataPresent(i)) {
        
        if (!fevent.GetEye(eyeid).HasTelescope(i)) 
          fevent.GetEye(eyeid).MakeTelescope(i);
        
        fevt::Telescope& telescope = fevent.GetEye(eyeid).GetTelescope(i);
        telescope.SetTimeOffset(eyeheader->GetMirrorTimeOffset(i));
        
        ostringstream pointing;
        pointing << "data: ";
#if FDEVENTLIB_VERSION_CODE >= ModuleVersionCode(4, 0, 4)
        TEyeGeometryData * const eyeGeometry = 
          const_cast<TEyeEvent&>(theData).GetGeometryData();
        if (!eyeGeometry) {
          pointing << "unknown";
        }
        else {
          float pointingElev, pointingPhi;
          eyeGeometry->GetAxisDirection(i, pointingPhi, pointingElev);
          pointing << pointingElev;
        }
#else
        pointing << "unknown";
#endif  
        telescope.SetRawTelPointing(pointing.str());
      }
  }
  

  // RETHINK + REDO
  void
  operator>>(const fevt::Eye& /*eyeEvent*/, TEyeEvent& /*data*/)
  {
    /*
    if (!theData) {
        
        ERROR("NULL TEyeEvent object passed to PushEvent().");
        return;
    }
    */

    /*
    if (!theEyeEvent.HasRawEvent()) {
        
        ERROR("Non-existent evt::Event::GetRawEvent() class object.");
        return;
    }
    */

    /*
    // this is because AugerEvent lacks a const EyesBegin
    AugerEvent& non_const_event 
    = const_cast<AugerEvent&>(theEvent.GetRawEvent()); 
    
    AugerEvent::EyeIterator eyeiter =  non_const_event.EyesBegin();
    
    // do nothing if the raw eye has not been filled
    if (eyeiter != non_const_event.EyesEnd()) {
        
        *theData = *eyeiter;
        
        }
    */
  }

}


// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// End: