EVAFile.h

Go to the documentation of this file.

#ifndef _io_EVAFile_h_
#define _io_EVAFile_h_

#include <io/EVAIOException.h>
#include <io/VEventFile.h>
#include <io/CorsikaUtilities.h>
#include <dirent.h>
#include <fstream>
#include <vector>
#include <utl/Vector.h>
#include <revt/Station.h>


namespace evt {
  class Event;
  class ShowerSimData;
}

namespace io {

  // Helper struct to store the file information

  struct SubfileInfo {
    SubfileInfo(const std::string& fstr, const utl::Vector3D& p, const double b)
      : filestring(fstr), position(p), binning_EVA(b) { }
    std::string filestring;
    utl::Vector3D position;
    double binning_EVA;
  private:
    SubfileInfo();
  };


  class EVAFile : public VEventFile {

  public:
    EVAFile() { }
    EVAFile(const std::string& filename, const Mode filemode = eRead, utl::Branch* const b = nullptr);
    virtual ~EVAFile() { }

    virtual Status Read(evt::Event& event);
    virtual void Write(const evt::Event& event);
    virtual Status FindEvent(const unsigned int eventId);
    virtual int GetNEvents() { return 1; }  // there is currently one event in a EVA file (hard-coded)
    virtual void Open(const std::string& filename, const io::Mode filemode = eRead, utl::Branch* const b = nullptr);
    virtual void Close() { file_open = false; }
    virtual io::Status GotoPosition(const unsigned int pos);

  private:
    // Copy-constructor are made private because they may not be used
    EVAFile(const EVAFile&);

    bool CheckFileExtension(const std::string& filename, const std::string& extension) const;
    void CheckFileReadability(const std::string& filename, const Mode filemode) const;
    void OpenFile(const std::string& filename);
    void ReadBaseFileQuantities();
    void ReadSubfileList();
    bool ReadShowerData(evt::Event&);
    bool ReadRadioSimData(evt::Event&);
    bool ReadSubfileHeader(std::ifstream&);
    bool ReadSubfileLine(std::ifstream&, double&, double* const);

    // Helper function for reading the data from a file
    template<class T>
    T
    ReadQuantity(const std::string& var_name = "", const std::string& unit = "",
                 const bool optional = false, const bool only_if = true, const T default_value = T())
    {
      if (!only_if)
        return default_value;

      if (!var_name.empty()) {
        const std::streampos oldpos = input_file.tellg();
        std::string input_var_name;
        input_file >> std::ws >> input_var_name;
        if (input_var_name != var_name) {
          if (!optional) {
            input_file.seekg(oldpos);
            std::ostringstream msg;
            msg << "Error reading variable name from " << filename << " file: expected " << var_name
                << " got " << input_var_name << " instead.";
            throw io::EVAIOException(msg.str());
          } else {
            input_file.seekg(oldpos);
            return default_value;
          }
        }
      }

      T ret_val;
      input_file >> ret_val;

      if (unit != std::string("")) {
        std::string input_unit;
        input_file >> std::ws >> input_unit;
        if (input_unit != unit) {
          std::ostringstream msg;
          msg << "Error reading unit for the variable '" << var_name
              << "' from .mgmr file: expected " << unit
              << " got " << input_unit << " instead.";
          throw io::EVAIOException(msg.str());
        }
      }

      return ret_val;
    }

    // logistics for reading the file
    std::string filename;
    std::string filetype;
    std::string name;
    std::string path_name;
    std::string version_string;
    std::string file_extension;
    std::vector<SubfileInfo> sub_file_list;
    std::ifstream input_file;
    bool file_open = false;
    unsigned int events_remaining = 1;  // there is currently one event in a EVA file (hard-coded)

    // This is all data that is read from the .mgmr file.
    utl::Vector3D core_position;
    utl::Vector3D refcoord;
    std::string primary_particle_str;
    double primary_energy = 0;
    double detector_level = 0;
    double zenith_angle = 0;
    double azimuth_angle = 0;
    double time_binning_MGMR = 0;
    double magnetic_field_zenith = 0;
    double magnetic_field_azimuth = 0;
    double magnetic_field = 0;
    double pancake_thickness = 0;
    bool askaryan_effect_included = false;
    bool corsika_longfile_included = false;
    bool corsika_pancakefile_included = false;
    int event_id = 0;
    int gps_time_seconds = 0;
    double gps_time_nanoseconds = 0;

  };

}


#endif