RdBeamFormer/RdWaveModel.cc

Go to the documentation of this file.

#include "RdWaveModel.h"

#include <evt/Event.h>
#include <revt/REvent.h>
#include <revt/Header.h>
#include <revt/Station.h>
#include <revt/StationRecData.h>

#include <det/Detector.h>
#include <rdet/RDetector.h>

#include <utl/Trace.h>
#include <utl/TraceAlgorithm.h>
#include <utl/ErrorLogger.h>
#include <utl/Reader.h>
#include <utl/config.h>
#include <utl/AugerUnits.h>
#include <utl/PhysicalConstants.h>

#include <fwk/CoordinateSystemRegistry.h>

#include <cmath>

using namespace std;
using namespace revt;
using namespace utl;
using namespace fwk;

namespace RdBeamFormer {

  RdWaveModel::RdWaveModel() 
  {
  }

  RdWaveModel::~RdWaveModel()
  {
  }

  inline double norm (utl::Vector x) {
    return sqrt(x*x);
  }

  void RdWaveModel::setOrigin (utl::Point origin) {
    this->origin = origin;
  }

  void RdWaveModel::setSkyPos(utl::Point skyPos) {
    this->skyPos = skyPos;
  }
  
  double RdPlaneWaveModel::delay(const utl::Point antennaPos, const evt::ShowerRRecData& rrec) const {
    const utl::Vector rho = skyPos - origin;
    const utl::Vector x = antennaPos - origin;
    return -(rho * x) / norm (rho) / kSpeedOfLight;
  }

  double RdSphericalWaveModel::delay (const utl::Point antennaPos, const evt::ShowerRRecData& rrec) const {
    const utl::Vector rho = skyPos - origin;
    const utl::Vector diff = skyPos - antennaPos;
    return (norm(diff) - norm(rho)) / kSpeedOfLight;
  }
  
  double RdSphericalWaveModel::curvature(utl::Vector skyVec, const utl::CoordinateSystemPtr cs) const {
    return 1.0 / skyVec.GetR(cs);
  }
 
  //calculations for conical and hyperbolic wavefronts are based on formulas from:
  //The wavefront of the radio signal emitted by cosmic ray air showers
  //Apel, W.D. et al. - LOPES collaboration 2014, Journal of Cosmology and Astroparticle Physics,
  //JCAP09(2014)025 doi:10.1088/1475-7516/2014/09/025

  double RdConicalWaveModel::delay (const utl::Point antennaPos, const evt::ShowerRRecData& rrec) const {
    const utl::Vector rho = skyPos - origin;
    const utl::Vector x = antennaPos - origin;
    double xOrtogonal = norm(Cross(rho,x))/norm(rho);
    double xParallel = (rho*x)/norm(rho);
    const double Rho = rrec.GetParameter(eRho);
    return (xOrtogonal*sin(Rho) - xParallel*cos(Rho))/kSpeedOfLight;
  }

  double RdHyperbolicWaveModel::delay (const utl::Point antennaPos, const evt::ShowerRRecData& rrec) const {
    const utl::Vector rho = skyPos - origin;
    const utl::Vector x = antennaPos - origin;
    double xOrtogonal = norm(Cross(rho,x))/norm(rho);
    double xParallel = (rho*x)/norm(rho);
    const double Rho = rrec.GetParameter(eRho);
    const double b = rrec.GetParameter(eB);
    return sqrt((xOrtogonal*sin(Rho)/kSpeedOfLight)*(xOrtogonal*sin(Rho)/kSpeedOfLight) + b*b) - 
                  xParallel*cos(Rho)/kSpeedOfLight + b;
  }
}