AntennaType.h

Go to the documentation of this file.

#ifndef _rdet_AntennaType_h_
#define _rdet_AntennaType_h_

#include <utl/Validated.h>
#include <det/Detector.h>

#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp>  // operator<() needed for keys in maps
#include <vector>
#include <map>
#include <string>
#include <complex>


namespace rdet {

  class RDetector;


  typedef boost::tuple<int, int, int> ResponseKey;


  struct VectorEffectiveLength {
    std::complex<float> Theta;
    std::complex<float> Phi;
  };


  struct AntennaPattern {
    int nPhi = 0;
    int nTheta = 0;
    int nFrequency = 0;
    double phi_lower_bound = 0;
    double phi_upper_bound = 0;
    double theta_lower_bound = 0;
    double theta_upper_bound = 0;
    double frequency_lower_bound = 0;
    double frequency_upper_bound = 0;
    std::vector<double> frequencies;
    std::vector<double> thetaAngles;
    std::vector<double> phiAngles;
    std::vector<double> meanTransfer;
    std::map<ResponseKey, VectorEffectiveLength> AntennaResponse;
  };


  class AntennaType {

  private:
    AntennaType& operator=(const AntennaType&);  // forbid assignment
    AntennaType(const AntennaType&);  // forbid copying
    AntennaType(const std::string& fAntennaType_);
    AntennaType() { }
    ~AntennaType() { }

    friend class RDetector;  //we will have to decide if the AntennaType object will be held at the instance of the RDetector
    friend class Channel;    //or at the level of the channels
    friend class utl::Validated<AntennaType>;

    mutable std::string fAntennaType;

    std::pair<std::complex<double>, std::complex<double>>
    GetElectricFieldResponse(const double theta, const double phi, const double freq, const std::string& interpolationMode);

    double GetIntegratedEffectiveAntennaHeight(const double freq);

    double CalculateIntegratedEffectiveAntennaHeight(const std::map<ResponseKey, VectorEffectiveLength>& antennaResponse,
                                                     const int iFreq, const int nTheta, const int nPhi);

    // new antenna pattern interpolation
    static std::map<std::string, AntennaPattern> fgAntennaPattern;  //  global variable that holds the antenna pattern

    void BufferAntennaPattern();

    std::pair<std::complex<double>, std::complex<double>>
    GetElectricFieldResponse_lookup(const double fTheta, const double fPhi, const double fFreq);

    std::pair<std::complex<double>, std::complex<double>>
    GetElectricFieldResponse_LinearInterpolation(const double fTheta, const double fPhi, const double fFreq);

    double InterpolateLinear(const double x, const double x_low, const double x_up, const double y_low, const double y_up);

    std::complex<float>
    InterpolateLinear(const float x, const float x_low, const float x_up,
                      const std::complex<float>& y_low, const std::complex<float>& y_up);

    VectorEffectiveLength
    InterpolateLinear(const double x, const double x_low, const double x_up,
                      const VectorEffectiveLength& VEL_low, const VectorEffectiveLength& VEL_up);

    std::pair<std::complex<double>, std::complex<double>>
    GetComplexRepresentationOfVectorEffectiveLength(const VectorEffectiveLength& vel);

    // Helper method to do the redundant work of preparing requests for AntennaType data,
    // sending it to the manager and reporting any errors.
    template<typename T>
    const T&
    GetAntennaData(utl::Validated<T>& requestedData, const std::string& antennaProp,
                   const std::string& propIndex = "")
      const
    {
      if (!requestedData.IsValid()) {
        det::VManager::IndexMap propIndexMap;
        // this is not general, but fit the needs of the AntennaType class up to now:
        if (!propIndex.empty())
          propIndexMap["idfreq"] = propIndex;

        // Fetch the data:
        const det::VManager& manager = det::Detector::GetInstance().GetRManagerRegister();
        const det::VManager::Status foundFlag =
          manager.GetData(requestedData.Get(), antennaProp, fAntennaType, propIndexMap);
        // just result flag
        if (foundFlag == det::VManager::eNotFound)
          NotFoundAndExit(antennaProp + " " + propIndex);
        requestedData.SetValid();
      }
      return requestedData.Get();
    }

    // Called by GetAntennaData:
    void NotFoundAndExit(const std::string& msg) const;

  };

}


#endif