RDetector.h

Go to the documentation of this file.

#ifndef _rdet_RDetector_h_
#define _rdet_RDetector_h_

#include <string>
#include <vector>
#include <map>
#include <set>

#include <boost/iterator/transform_iterator.hpp>

#include <rdet/Station.h>

#include <utl/TimeStamp.h>
#include <utl/Validated.h>
#include <utl/AugerException.h>


namespace det {
  class Detector;
}

namespace utl {
  class NonExistentComponentException;
  class TabulatedFunctionComplexLgAmpPhase;
}

namespace revt {
  class Station;
}

namespace rdet {

  class Station;


  class RDetector {

  private:
    typedef std::map<int, const rdet::Station*> InternalStationMap;
    typedef InternalStationMap::const_iterator InternalStationIterator;

    struct InternalStationFunctor {
      const rdet::Station& operator()(const InternalStationMap::value_type& pair) const
      { return *pair.second; }
    };

  public:
    typedef boost::transform_iterator<InternalStationFunctor,
                                      InternalStationIterator,
                                      const Station&> StationIterator;

    StationIterator StationsBegin() const
    { return StationIterator(fFullStationMap.begin()); }

    StationIterator StationsEnd() const
    { return StationIterator(fFullStationMap.end()); }

    OFFLINE_MAKE_CONST_ITERATOR_RANGE(StationIterator, Stations)

    
    const Station& GetStation(const int stationId) const;

    const Station& GetStation(const revt::Station& station) const;

    const std::vector<int>& GetFullStationList() const;

    const utl::TabulatedFunctionComplexLgAmpPhase& GetHardwareResponseProfile(const std::string& identifier) const;

    const std::vector<double>& GetBeaconFrequencies() const;

    double GetBeaconReferencePhase(const int stationId, const double beaconFreq) const;

    unsigned long long int GetBadStationReason(const int stationId) const;

    double GetTemperature(const std::string& site) const;

    // Returns fAddStationListFromSManager
    bool AddStationListFromSManager() const;

    // Helper method to do the redundant work of preparing requests for detector data,
    // sending it to the manager and reporting any errors.
    // The indexMap is not used here, but kept for the interface
    template<typename T>
    void
    GetDetectorData(T*& requestedData,
                    const std::string& property,
                    const std::string& component,
                    const std::string& errorMsg,
                    const det::VManager::IndexMap& indexMap = det::VManager::IndexMap())
      const
    {
      if (!requestedData) {
        requestedData = new T;

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

        if (foundFlag == det::VManager::eNotFound) {
          std::ostringstream err;
          err << "Did not find requested component: " << errorMsg;
          ERROR(err);
          throw utl::NonExistentComponentException(err.str());
        }
      }
    }
    
    int GetRdSdStationIdLink() const { return fRdSdStationIdLink; }

  private:
    RDetector() { }

    ~RDetector();

    RDetector(const RDetector& rdetector);

    RDetector& operator=(const RDetector& rdetector);

    void Update();

    const std::string fRDetectorName = "AERA";

    // List of all stations available in the external sources
    // (external sources are, for example, the XML file with
    // station list or perhaps some MySQL database)
    mutable utl::Validated<std::vector<int>> fFullStationList;

    // If true, station ids from the SManager are added to fFullStationList
    mutable utl::Validated<bool> fAddStationListFromSManager;
    
    mutable InternalStationMap fFullStationMap;

    typedef std::map<std::string, const utl::TabulatedFunctionComplexLgAmpPhase*> HardwareResponseProfileMap;
    mutable HardwareResponseProfileMap fHardwareResponseProfileMap;

    mutable std::vector<double>* fBeaconFreq = nullptr;
    mutable double* fBeaconReferencePhase = nullptr;

    friend class det::Detector;
    
    int fRdSdStationIdLink = 30000;
  };

}


#endif