RDetector.cc

Go to the documentation of this file.

#include <iostream>
#include <string>
#include <limits>

#include <det/VManager.h>
#include <det/Detector.h>

#include <rdet/RDetector.h>
// #include <rdet/Station.h>

#include <revt/Station.h>

#include <utl/ErrorLogger.h>
#include <utl/TimeStamp.h>
#include <utl/UTCDateTime.h>
#include <utl/UTMPoint.h>

#include <TMath.h>


using namespace rdet;
using namespace std;
using namespace det;
using namespace utl;
using TMath::Na;


RDetector::~RDetector()
{
  for (const auto& is : fFullStationMap)
    delete is.second;
  for (const auto& nr : fHardwareResponseProfileMap)
    delete nr.second;
}


void
RDetector::Update()
{
  // This would be smart but does not work:
  //const TimeStamp dTime = Detector::GetInstance().GetTime();
  /*  
   if (! fFullStationList.IsValid()) {
     for (vector<int>::const_iterator it = GetFullStationList().begin();
     it != GetFullStationList().end() ; ++it) {
       const int id = *it;
       Station* const station = new Station(id);
       fFullStationMap[id] = station;
     }
   } else {
    fFullStationMap.begin()->second->Update();
   }
  */

  // This is not smart but does work!

  // fFullStationList contains station ids
  // fFullStationMap contains stations

  if (fFullStationList.IsValid()) {
    for (const auto& is : fFullStationMap)
      delete is.second;
    fFullStationList.SetValid(false);
  }
  
  fFullStationMap.clear();
  for (const auto id : GetFullStationList()) {
    fFullStationMap[id] = new Station(id);
  }
}
  

const vector<int>&
RDetector::GetFullStationList()
  const
{
  if (!fFullStationList.IsValid()) {
    fFullStationList.Get().clear();
    VManager::IndexMap indexMap;

    const VManager& manager = Detector::GetInstance().GetRManagerRegister();
    VManager::Status status =
      manager.GetData(fFullStationList.Get(), "fullStationList", "stationList", indexMap);

    // Release a Error only if no station ids are added from the SManagers.
    if (!AddStationListFromSManager()) {
      if (status == VManager::eNotFound) {
        ostringstream err;
        err << "Could not get a list of station ID's from RManagers. "
               "No AERA station information will be available!";
        ERROR(err);
      }
    }

    if (AddStationListFromSManager()) {
      std::vector<int> additionalRDStationIdsFromSManager;
      additionalRDStationIdsFromSManager.clear();

      const VManager& smanager = Detector::GetInstance().GetSManagerRegister();
      status = smanager.GetData(additionalRDStationIdsFromSManager, "fullStationList", "stationList", indexMap);

      if (status == VManager::eNotFound) {
        ostringstream err;
        err << "Could not get a list of station ID's from SManagers. "
               "No RD station information will be available!";
        ERROR(err);
      }

      if (!additionalRDStationIdsFromSManager.empty()) {
        for (const auto id : additionalRDStationIdsFromSManager)
          fFullStationList.Get().push_back(id + fRdSdStationIdLink);  // here linking SD to RD stations
      }
    }

    fFullStationList.SetValid();
  }

  return fFullStationList.Get();
}


const Station&
RDetector::GetStation(const revt::Station& station)
  const
{
  return GetStation(station.GetId());
}


const Station&
RDetector::GetStation(const int id)
  const
{
  const InternalStationIterator it = fFullStationMap.find(id);

  if (it != fFullStationMap.end() &&
      it->second->GetCommissionTimeRange() == Detector::GetInstance().GetTime())
    return *it->second;

  ostringstream err;
  err << "Station with Id = " << id << " is not available at "
         "detector time = " << Detector::GetInstance().GetTime()
      << " or detector description was not properly configured. "
      << "If station ID is larger than " << fRdSdStationIdLink << ", "
      << "check if RModelsXMLManager and RHardwareProfileXMLManager are "
      << "and configured.";
  ERROR(err);
  throw utl::NonExistentComponentException(err.str());
}


const TabulatedFunctionComplexLgAmpPhase&
RDetector::GetHardwareResponseProfile(const std::string& responseId)
  const
{
  const HardwareResponseProfileMap::const_iterator it =
    fHardwareResponseProfileMap.find(responseId);

  if (it != fHardwareResponseProfileMap.end())
    return *it->second;

  utl::TabulatedFunctionComplexLgAmpPhase* rResponse = 0;
  GetDetectorData(rResponse, "Response", responseId, "Response");
  fHardwareResponseProfileMap[responseId] = rResponse;

  return *rResponse;
}


const std::vector<double>& 
RDetector::GetBeaconFrequencies() 
  const
{
  if (fBeaconFreq) {
    delete fBeaconFreq;
    fBeaconFreq = nullptr;
  }
  GetDetectorData(fBeaconFreq, "BeaconFreq", "BeaconFreq", "BeaconFrequencies");
  return *fBeaconFreq;
}


double
RDetector::GetBeaconReferencePhase(const int stationId, const double beaconFreq)
  const
{
  if (fBeaconReferencePhase) {
    delete fBeaconReferencePhase;
    fBeaconReferencePhase = nullptr;
  }
  VManager::IndexMap indexMap;
  indexMap["RStationId"] = boost::lexical_cast<string>(stationId);
  //boost::lexical_cast<string>(double) returns full double presentation of value, i.e. not rounded
  //e.g. 0.061523000000000001 instead of 0.061523
  //lexical_cast is supposed to be faster than the explicit stringstream
  //string to_string(double) is only C++11
  indexMap["BeaconFreq"] = boost::lexical_cast<string>(beaconFreq);
  GetDetectorData(fBeaconReferencePhase, "BeaconRefPhase", "BeaconRefPhase", "BeaconFrequenciesReferencePhases", indexMap);
  return *fBeaconReferencePhase;
}


unsigned long long int
RDetector::GetBadStationReason(const int stationId)
  const
{
  unsigned long long int res = 0;
  const det::ManagerRegister& m = det::Detector::GetInstance().GetRManagerRegister();
  m.GetDataOrThrow(res, "BadStation", boost::lexical_cast<string>(stationId));
  return res << 15;

  /*union I2LL {
    int fI[2];
    unsigned long long int fLL;
  };
  static vector<int>* iiReason;
  if (iiReason) {
    delete iiReason;
    iiReason = nullptr;
  }
  GetDetectorData(iiReason, "BadStation", boost::lexical_cast<string>(stationId) , "");
  I2LL reason;
  for (unsigned int i = 0; i < 2; ++i)
    reason.fI[i] = iiReason->at(i);
  return reason.fLL << 32;*/
  /*static unsigned long long int* reason;
  if (reason) {
    delete reason;
    reason = nullptr;
  }
  GetDetectorData(reason, "BadStation", boost::lexical_cast<string>(stationId) , "");
  return *reason << 32;  // in Offline the reasons from the database start at bit 32*/
}


double
RDetector::GetTemperature(const std::string& site)
  const
{
  static double* temperature;
  if (temperature) {
    delete temperature;
    temperature = nullptr;
  }
  const VManager::IndexMap indexMap({{ "site", site }});
  GetDetectorData(temperature, "monitoring", "temperature", "", indexMap);
  return *temperature + 273.15; // conversion to Kelvin as temperature is stored in degree celsius in DB
}


bool 
RDetector::AddStationListFromSManager()
  const
{
  if (!fAddStationListFromSManager.IsValid()) {
    const det::ManagerRegister& managerRRegister = det::Detector::GetInstance().GetRManagerRegister();
    
    // if no radio manager is registered return 0 anyway.
    if (managerRRegister.ManagersBegin() == managerRRegister.ManagersEnd()) {
      fAddStationListFromSManager = false;
    }
    else {
      int addStations;
      det::VManager::IndexMap indexMap;

      const det::VManager::Status foundFlag =
        managerRRegister.GetData(addStations, "addSStationList", "", indexMap);

      if (foundFlag == det::VManager::eNotFound) {
        ERROR("Did not find requested component: addSStationList (Flag to add station Ids from SManager to RDetector.)");
        throw utl::NonExistentComponentException("Did not find requested component:"
          "addSStationList (Flag to add station Ids from SManager to RDetector.)");
      }
      if (addStations == 1)
        fAddStationListFromSManager = true;
      else
        fAddStationListFromSManager = false;
    }

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