RdEventMerger.cc

Go to the documentation of this file.

#include "RdEventMerger.h"

#include <fwk/CentralConfig.h>

#include <utl/Reader.h>
#include <utl/ErrorLogger.h>
#include <utl/TimeStamp.h>
#include <utl/TimeInterval.h>
#include <utl/TraceAlgorithm.h>

#include <io/EventFile.h>
#include <io/EventFileChain.h>
#include <io/CDASToOfflineEventConverter.h>

#include <AugerEvent.h>
#include <evt/Event.h>
#include <evt/Header.h>
#include <sevt/SEvent.h>
#include <sevt/Header.h>
#include <sevt/EventTrigger.h>
#include <revt/REvent.h>
#include <revt/EventTrigger.h>
#include <revt/Header.h>
#include <revt/StationTriggerData.h>
#include <revt/StationHeader.h>
#include <revt/StationGPSData.h>
#include <revt/Channel.h>
#include <revt/Station.h>

#include <rdet/RDetector.h>
#include <rdet/Station.h>

#include <fevt/FEvent.h>
#include <fevt/Header.h>

using namespace std;
using namespace utl;
using namespace fwk;
using namespace io;
using namespace evt;
using namespace sevt;
using namespace revt;

namespace RdEventMerger {

  RdEventMerger::RdEventMerger() :
    fInputFiles(0),
    fEventsWritten(0),
    fOfflineFile(NULL),
    fTempEvt(NULL),
    fSkipAERAlet(0)
  {
  }

  RdEventMerger::~RdEventMerger()
  {
    delete fOfflineFile ;
  }

  VModule::ResultFlag
  RdEventMerger::Init()
  {
    // Initialize your module here. This method
    // is called once at the beginning of the run.
    // The eSuccess flag indicates the method ended
    // successfully.  For other possible return types,
    // see the VModule documentation.

    INFO("RdEventMerger::Init()");

    // Read in the configurations of the xml file    
    Branch topBranch = CentralConfig::GetInstance()->GetTopBranch("RdEventMerger");

    topBranch.GetChild("OutputFile").GetData(fOffFilename);
    topBranch.GetChild("WriteMergedFile").GetData(fWriteMerged);
    topBranch.GetChild("BufferSize").GetData(fBufferSize);
    topBranch.GetChild("BufferIncrement").GetData(fBufferInc);
    topBranch.GetChild("RadioMerging").GetData(fRadioMerging);
    topBranch.GetChild("InputFilenames").GetData(fInputFilenames);

    topBranch.GetChild("Offset").GetData(fOffset);
    topBranch.GetChild("CoincidenceWindow").GetData(fCoinWindow);
    topBranch.GetChild("RadioOffset").GetData(fRadioOffset);
    topBranch.GetChild("SkipAERAlet").GetData(fSkipAERAlet);

    if (fBufferInc > fBufferSize) {
      INFO("<SdBufferIncrement> must be smaller than <SdBufferSize>");
      return eFailure;
    }

    // Read Sd input file type
    string fileType;
    topBranch.GetChild("InputFileType").GetData(fileType);
    if (fileType == "Offline")
      fFileType = eOffline;
    else if (fileType == "FDAS")
      fFileType = eFDas;
    else if (fileType == "CDAS")
      fFileType = eCDas;
    else if (fileType == "CORSIKA")
      fFileType = eCorsika;
    else if (fileType == "IoAuger")
      fFileType = eIoAuger;
    else if (fileType == "RadioAERA")
      fFileType = eRadioAERA;
    else if (fileType == "RadioAERAroot")
      fFileType = eRadioAERAroot;

    // Create hybrid output file
    std::ostringstream info;
    info << "Creating new merged hybrid output file: " << fOffFilename;
    INFO(info);
    if (fWriteMerged)
      fOfflineFile = new EventFile(fOffFilename, io::eNew, io::eOffline);

    // Opening input file(s)
    info.str("");
    info << "Opening input file(s): ";
    for (vector<string>::const_iterator fIt = fInputFilenames.begin(); fIt != fInputFilenames.end(); ++fIt)
    info << *fIt << " " ;
    INFO(info);

    fInputFiles = new EventFileChain(fInputFilenames, fFileType);

    // ASCII output file, for development purposes
    string filename = "out.txt"; 
    outfile.open(filename.c_str(),ios::out);

    return eSuccess;
  }


  VModule::ResultFlag
  RdEventMerger::Run(evt::Event& event)
  {

    // Read radio event (use EventFileReader)
    REvent& rEvent = event.GetREvent();
    stringstream message;
    message << "Radio event " << rEvent.GetHeader().GetId() 
      << " GPS second: " << rEvent.GetHeader().GetTime().GetGPSSecond()
      << " found with " << rEvent.GetNumberOfStations() << " stations!";
    INFO(message.str());

    // Start big while over all input events until coincidence is found or radio event is outside buffer
    while(1) {

      // Fill the buffer with input events
      while (fInputBuffer.size() < fBufferSize) {

        // Create temporary event and read next input event into it    
        fTempEvt = new Event(); 
        EndOfInputFiles = fInputFiles->Read(*fTempEvt);

        if (EndOfInputFiles) {
           INFO("#### End of input files reached, no more filling of buffer ####");
           // only if buffer is empty the last event has been reached, so break, 
           // otherwise only break filling of buffer loop
           if (!fInputBuffer.size()) {
             return eBreakLoop;
           } else {
             break;
           }
        }

        unsigned int Id;

        if (!fRadioMerging) {
          // Next lines are needed to get the whole (raw) Sd event
          // If you don't do this, you don't get the Trigger
          if(fTempEvt->HasRawEvent() && fTempEvt->GetRawEvent().HasSd()) {
            *fTempEvt << (fTempEvt)->GetRawEvent().Sd();
            Id = (fTempEvt)->GetSEvent().GetHeader().GetId();
            if ((fTempEvt)->GetSEvent().GetTrigger().GetAlgorithm()=="AERA" && fSkipAERAlet==true) {
              delete fTempEvt;
              continue;
            }
          }
          else {
            delete fTempEvt;
            continue;
          }
        }
        else Id = (fTempEvt)->GetREvent().GetHeader().GetId();

        // Get the event ID to sort the map (GPS second is not unique), and set the map element of the buffer

        fInputBuffer[Id] = *fTempEvt;

        delete fTempEvt;

      }// end while to fill buffer

      const revt::Header& RadioHead = rEvent.GetHeader();
      int StationNumber = RadioHead.GetNumberOfStations();
      double DeltaT;
      int CoinCount=0;
      utl::TimeStamp RdTime = RadioHead.GetTime();
      utl::TimeStamp InputTime,firstTime,lateTime,lastTime;

      // Create a bunch of iterators to select events from input buffer
      map<const unsigned int,evt::Event>::iterator firstInput = fInputBuffer.begin();
      map<const unsigned int,evt::Event>::iterator lastInput  = fInputBuffer.end();
      map<const unsigned int,evt::Event>::iterator lateInput = fInputBuffer.begin();
      map<const unsigned int,evt::Event>::iterator It = fInputBuffer.begin();
      map<const unsigned int,evt::Event>::iterator eraseInput = fInputBuffer.begin();

      // Move iterators into position
      lastInput--;
      if(fInputBuffer.size()<fBufferSize-fBufferInc)
        lateInput=lastInput;
      else
        advance(lateInput,(fBufferSize-fBufferInc-1));
      advance(eraseInput,fBufferInc);

      // Read time stamps of first and last event in buffer
      if (fRadioMerging) {
        firstTime=(firstInput->second).GetREvent().GetHeader().GetTime();
        lateTime=(lateInput->second).GetREvent().GetHeader().GetTime();
        lastTime=(lastInput->second).GetREvent().GetHeader().GetTime();
      }
      else {
        firstTime=(firstInput->second).GetSEvent().GetTrigger().GetTime();
        lateTime=(lateInput->second).GetSEvent().GetTrigger().GetTime();
        lastTime=(lastInput->second).GetSEvent().GetTrigger().GetTime();
      }

      // Check if Rd event is earlier than events in input buffer       
      if (RdTime+fCoinWindow < firstTime) {
        INFO("#### Radio event before input events, go to next event ####");
        return eSuccess;
      }
      // Check if Rd event is in main part of input buffer
      else if (RdTime < lateTime+fCoinWindow) {
        while (1) {
          if (fRadioMerging) InputTime=(It->second).GetREvent().GetHeader().GetTime()+fOffset;
          else InputTime=(It->second).GetSEvent().GetTrigger().GetTime()+fOffset;
          DeltaT=RdTime-InputTime;
          if (abs(DeltaT)<fCoinWindow) {
            INFO("#### Coincidence found in main part of buffer! ####");
            if(fRadioMerging) {
              int StationNumberadd = (It->second).GetREvent().GetHeader().GetNumberOfStations();
              event.GetREvent().GetHeader().SetNumberOfStations(max(StationNumberadd,StationNumber));
              for (revt::REvent::StationIterator sIt = (It->second).GetREvent().StationsBegin();
                sIt != (It->second).GetREvent().StationsEnd(); ++sIt) {
                revt::Station& station = *sIt;
                int station_id = station.GetId();
                // Create station and copy from buffer
                event.GetREvent().MakeStation(station_id);
                event.GetREvent().GetStation(station_id)=(It->second).GetREvent().GetStation(station_id);
                // Shift trace start by RadioOffset
                utl::TimeStamp TraceStart=event.GetREvent().GetStation(station_id).GetRawTraceStartTime();
                TraceStart=TraceStart+fRadioOffset;
                event.GetREvent().GetStation(station_id).SetRawTraceStartTime(TraceStart);
              }
            }           
            else {
              event.MakeSEvent();
              event.GetSEvent() = (It->second).GetSEvent();
              if ((It->second).HasFEvent()) {
                event.MakeFEvent();
                event.GetFEvent() = (It->second).GetFEvent();
                event.MakeRawEvent();
                event.GetRawEvent() = (It->second).GetRawEvent();
              }
            }
            if (fWriteMerged)
              fOfflineFile->Write(event);
            ExamineEvent(event);
            fEventsWritten++;
            INFO("#### Coincidence written ####");
            CoinCount++;
          }
          if (It==lateInput)
            break;
          It++;
        }
        message.str("");
        message << "#### Radio event in main part of input buffer, " << CoinCount << " coincidence(s) found ####" << endl
                 << "#### Leave buffer the same and move on to next radio event ####";
        INFO(message.str());
        return eSuccess;
      }

      // Check if Rd event is in advanced part of input buffer
      else if (RdTime <= lastTime) {
        advance(It,(fBufferSize-fBufferInc));
        while (It!=fInputBuffer.end()) {
          if (fRadioMerging) InputTime=(It->second).GetREvent().GetHeader().GetTime()+fOffset;
          else InputTime=(It->second).GetSEvent().GetTrigger().GetTime()+fOffset;
          DeltaT=RdTime-InputTime;
          if (abs(DeltaT)<fCoinWindow) {
            INFO("#### Coincidence found in advanced buffer! ####");
            if(fRadioMerging) {
              int StationNumberadd = (It->second).GetREvent().GetHeader().GetNumberOfStations();
              event.GetREvent().GetHeader().SetNumberOfStations(max(StationNumberadd,StationNumber));
              for (revt::REvent::StationIterator sIt = (It->second).GetREvent().StationsBegin();
                sIt != (It->second).GetREvent().StationsEnd(); ++sIt) {
                revt::Station& station = *sIt;
                int station_id = station.GetId();
                // Create station and copy from buffer
                event.GetREvent().MakeStation(station_id);
                event.GetREvent().GetStation(station_id)=(It->second).GetREvent().GetStation(station_id);
                // Shift trace start by RadioOffset
                utl::TimeStamp TraceStart=event.GetREvent().GetStation(station_id).GetRawTraceStartTime();
                TraceStart=TraceStart+fRadioOffset;
                event.GetREvent().GetStation(station_id).SetRawTraceStartTime(TraceStart);
              }
            }           
            else {
              event.MakeSEvent();
              event.GetSEvent() = (It->second).GetSEvent();
              if ((It->second).HasFEvent()) {
                event.MakeFEvent();
                event.GetFEvent() = (It->second).GetFEvent();
                event.MakeRawEvent();
                event.GetRawEvent() = (It->second).GetRawEvent();
              }
            } 
            if (fWriteMerged)
              fOfflineFile->Write(event);
            ExamineEvent(event);
            fEventsWritten++;
            INFO("#### Coincidence written ####");
            CoinCount++;
          }
          It++;
        }
        message.str("");
        message << "#### Radio event in advanced part of input buffer, " << CoinCount << " coincidence(s) found ####" << endl
                 << "#### Remove first " << fBufferInc << " elements from buffer and move on to next radio event ####";
        INFO(message.str());
        fInputBuffer.erase(firstInput,eraseInput);
        return eSuccess;
      }

      // Event must be later than input buffer
      else {
        if(EndOfInputFiles)
          fInputBuffer.erase(firstInput);
        else
          fInputBuffer.erase(firstInput,eraseInput);
        continue; // Restart big while loop to refill buffer
      }

    } // end big while loop

    return eSuccess;
  }

  // Function to examine the contents of the merged event and print to ascii file
  void RdEventMerger::ExamineEvent(evt::Event& event){

    revt::REvent& rEvent = event.GetREvent();
    const revt::Header& rHeader = rEvent.GetHeader();

    outfile << "#############################################################################" << endl
      << "Coincidence found for radio event with ID "
      << rHeader.GetId() << endl
      << "Number of stations: " << rEvent.GetNumberOfStations() << endl
      << "Timestamp: " << rHeader.GetTime() << endl
      << "#############################################################################" << endl << endl;

    // Loop through stations
    for (revt::REvent::StationIterator sIt = rEvent.StationsBegin();
      sIt != rEvent.StationsEnd(); ++sIt) {
      revt::Station& station = *sIt;
      outfile << "Radio station found with ID " << station.GetId() << endl
              << "Timestamp of station: " << station.GetRawTraceStartTime() << endl
              << "Hardware type: " << station.GetStationHeader().GetHardwareType() << endl;
    }

    if (event.HasSEvent()) {
    const SEvent& sevent = event.GetSEvent();
    const sevt::EventTrigger& SevtTrigger = sevent.GetTrigger() ;
    outfile << endl << "Coinciding Sd event: " << sevent.GetHeader().GetId() << endl
      << "Total # of stations: " << sevent.GetNumberOfStations() << endl
      << "Triggered # of stations: " << SevtTrigger.GetNStations() << endl
      << "Trigger sender: " << SevtTrigger.GetSender() << endl
      << "Algorithm: " << SevtTrigger.GetAlgorithm() << endl
      << "Time: " << sevent.GetHeader().GetTime() << endl << endl;
    }

  }// end examining

  VModule::ResultFlag
  RdEventMerger::Finish()
  {

  ostringstream info;
  info << "Wrote " << fEventsWritten << " merged events.";
  if (fWriteMerged)
    INFO(info);

  outfile.close(); // close ascii output
  if (fWriteMerged)
    fOfflineFile->Close();

  delete fInputFiles;

  return eSuccess;
  }

}