RDetector/Channel.h

Go to the documentation of this file.

#ifndef _rdet_Channel_h_
#define _rdet_Channel_h_

#include <rdet/AntennaType.h>
#include <utl/TabulatedFunctionComplexLgAmpPhase.h>
#include <utl/Point.h>
#include <utl/AugerException.h>
#include <utl/ResponseMap.h>
#include <utl/Validated.h>
#include <rdet/RDetector.h>
#include <det/VManager.h>
#include <string>


namespace rdet {
  class Channel {

  public:
    int GetId() const { return fChannelId; }

    int GetOkFlag() const;

    //RChannel part of RModelConfig

    double GetDesignLowerFreq() const;

    double GetDesignUpperFreq() const;

    double GetOrientationZenith() const;

    double GetOrientationAzimuth() const;

    double GetOrientationZeta() const;

    const utl::Point& GetPosition() const;

    const std::string& GetChannelType() const;

    /*
    const utl::TabulatedFunctionComplexLgAmpPhase& GetGlobalResponse() const
    { return *fGlobalResponse; }
    */

    const std::string& GetAntennaTypeName() const;

    //RADC part of RModelConfig

    const std::string& GetADCType() const;

    int GetBitDepth() const;

    double GetSamplingFrequency() const;

    double GetMinVoltage() const;

    double GetMaxVoltage() const;

    double GetDesignImpedance() const;

    double GetIntegratedHorizontalGain() const;

    double GetIntegratedVerticalGain() const;

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

    double GetIntegratedEffectiveAntennaHeight(const double freq) const;

    const utl::ResponseMap& GetResponseMap() const;

    const utl::TabulatedFunction& GetCalibrationFunction() const;

  private:

    Channel(const int stationId, const int ChannelId);
    ~Channel();                           // don't forget to delete all the pointer member objects in the destructor!

    Channel(const Channel&);              // copy constructor is private so that no copy of a channel can be made (would need deep-copying)
    Channel& operator=(const Channel&);   // assignment operator is private so that no copy of a channel can be made (would need deep-copying)

    void Update() const;

    std::string fStationIdString;
    std::string fChannelIdString;

    int fChannelId;

    // general Channel characteristics:
    mutable utl::Validated<int> fChannelOk;                // Channel OK flag
    mutable utl::Validated<double> fDesignLowerFreq;       // design value of the freq-band
    mutable utl::Validated<double> fDesignUpperFreq;       // design value of the freq-band
    mutable utl::Validated<double> fOrientationZenith;     // zenith-direction of Antenna for this Channel
    mutable utl::Validated<double> fOrientationAzimuth;    // azimuth-direction of Antenna for this Channel
    mutable utl::Validated<double> fOrientationZeta;       // zeta-tilt of Antenna for this Channel
    mutable utl::Validated<utl::Point> fPosition;          // Position of channel Ref.Point. wrt. Station Ref.Point
    mutable utl::Validated<std::string> fChannelType;      // Type of Channel

    // coming from the ADC:
    mutable utl::Validated<std::string> fADCType;          // description of ADC-Type
    mutable utl::Validated<int> fBitDepth;                     // number of bits of ADC
    mutable utl::Validated<double> fSamplingFrequency;     // sampling Frequency of ADC
    mutable utl::Validated<double> fMinVoltage;
    mutable utl::Validated<double> fMaxVoltage;

    // coming from the Antenna_type:
    mutable utl::Validated<std::string> fAntennaTypeName;      // description of Antenna-Type

    mutable utl::Validated<double> fDesignImpedance;
    mutable utl::Validated<double> fIntegratedHorizontalGain;
    mutable utl::Validated<double> fIntegratedVerticalGain;

    mutable utl::Validated<utl::ResponseMap> fResponseMap; // table detailing the detector responses and their weights

    // mutable utl::TabulatedFunctionComplexLgAmpPhase* fGlobalResponse; // complex global response, tabulated in freq.

    // reference_phase map  postponed or put into calibration

    // this is the antenna belonging to this channel
    AntennaType* fAntenna;

    friend class Station;

    // Helper method to do the redundant work of preparing requests for Channel data,
    // sending it to the manager and reporting any errors.

    template<typename T>
    const T&
    GetChannelData(utl::Validated<T>& requestedData,
                   const std::string& property,
                   const std::string& component,
                   const std::string& errorMsg)
      const
    {
      if (!requestedData.IsValid()) {
        det::VManager::IndexMap indexMap;
        indexMap["station"] = fStationIdString;
        indexMap["channel"] = fChannelIdString;

        const det::VManager& manager =
          ::det::Detector::GetInstance().GetRManagerRegister();
        const det::VManager::Status foundFlag =
          manager.GetData(requestedData.Get(), property, component, indexMap);

        if (foundFlag == det::VManager::eNotFound)
          NotFoundAndExit(errorMsg);

        requestedData.SetValid();
      }
      return requestedData.Get();
    }

    void NotFoundAndExit(const std::string& msg) const;

  };

}


#endif //_rdet_Channel_h_