ArtificialShowerFile.cc

Go to the documentation of this file.

#include "ArtificialShowerFile.h"

#include <evt/Event.h>
#include <evt/ShowerSimData.h>
#include <evt/GaisserHillas4Parameter.h>
#include <evt/DefaultShowerGeometryProducer.h>

#include <utl/AugerException.h>
#include <utl/ErrorLogger.h>

#include <io/IoCodes.h>

#include <fwk/CentralConfig.h>
#include <utl/config.h>

#include <utl/Reader.h>

#include <string>
#include <fstream>
#include <iostream>

using namespace evt;
using namespace io;
using namespace utl;
using namespace fwk;

using namespace std;


namespace io {

  ArtificialShowerFile::ArtificialShowerFile(const std::string& fileName, const Mode mode, utl::Branch* const b)
  {
    Open(fileName, mode, b);
  }


  void
  ArtificialShowerFile::Open(const std::string& /*fileName*/, const Mode mode, utl::Branch* const /*b*/)
  {
    if (fIsOpen) {
      const string msg = "Artificial IO Exception: ArtificiaFileShower has already been opened.\n";
      throw utl::IOFailureException(msg);
    }
    if (mode == eWrite) {
      const string msg = "Artificial IO Exception: Cannot write to Artificial files.\n";
      throw utl::IOFailureException(msg);
    }

    fIsOpen = true;
  }


  void
  ArtificialShowerFile::ReadXMLParameters()
  {
    Branch topB = CentralConfig::GetInstance()->GetTopBranch("ArtificialShowerFile");
    if (topB) {
      Branch primaryEnergyB = topB.GetChild("PrimaryEnergy");
      if (primaryEnergyB)
        primaryEnergyB.GetData(fPrimaryEnergy);
      Branch zenithB = topB.GetChild("PrimaryZenith");
      if (zenithB)
        zenithB.GetData(fZenith);
      Branch azimuthB = topB.GetChild("PrimaryAzimuth");
      if (azimuthB)
        azimuthB.GetData(fAzimuth);
    }
  }


  Status
  ArtificialShowerFile::Read(evt::Event& event)
  {
    if (fReadEvents > 0)
      return io::eEOF;

    ReadXMLParameters();

    if (event.HasSimShower()) {
      ERROR("Event not cleared - has SimShower. Cannot read ArtificialShowerFile.");
      return eFail;
    }
    event.MakeSimShower(DefaultShowerGeometryProducer());
    evt::ShowerSimData& shower = event.GetSimShower();

    shower.SetPrimaryParticle(utl::Particle::eProton);
    shower.SetEnergy(fPrimaryEnergy);
    shower.SetGroundParticleCoordinateSystemZenith(fZenith);
    shower.SetGroundParticleCoordinateSystemAzimuth(fAzimuth);
    shower.SetShowerNumber(1);
    shower.SetShowerRunId("1");

    if (!shower.HasGroundParticles())
      shower.MakeGroundParticles();

    if (CreateArtificialShowerFileParticleIterator() != eSuccess)
      return eFail;

    shower.GetGroundParticles().SetFileInterface(&fArtificialShowerFileParticleIterator);

    ++fReadEvents;

    return eSuccess;
  }


  void
  ArtificialShowerFile::Write(const evt::Event& /*event*/)
  {
    const string msg = "Artificial IO Exception: Cannot write to Artificial files.";
    throw utl::IOFailureException(msg);
  }


  Status
  ArtificialShowerFile::FindEvent(const unsigned int eventId)
  {
    return eventId == 1 ? eSuccess : eFail;
  }


  Status
  ArtificialShowerFile::GotoPosition(const unsigned int /*position*/) // unused
  {
    return eSuccess;
  }


  int
  ArtificialShowerFile::GetNEvents()
  {
    if (fIsOpen)
      return 1;
    else {
      const string msg = "Artificial IO Exception: ArtificiaFileShower is already closed.";
      throw utl::IOFailureException(msg);
    }
  }


  Status
  ArtificialShowerFile::CreateArtificialShowerFileParticleIterator()
  {
    fArtificialShowerFileParticleIterator = ArtificialShowerFileParticleIterator();
    fArtificialShowerFileParticleIterator.SetShowerZenith(fZenith);
    fArtificialShowerFileParticleIterator.SetShowerAzimuth(fAzimuth);
    return eSuccess;
  }

}