RDetector/Station.cc

Go to the documentation of this file.

#include <sstream>
#include <boost/lexical_cast.hpp>

#include <det/Detector.h>

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

#include <revt/Channel.h>

#include <fwk/LocalCoordinateSystem.h>

#include <utl/ErrorLogger.h>
#include <utl/Point.h>
#include <utl/UTMPoint.h>
#include <utl/TimeStamp.h>
#include <utl/UTCDateTime.h>
#include <utl/TimeInterval.h>
#include <utl/Reader.h>
#include <utl/AugerUnits.h>
#include <utl/CoordinateSystem.h>
#include <utl/AugerCoordinateSystem.h>
#include <utl/ReferenceEllipsoid.h>

using namespace det;
using namespace rdet;
using namespace std;
using namespace utl;


Station::Station(const int id) :
  fId(id),
  fStationIdString(boost::lexical_cast<string>(id))
{
  SetListOfChannelIds();
  for (unsigned int i = 0; i < fListOfChannelIds.size(); ++i) {
    Channel* const channel = new Channel(id, fListOfChannelIds[i]);
    fChannelVector.push_back(channel);
        }
}


Station::~Station()
{
  for (InternalChannelIterator it = fChannelVector.begin();
       it != fChannelVector.end(); ++it)
    delete *it;
}


const Channel&
Station::GetChannel(const int id)
  const 
{
  if (fChannelIdToInternalChannelId.find(id) != fChannelIdToInternalChannelId.end()) {
    return *fChannelVector[fChannelIdToInternalChannelId.at(id)];
  } else {
    ostringstream err;
    err << "Invalid Channel Id requested : " << id
        << ", available channel Id's are";
    for(unsigned int i = 0; i < fListOfChannelIds.size(); ++i) {
      err << fListOfChannelIds[i] << " ";
    }
    ERROR(err);
    throw NonExistentComponentException(err.str());
  }
}


const Channel&
Station::GetChannel(const revt::Channel& channel)
  const
{
  return GetChannel(channel.GetId());
}


string
Station::GetName()
  const
{ 
  if (!fName.IsValid()) {
    GetStationData(fName.Get(), "name", "stationList", "station name");
    fName.SetValid();
   }
  return fName.Get();
}

bool
Station::IsVirtual() 
  const
{
  int isvirtual;
  GetStationData(isvirtual, "virtual", "stationList", "station is virtual");
  return isvirtual;
}


bool
Station::IsInAcquisition()
  const
{
  int IsInAcquisition;
  GetStationData(IsInAcquisition, "station_in_acquisition", "is_in_acquisition", "station in acquisition flag");
  return IsInAcquisition;
}


const TimeRange&
Station::GetCommissionTimeRange()
  const
{
  if (!fCommissionTimeRange.IsValid()) {
    string timeString;
    GetStationData(timeString, "commission", "stationList", "commission time");
    const TimeStamp start = boost::lexical_cast<UTCDateTime>(timeString).GetTimeStamp();
    GetStationData(timeString, "decommission", "stationList", "commission time");
    const TimeStamp stop = boost::lexical_cast<UTCDateTime>(timeString).GetTimeStamp();
    fCommissionTimeRange = TimeRange(start, stop);
  }
  return fCommissionTimeRange.Get();
}


Point
Station::GetPosition()
  const
{
  if (!fPosition.IsValid()) {
        
    double northing, easting, altitude;
    GetStationData(northing, "northing", "stationList", "northing");
    GetStationData(easting, "easting", "stationList", "easting");
    GetStationData(altitude, "altitude", "stationList", "altitude"); 
          
    string ellipsoid;
    GetStationData(ellipsoid, "ellipsoid", "stationList", "ellipsoid for UTM conversion");
    fEllipsoid = ReferenceEllipsoid::GetEllipsoidIDFromString(ellipsoid);
    
    string band;
    GetStationData(band, "band", "stationList", "band for UTM conversion");
    
    int zone;
    GetStationData(zone, "zone", "stationList", "zone for UTM conversion");

    const CoordinateSystemPtr cs = Detector::GetInstance().GetSiteCoordinateSystem();
    const UTMPoint utmposition(northing, easting, altitude, zone, band[0], fEllipsoid);

    fPosition = utmposition.GetPoint(cs);

  } 
  return fPosition.Get();
}


bool
Station::IsInGrid(const int)
  const
{

  if (!fInGrid.IsValid()) {
    if (fId > det::Detector::GetInstance().GetRDetector().GetRdSdStationIdLink())  // temporary solution until SStationList is expanded
      fInGrid.Get() = 1;
    else
      GetStationData(fInGrid.Get(), "inGrid", "stationList", "get is-in-grid");
    fInGrid.SetValid();
  }
  return fInGrid.Get();
}


void
Station::NotFoundAndThrow(const string& msg)
  const
{
  ostringstream err;
  err << "Did not find requested component: '" << msg
      << "' for station = " << fStationIdString;
  ERROR(err);
  throw NonExistentComponentException(err.str());
}


utl::CoordinateSystemPtr
Station::GetLocalCoordinateSystem()
  const
{
  if (!fReferenceSystem)
    fReferenceSystem =
      fwk::LocalCoordinateSystem::Create(GetPosition());

  return fReferenceSystem;
} 


void
Station::Update()
  const
{
  /*
   * In this method we clean all the variables that might change with time and deleted whatever was allocated in the get*'s

  fName.SetValid(false);
  fInGrid.SetValid(false);
  fPosition.SetValid(false);
  fCommissionTimeRange.SetValid(false);

  delete fWaterAbsLength;
  fWaterAbsLength = 0;

  delete fWaterRefractionIndex;
  fWaterRefractionIndex = 0;

  delete fLinerReflectivity;
  fLinerReflectivity = 0;

  delete fLinerSpecularLobe;
  fLinerSpecularLobe = 0;

  delete fLinerSpecularSpike;
  fLinerSpecularSpike = 0;

  delete fLinerSigmaAlpha;
  fLinerSigmaAlpha = 0;
  */

  fIsInAcquisition.SetValid(false);
  fIsInAcquisition = 0;

  /*
  delete fLiveTime;
  fLiveTime = 0;
  */

  for(InternalChannelIterator channelIt = fChannelVector.begin();
      channelIt != fChannelVector.end(); ++channelIt)
    (*channelIt)->Update();
}


void Station::SetListOfChannelIds(){
  det::VManager::IndexMap indexMap;
  indexMap["station"] = fStationIdString;
  indexMap["stationId"] = fStationIdString;
  std::vector<int> requestedData;

  if (fId > det::Detector::GetInstance().GetRDetector().GetRdSdStationIdLink()) {  // temporary solution until SStationList is expanded
    std::vector<int> defaultChannelIds{0, 1};
    requestedData = defaultChannelIds;
  }
  else {
    const det::VManager& manager = det::Detector::GetInstance().GetRManagerRegister();
    const det::VManager::Status status = manager.GetData(requestedData, "listOfChannelIds", "RChannel", indexMap);

    if (status == det::VManager::eNotFound)
      NotFoundAndThrow("List of channels Ids not found.");
  }

  fListOfChannelIds = requestedData;
  
  for(unsigned int i = 0; i< fListOfChannelIds.size(); ++i) {
    fChannelIdToInternalChannelId.insert(std::pair<int, int> (fListOfChannelIds[i], i));
  }
   
}


template <typename T>
det::VManager::Status
Station::GetStationData(T& requestedData, 
   const std::string& property, 
   const std::string& component, 
   const std::string& errorMsg,
   const bool throwOnFailure)
  const
{      
  det::VManager::Status status;
  det::VManager::IndexMap indexMap;

  // If station Id is equal or below RDetector::fRdSdStationIdLink ask radio manager (AERA stations),
  // if station Id is above ask SD manager (RD stations)
  int rdsdLink = det::Detector::GetInstance().GetRDetector().GetRdSdStationIdLink();
  if (fId <= rdsdLink) {
    indexMap["stationId"] = fStationIdString;   
    const det::VManager& manager = det::Detector::GetInstance().GetRManagerRegister();
    status = manager.GetData(requestedData, property, component, indexMap);
  }
  else {
    indexMap["stationId"] = boost::lexical_cast<std::string>(fId - rdsdLink);
    const det::VManager& manager = det::Detector::GetInstance().GetSManagerRegister();
    status = manager.GetData(requestedData, property, component, indexMap);
  }

  if (throwOnFailure && status == det::VManager::eNotFound)
    NotFoundAndThrow(errorMsg);
  
  return status;
}