RBeaconSQLManager.cc

Go to the documentation of this file.

#include <iomanip>
#include <boost/lambda/lambda.hpp>

#include <rdet/RBeaconSQLManager.h>
#include <utl/ErrorLogger.h>
#include <rdet/RDetector.h>
#include <rdet/RManagerRegister.h>
#include <det/VManager.h>
#include <utl/UTCDateTime.h>
#include <utl/TimeStamp.h>
#include <utl/LeapSeconds.h>
#include <utl/TabulatedFunctionComplexLgAmpPhase.h>
#include <utl/MathConstants.h>

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

REGISTER_R_MANAGER("RBeaconSQLManager", RBeaconSQLManager)

namespace rdet {

  void
  RBeaconSQLManager::Init(const string& configLink)
  {
    VSQLManager::Init(configLink);
  }
  
  VManager::Status
  RBeaconSQLManager::InternalGetDataVecDouble(std::vector<double>& returnData,
                                              const std::string& /*componentProperty*/,
                                              const std::string& componentName,
                                              const VManager::IndexMap& /*componentIndex*/) const
  {
    if (componentName=="BeaconFreq") {
    //if ComponentMap is not needed
      // check if cache is available and up-to-date
      const TimeStamp& curTime = Detector::GetInstance().GetTime();
      if ( (fBeaconFreqs.size()) && 
            (fBeaconFreqsBufferedStartDate < curTime) &&
            (fBeaconFreqsBufferedStopDate > curTime) ) {
        returnData = fBeaconFreqs;
        return eFound;
      } else {                          //else query DB
        try {
          returnData = GetBeaconFrequencies();
          fBeaconFreqs = returnData;
          if (returnData.size()) {
            return eFound;
          }
        } catch (utl::DataNotFoundInDBException& err) {
          throw (err);
        }
      }
    }
    return eNotFound;
  }
 
  VManager::Status
  RBeaconSQLManager::InternalGetDataDouble(double& returnData,
                                           const std::string& /*componentProperty*/,
                                           const std::string& componentName,
                                           const VManager::IndexMap& componentIndex) const
  {
    if  (componentName=="BeaconRefPhase") {
      const TimeStamp& curTime = Detector::GetInstance().GetTime();
      const int stationId = boost::lexical_cast<int>(componentIndex.find("RStationId")->second);
      stringstream sBeaconFreq(componentIndex.find("BeaconFreq")->second);
      double beaconFreq = 0;
      sBeaconFreq >> beaconFreq;
      
      // check if cache is available and up-to-date
      if ( (fBufferBeaconRefPhases.size()) && 
           (fBufferBeaconRefPhases.find(stationId) != fBufferBeaconRefPhases.end()) &&
           (fBufferBeaconRefPhases[stationId].find(beaconFreq) != fBufferBeaconRefPhases[stationId].end()) &&
           (fBufferBeaconRefPhases[stationId][beaconFreq].startDate < curTime) &&
           (fBufferBeaconRefPhases[stationId][beaconFreq].stopDate > curTime) ) {
        returnData = fBufferBeaconRefPhases[stationId][beaconFreq].refPhase;
      } else {                          //else query DB
        try {
          returnData = GetBeaconRefPhase(stationId, beaconFreq);
        } catch (utl::DataNotFoundInDBException& err) {
          throw (err);
        }
      }
      return eFound;
    }
    return eNotFound;
  }

  
  std::vector<double>
  RBeaconSQLManager::GetBeaconFrequencies() 
    const 
  {
    const TimeStamp& curTime = Detector::GetInstance().GetTime();
    ostringstream query;
    query << "select BeaconFrequency, UNIX_TIMESTAMP(Commission), UNIX_TIMESTAMP(Decommission) from BeaconFreq where"
          << "     Commission<\""   << UTCDateTime(curTime).GetInMySQLFormat() << "\" "
          << " and Decommission>\"" << UTCDateTime(curTime).GetInMySQLFormat() << "\";";
    if (Query(query.str(), QueryInfoMessage("BeaconFrequency", "BeaconFreq")) == eNotFound) {
      const string err = "No Beacon Frequency for given event-time in SQL data found! Query: " + query.str();
      throw DataNotFoundInDBException(err);
    }
    vector<double> Result;
    vector<TimeStamp> Comission;
    vector<TimeStamp> Decomission;
    vector<string> sqlResult;
    utl::LeapSeconds leapSeconds;
    unsigned long gpsSeconds=0; // dummy variable for conversion only
    bool firstValue = true; // for all but the first value, check if the validity range in time is shorter.
    while (FetchRow(sqlResult, false) == eFound) {
      Result.push_back(boost::lexical_cast<double>(sqlResult[0]));
      
      // determine and store validity range
      leapSeconds.ConvertUnixToGPS(boost::lexical_cast<unsigned long>(sqlResult[1]),gpsSeconds);
      if (firstValue) {
        fBeaconFreqsBufferedStartDate = TimeStamp(gpsSeconds);      
      } else {
        if (fBeaconFreqsBufferedStartDate < TimeStamp(gpsSeconds))
          fBeaconFreqsBufferedStartDate = TimeStamp(gpsSeconds);      
      }
      leapSeconds.ConvertUnixToGPS(boost::lexical_cast<unsigned long>(sqlResult[2]),gpsSeconds);
       if (firstValue) {
        fBeaconFreqsBufferedStopDate = TimeStamp(gpsSeconds);
      } else {
        if (fBeaconFreqsBufferedStopDate > TimeStamp(gpsSeconds))
          fBeaconFreqsBufferedStopDate = TimeStamp(gpsSeconds);      
      }
      firstValue = false;
     }
     
    return Result;
  }

  double
  RBeaconSQLManager::GetBeaconRefPhase(const int& stationId,
                                       const double& beaconFreq) const 
  {
    const TimeStamp& curTime = Detector::GetInstance().GetTime();
    ostringstream query;
    query << "select BeaconRefPhase.RefPhase, UNIX_TIMESTAMP(Start), UNIX_TIMESTAMP(Stop) from BeaconFreq , BeaconRefPhase"
          << " where BeaconFreq.BeaconFreq_id=BeaconRefPhase.BeaconFreq_id"
          << " and BeaconRefPhase.RStationId = " << stationId
          << " and BeaconFreq.BeaconFrequency LIKE " << beaconFreq
          << " and Start<\""   << UTCDateTime(curTime).GetInMySQLFormat() << "\" "
          << " and Stop>\"" << UTCDateTime(curTime).GetInMySQLFormat() << "\";";
    const string err = "No Beacon RefPhase for event-time in  SQL data found! Query: " + query.str();
    if (Query(query.str(), QueryInfoMessage("BeaconRefPhase", "RefPhase")) == eNotFound) {
      throw DataNotFoundInDBException(err);
    }
    //cout << query.str() << endl;
    vector<string> sqlResult;
    if (FetchRow(sqlResult, false) != eFound) {
      throw DataNotFoundInDBException(err);      
    }
    double Result = boost::lexical_cast<double>(sqlResult[0]);
    
    // store value in cache
    fBufferBeaconRefPhases[stationId][beaconFreq].refPhase = Result;
 
    // store validity dates in cache
    utl::LeapSeconds leapSeconds;
    unsigned long gpsSeconds=0; // dummy variable for conversion only
    leapSeconds.ConvertUnixToGPS(boost::lexical_cast<unsigned long>(sqlResult[1]),gpsSeconds);
    fBufferBeaconRefPhases[stationId][beaconFreq].startDate = TimeStamp(gpsSeconds);
    leapSeconds.ConvertUnixToGPS(boost::lexical_cast<unsigned long>(sqlResult[2]),gpsSeconds);
    fBufferBeaconRefPhases[stationId][beaconFreq].stopDate = TimeStamp(gpsSeconds);

    return Result;
  }
}