ShowerSimData.cc

Go to the documentation of this file.

#include <evt/ShowerSimData.h>
#include <evt/LaserData.h>
#include <evt/RadioSimulation.h>
#include <fwk/LocalCoordinateSystem.h>
#include <utl/ParticlePropertiesFactory.h>
#include <utl/ErrorLogger.h>

#include <utl/LameShadowPtr_imp.h>
LAMESHADOWPTR_INST(evt::ShowerSimData);

using namespace utl;
using namespace evt;
using namespace std;


namespace evt {

  void
  ShowerSimData::SetGroundParticleCoordinateSystemZenith(const double zenith)
  {
    if (HasGeometry()) {
      ERROR("ShowerSimData Geometry already exists - Not replacing zenith");
      throw AugerException("ShowerSimData Geometry already exists - Not replacing zenith.");
    }
    fGroundParticleCoordinateSystemZenith = zenith;
  }


  void
  ShowerSimData::SetGroundParticleCoordinateSystemAzimuth(const double azimuth)
  {
    if (HasGeometry()) {
      ERROR("ShowerSimData Geometry already exists - Not replacing azimuth");
      throw AugerException("ShowerSimData Geometry already exists - Not replacing azimuth.");
    } 
    fGroundParticleCoordinateSystemAzimuth = azimuth;
  }


  const utl::Point&
  ShowerSimData::GetPosition()
    const
  {
    if (!fCachedPosition) {
      fCachedPosition = new utl::Point(0, 0, 0, GetGroundParticleCoordinateSystem());
    }
    return *fCachedPosition;
  }


  const utl::Vector&
  ShowerSimData::GetDirection()
    const
  {
    if (!fCachedDirection)
      fCachedDirection = new utl::Vector(0, 0, -1, GetShowerCoordinateSystem());
    return *fCachedDirection;
  }


  void
  ShowerSimData::MakeGeometry(const utl::Point& anyPointOnShowerAxis)
  {
    if (HasGeometry()) {
      ERROR("ShowerSimData Geometry already exists - Not replacing");
      throw AugerException("ShowerSimData Geometry already exists - Not replacing.");
    }
    
    if (!fShowerGeometryProducer) {
      ERROR("ShowerGeometryProducer does not exists. You need to define one in the EventIO");
      throw AugerException("ShowerGeometryProducer does not exists. You need to define one in the EventIO");
    }
    
    fParticleCS = fShowerGeometryProducer->MakeGroundParticleCoordinateSystem(anyPointOnShowerAxis);
    
    fShowerCS =
      CoordinateSystem::RotationY(
        fGroundParticleCoordinateSystemZenith,
        CoordinateSystem::RotationZ(fGroundParticleCoordinateSystemAzimuth, fParticleCS)
      );

    fLocalCS = fwk::LocalCoordinateSystem::Create(GetPosition());
  }


  void
  ShowerSimData::CheckGeometry()
    const
  {
    if (!HasGeometry())
      throw utl::AugerException("Geometry not defined!");
  }


  void
  ShowerSimData::MakeGroundParticles()
  {
    if (fGroundParticles)
      ERROR("ShowerSimData already has GroundParticles - not replacing");
    else
      fGroundParticles = new utl::ShowerParticleList;
  }


  void
  ShowerSimData::MakeGroundCherenkov(const utl::AttributeMap& am)
  {
    if (fGroundCherenkov.count(am) && fGroundCherenkov[am])
      ERROR("ShowerSimData already has GroundCherenkov - not replacing");
    else
      fGroundCherenkov[am] = new utl::ShowerParticleList;
  }


  void
  ShowerSimData::SetPrimaryParticle(const int type)
  {
    fPrimaryProperties = utl::ParticlePropertiesFactory::Create(type);
  }


  void
  ShowerSimData::MakeGHParameters(const VGaisserHillasParameter& gHParameters)
  {
    if (fGHParameters)
      ERROR("Sim Shower GHParameters already exists - Not replacing");
    else
      fGHParameters = gHParameters.Clone();
  }


  void
  ShowerSimData::MakeAtmosphereParameters(const AtmosphereParameters& param)
  {
    if (fAtmosphereParameters)
      ERROR("Sim Shower AtmosphereParameters already exists - Not replacing");
    else
      fAtmosphereParameters = new AtmosphereParameters(param);
  }


  void
  ShowerSimData::MakeTimeStamp(const TimeStamp& ts)
  {
    if (fTimeStamp)
      ERROR("Sim Shower TimeStamp already exists - Not replacing");
    else
      fTimeStamp = new TimeStamp(ts);
  }


  double
  ShowerSimData::GetEnergyCutoff(const ProfileType type)
    const
  {
    switch (type) {
    case eMuon:
      return fEnergyCutoffMuon; 
    case eElectron:
      return fEnergyCutoff;
    default:
      return -1;
    }
  }


  void
  ShowerSimData::SetEnergyCutoff(const double energy, 
                                 const ProfileType type)
  {
    switch (type) {
    case eMuon:
      fEnergyCutoffMuon = energy;
      break;
    case eElectron:
      fEnergyCutoff = energy;
      break;
    default:
      break;
    }
  }


  void
  ShowerSimData::MakeLaserData()
  {
    if (!fLaserData)
      fLaserData = new LaserData();
    else
      ERROR("LaserData already exists - Not replacing");
  }


  void
  ShowerSimData::MakeRadioSimulation()
  {
    if (!fRadioSimulation)
      fRadioSimulation = new RadioSimulation();
    else
      ERROR("RadioSimulation already exists - Not replacing");
  }


  void
  ShowerSimData::AddSimCore(const utl::Point& pos) 
  {
    fSimCores.push_back(pos);
  }

}