RdStationSignalInterpolator.h

Go to the documentation of this file.

#ifndef _RdStationSignalInterpolator_RdStationSignalInterpolator_h_
#define _RdStationSignalInterpolator_RdStationSignalInterpolator_h_

#include <fwk/VModule.h>
#include <vector>
#include <complex>
#include <map>
#include <string>
#include <utl/CoordinateSystem.h>
#include <utl/ParameterStorage.h>
#include <utl/TimeStamp.h>
#include <utl/Point.h>
#include <utl/FFTDataContainer.h>
#include <evt/SimRadioPulse.h>
#include <evt/RadioSimulation.h>
#include <evt/ShowerRRecDataQuantities.h>
#include <revt/Station.h>
#include <revt/StationRecData.h>
#include <revt/Channel.h>
#include <rdet/RDetector.h>


namespace evt {
  class Event;
}

namespace RdStationSignalInterpolator {

  class StarShapeEntry {
  public:
    StarShapeEntry(const double distance, const double azimuth, const int statID)
      : fDistanceFromShowerAxis(distance), fObserverAzimuthAngle(azimuth), fStationID(statID) { }

    bool
    operator<(const StarShapeEntry& rhs)
      const
    {  // sort by azimuth, then by radius in the shower plane
      if (fabs(fObserverAzimuthAngle - rhs.fObserverAzimuthAngle) > 1e-3)
        return fObserverAzimuthAngle < rhs.fObserverAzimuthAngle;
      else
        return fDistanceFromShowerAxis < rhs.fDistanceFromShowerAxis;
    }

    double fDistanceFromShowerAxis = 0;
    double fObserverAzimuthAngle = 0;
    int fStationID = 0;
  };


  class RdStationSignalInterpolator : public fwk::VModule {
  public:
    RdStationSignalInterpolator() { }
    ~RdStationSignalInterpolator() override { }

    fwk::VModule::ResultFlag Init() override;
    fwk::VModule::ResultFlag Run(evt::Event& event) override;
    fwk::VModule::ResultFlag Finish() override;

  private:
    double PolarDistance(const double r1, const double phi1, const double r2, const double phi2);

    double
    LagrangianFactorCubic(const double X,
                          const double x1, const double x2, const double x3 ,const double x4,
                          const double v1, const double v2, const double v3, const double v4);

    std::vector<double>
    NearestNeighbourInterpolation(const double radius, const double azimuth,
                                  const std::set<double>& AzimuthListStarShape,
                                  const std::vector<StarShapeEntry>& StarShapeList,
                                  const std::vector<revt::StationRRecDataQuantities>& eNumNames,
                                  revt::REvent& rEvent, const bool errors);

    std::vector<double>
    BilinearInterpolation(const double radius, const double azimuth,
                          const std::set<double>& AzimuthListStarShape,
                          const std::vector<StarShapeEntry>& StarShapeList,
                          const std::vector<revt::StationRRecDataQuantities>& eNumNames,
                          revt::REvent& rEvent, const bool errors);

    std::vector<double>
    BicubicInterpolation(const double radius, const double azimuth,
                         const std::set<double>& AzimuthListStarShape,
                         const std::vector<StarShapeEntry>& StarShapeList,
                         const std::vector<revt::StationRRecDataQuantities>& eNumNames,
                         revt::REvent& rEvent, const bool errors);

    std::vector<int>
    FindIndexOfSurroundingNN(const double x_coord, const double y_coord,
                             const std::set<double>& AzimuthListStarShape,
                             const std::vector<StarShapeEntry>& StarShapeList);

    std::vector<StarShapeEntry>
    SortForInterpolation(const std::vector<StarShapeEntry>& StarShapeList);

    void MoveItemToBack(std::vector<StarShapeEntry>& v, const size_t itemIndex);

    double fMinimumEnergy = 0;
    bool fUseEarlyLate = false;
    bool fRequireSDStationTrigger = false;
    int fInterpolationMethod = 0;

    enum interpolationMethod {
      eNN = 0,
      eBilinear = 1,
      eBicubic = 2
    };

    REGISTER_MODULE("RdStationSignalInterpolator", RdStationSignalInterpolator);

  };

}


#endif