RadioGeometryUtilities.h

Go to the documentation of this file.

#ifndef _utl_radio_RadioGeometryUtilities_h_
#define _utl_radio_RadioGeometryUtilities_h_

#include <utl/Math.h>
#include <utl/Vector.h>
#include <utl/Point.h>
#include <utl/Trace.h>
#include <utl/CoordinateSystemPtr.h>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/io.hpp>
#include <TVector3.h>


namespace utl {

  class RadioGeometryUtilities {

  public:
    RadioGeometryUtilities(const utl::Vector& showeraxis,
                           const utl::CoordinateSystemPtr cs,
                           const utl::Vector& magneticField);

    static utl::Vector GetChargeExcessVector(const utl::Point& core, const utl::Vector& showeraxis,
                                             const utl::Point& stationPosition);

    static double GetSignalCorrectionFactor(const utl::Point& core, const utl::Vector& showeraxis,
                                            const utl::Point& stationPosition, const utl::Vector& vMagField,
                                            const double chargeExcessStrength);

    static utl::Vector GetLorentzVector(const utl::Vector& showeraxis, const utl::Vector& vMagField);

    // returns angle to Lorentz force vector
    static double GetAngleToLorentzVector(const utl::Vector& measuredEField,
                                          const utl::Vector& showeraxis, const utl::Vector& vMagField);

    static double GetDistanceToAxis(const utl::Vector& ShowerAxis, const utl::Point& CorePosition,
                                    const utl::Point& AntennaPosition);

    static double GetEarlyLateCorrectionFactor(const utl::Point& showerCore,
                                               const utl::Point& stationPosition,
                                               const utl::Point& showerMax,
                                               const utl::Vector& showerAxis);

    static double GetEarlyLateCorrectionFactor(const double distanceXmax, const double Z_vxB)
    { return 1 + Z_vxB / distanceXmax; }

    // correction factor of the energy fluence for the early-late-effect (don't forget to correct the distance too)
    static double GetEnergyFluenceCorrectionEarlyLateEffect(const utl::Point& showerCore,
                                                            const utl::Point& stationPosition,
                                                            const utl::Point& showerMax,
                                                            const utl::Vector& showerAxis)
    { return utl::Sqr(GetEarlyLateCorrectionFactor(showerCore, stationPosition, showerMax, showerAxis)); }

    static double GetEnergyFluenceCorrectionEarlyLateEffect(const double distanceXmax, const double Z_vxB)
    { return utl::Sqr(GetEarlyLateCorrectionFactor(distanceXmax, Z_vxB)); }

    // correction factor of the distance for the early-late-effect (don't forget to correct the energy fluence too)
    static double GetDistanceCorrectionEarlyLateEffect(const utl::Point& showerCore,
                                                       const utl::Point& stationPosition,
                                                       const utl::Point& showerMax,
                                                       const utl::Vector& showerAxis)
    { return 1. / GetEarlyLateCorrectionFactor(showerCore, stationPosition, showerMax, showerAxis); }

    static double GetDistanceCorrectionEarlyLateEffect(const double distanceXmax, const double Z_vxB)
    { return 1. / GetEarlyLateCorrectionFactor(distanceXmax, Z_vxB); }

    static utl::Vector GetExpectedEFieldVector(const utl::Point& core, const utl::Vector& showeraxis,
                                               const utl::Point& stationPosition, const utl::Vector& vMagField,
                                               const double chargeExcessStrength);

    static double GetAngleToEFieldExpectation(const utl::Vector& measuredEField, const utl::Point& core,
                                              const utl::Vector& showeraxis, const utl::Point& stationPosition,
                                              const utl::Vector& vMagField, const double chargeExcessStrength);

    static double GetAngleToEFieldExpectation2D(const utl::Vector& measuredEField, const utl::Point& core,
                                                const utl::Vector& showeraxis, const utl::Point& stationPosition,
                                                const utl::Vector& vMagField, const double chargeExcessStrength,
                                                const utl::CoordinateSystemPtr localCS);

    static const Point GetCoreAtObservationLevel(const Point& core,
                                                 const Vector& showerAxis,
                                                 const CoordinateSystemPtr cs,
                                                 const double altitudeObsLvl);

    void GetVectorInShowerPlaneVxB(double& x, double& y, double& z, const utl::Point& point) const;
    void GetVectorInShowerPlaneVxB(double& x, double& y, double& z, const TVector3& vector) const;

    utl::TraceV3D GetTraceInShowerPlaneVxB(const utl::TraceV3D& trace) const;
    utl::TraceV3D GetTraceFromShowerPlaneVxB(const utl::TraceV3D& trace) const;

    utl::Point GetVectorFromShowerPlaneVxB(const double x, const double y, const double z, const bool verticalZero) const;

    utl::Point GetVectorFromShowerPlaneVxB(const double x, const double y) const;

    utl::Point GetVectorFromShowerPlaneVxB(const double x, const double y, const double z) const
    { return GetVectorFromShowerPlaneVxB(x, y, z, false); }

    double GetHeightInShowerPlane(const double x, const double y) const;

  private:
    const utl::CoordinateSystemPtr fcs;
    const utl::Vector fMagneticField;
    boost::numeric::ublas::matrix<double> fTransformationMatrix;
    boost::numeric::ublas::matrix<double> fInverseTransformationMatrix;

  };

}


#endif