EventFileExporter.cc

Go to the documentation of this file.

#include "EventFileExporter.h"


#include <io/EventFile.h>

#include <fwk/CentralConfig.h>
#include <fwk/RunController.h>

#include <evt/Event.h>

#include <det/Detector.h>

#include <sevt/SEvent.h>
#include <sevt/Header.h>
#include <sevt/EventTrigger.h>

#include <fevt/FEvent.h>
#include <fevt/Eye.h>
#include <fevt/EyeHeader.h>

#include <utl/config.h>
#include <utl/ErrorLogger.h>
#include <utl/Reader.h>
#include <utl/TimeStamp.h>

#include <EyeEvent.hh>

#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>

#include <cstddef>
#include <sstream>

namespace fs = boost::filesystem;
using namespace EventFileExporterOG;
using namespace fwk;
using namespace io;
using namespace evt;
using namespace utl;
using namespace std;


VModule::ResultFlag 
EventFileExporter::Init()
{
  
  Branch topBranch = CentralConfig::GetInstance()->GetTopBranch("EventFileExporter");
  
  const string fileType = topBranch.GetChild("OutputFileType").Get<string>();

  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 == "AIRES")
    fFileType = eAires;
  else if(fileType == "IoAuger")
    fFileType = eIoAuger;
  else if(fileType == "RadioAERAroot")
    fFileType = eRadioAERAroot;
  else{
    ostringstream err;
    err << "Unknown file type " << fileType << " in EventFileExporter::Init()";
    ERROR(err);
  }

  topBranch.GetChild("OutputFilename").GetData(fEventFilename);

  if (fFileType == io::eCorsika || fFileType == io::eAires) {
    ERROR("Output to strictly input only file types not allowed.");
    return eFailure;
  }
 
  // Read in streamer switch settings from XML and set the StreamerSwitch accordingly
  Branch sB = topBranch.GetChild("StreamerSwitches");

  if (sB) {
    //ostringstream msg;
    string sSwitch;

    if (sB.GetChild("FDRaw")) {
      sB.GetChild("FDRaw").GetData(sSwitch);
      if (sSwitch == string("off")) {
        //msg << "\n\tFDRaw data";
              //fStreamerSwitch.SetFDRaw(false);
              WARNING("Streamer switching is currently not supported ");
      }     
    }

    if (sB.GetChild("FDSimTraces")) {
      sB.GetChild("FDSimTraces").GetData(sSwitch);
      if (sSwitch == string("off")) {
        //msg << "\n\tFDSim photon traces";
        //fStreamerSwitch.SetFDSimPhotonTraces(false);
              WARNING("Streamer switching is currently not supported ");
      }     
    }

    if (sB.GetChild("FDSimTelescope")) {
      sB.GetChild("FDSimTelescope").GetData(sSwitch);
      if (sSwitch == string("off")) {
        //msg << "\n\tFDSim photon telescopes";
        //fStreamerSwitch.SetFDSimTelescope(false);
              WARNING("Streamer switching is currently not supported ");
      }     
    }

    if (sB.GetChild("SDSimPEHisto")) {
      sB.GetChild("SDSimPEHisto").GetData(sSwitch);
      if (sSwitch == string("off")) {
        //msg << "\n\tSD PMT simulated photoelectron time distributions";
        //fStreamerSwitch.SetSDSimPETimeDistribution(false);
              WARNING("Streamer switching is currently not supported ");
      }     
    }

    if (sB.GetChild("SDSimPMTBaseHisto")) {
      sB.GetChild("SDSimPMTBaseHisto").GetData(sSwitch);
      if (sSwitch == string("off")) {
        //msg << "\n\tSD PMT base time distributions";
        //fStreamerSwitch.SetSDSimPMTBaseTimeDistribution(false);
              WARNING("Streamer switching is currently not supported ");
      }     
    }

    if (sB.GetChild("SDSimPMTFilterHisto")) {
      sB.GetChild("SDSimPMTFilterHisto").GetData(sSwitch);
      if (sSwitch == string("off")) {
        //msg << "\n\tSD PMT filter time distributions";
        //fStreamerSwitch.SetSDSimPMTFilterTimeDistribution(false);
              WARNING("Streamer switching is currently not supported ");
      }     
    }

    if (sB.GetChild("SDSimTankParticles")) {
      sB.GetChild("SDSimTankParticles").GetData(sSwitch);
      if (sSwitch == string("on")) {
        //INFO("Switching on SD sim particle streamers.");
        //fStreamerSwitch.SetSDSimTankParticles(true);
      } else    
              WARNING("Streamer switching is currently not supported ");
    }

    if (sB.GetChild("CDSimRPCParticles")) {
      sB.GetChild("CDSimRPCParticles").GetData(sSwitch);
      if (sSwitch == string("on")) {
        //INFO("Switching on MARTA sim streamer for particles in RPC.");
        //fStreamerSwitch.SetMARTASimRPCParticles(true);
      } else    
              WARNING("Streamer switching is currently not supported ");
    }

    /*ostringstream info;
    info << "StreamerSwitch data found. ";
    if (msg.str().length())
      info << "Switching off the following streamers:"
           << msg.str();*/

  } else

    INFO("StreamerSwitch data not found.");

#warning INFO: the streamer-switches can also go entirely into the new Branch interface
  fEventFile = new EventFile(fEventFilename, io::eNew, fFileType, 0, fStreamerSwitch);
  return eSuccess;
}


VModule::ResultFlag 
EventFileExporter::Run(evt::Event& event) 
{
  fEventFile->Write(event);
  ++fEventsWritten;

  ++RunController::GetInstance().GetRunData().GetNamedCounters()["EventFileExporter/Events"];

  return eSuccess;
}


VModule::ResultFlag 
EventFileExporter::Finish() 
{ 
  std::ostringstream info;
  info << "Wrote " << fEventsWritten << " events.";  
  INFO(info); 
  
  fEventFile->Close();
  
  return eSuccess;
}