MonitoringSQLManager.cc

Go to the documentation of this file.

#include "MonitoringSQLManager.h"

#include <boost/lambda/lambda.hpp>

#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>

#include <utl/AugerException.h>
#include <utl/AugerUnits.h>

#include <sstream>

using namespace std;


REGISTER_R_MANAGER("MonitoringSQLManager", rdet::MonitoringSQLManager);


namespace rdet {

void
MonitoringSQLManager::Init(const string& configLink)
{
  VSQLManager::Init(configLink);
}


double
MonitoringSQLManager::GetTemperature(const std::string& site, const double timeToAverage,
                                     const unsigned int numberOfQueriesToBuffer,
                                     const double precision)
  const
{
  const utl::TimeStamp& currentTime = det::Detector::GetInstance().GetTime();
  unsigned int currentGPSSeconds = currentTime.GetGPSSecond();

  if (fTemperatureBuffer.find(site) == fTemperatureBuffer.end()) {
    INFO("site not found in temperature buffer, buffering database...");
    if (!BufferTemperature(site, timeToAverage, numberOfQueriesToBuffer)) {
      WARNING("An error occurred while buffering temperature.");
      return std::numeric_limits<double>::quiet_NaN();;
    }
  } else {
    std::cout << "Temperatures buffered between " << fTemperatureBufferInterval[site].first << " and "
              << fTemperatureBufferInterval[site].second << "\ncurrentGPSSeconds = "
              << currentGPSSeconds << std::endl;
    if (((fTemperatureBufferInterval[site].first - 0.9 * precision / utl::second) > currentGPSSeconds) ||
        ((fTemperatureBufferInterval[site].second + 0.9 * precision / utl::second) < currentGPSSeconds)) {
      INFO("No temperature information at event-time found in buffer, rebuffering database...");
      if (!BufferTemperature(site, timeToAverage, numberOfQueriesToBuffer)) {
        WARNING("An error occurred while buffering temperature");
        return std::numeric_limits<double>::quiet_NaN();;
      }
    }
  }

  for (auto it = fTemperatureBuffer[site].begin(); it != fTemperatureBuffer[site].end(); ++it) {
    if (fabs(it->first - currentGPSSeconds) < precision / utl::second) {
      stringstream sstr;
      sstr << "Temperature found in buffer. GPSsecond in buffer " << it->first
           << ", currentGPSseconds " << currentGPSSeconds << ", difference "
           << fabs(it->first - currentGPSSeconds) << ", precision " << precision / utl::second
           << "seconds";
      INFO(sstr.str());
      return it->second;
    }
  }

  ostringstream sstr;
  sstr << "An error occurred reading temperature from buffer. "
          "Most likely reason: There is no temperature information in the database for the event time "
       << utl::UTCDateTime(currentTime).GetInXMLFormat();
  WARNING(sstr);

  //throw utl::AugerException("An error occurred reading temperature from buffer.");
  //return false;
  return std::numeric_limits<double>::quiet_NaN();
}


bool
MonitoringSQLManager::BufferTemperature(const std::string& site, const double timeToAverage,
                                        const unsigned int numberOfQueriesToBuffer)
  const
{
  stringstream query;
  const utl::TimeStamp& currentTime = det::Detector::GetInstance().GetTime();
  const utl::TimeStamp startTime = currentTime - utl::TimeInterval(0.5*timeToAverage);
  const utl::TimeStamp stopTime = currentTime + utl::TimeInterval(numberOfQueriesToBuffer * timeToAverage);

  const utl::UTCDateTime currentDateTime(currentTime);
  const string mySQLTime = currentDateTime.GetInMySQLFormat();

  std::cout << "buffering DB for site " << site << " at time " << currentDateTime
            << " buffer size is " << timeToAverage / utl::second << "seconds with " << numberOfQueriesToBuffer
            << " queries" << std::endl;

  if (site == "CRS") {
    //std::cout << "query to CRS Moni DB" << std::endl;
    query << "select AVG(UNIX_TIMESTAMP(TimeStamp)), AVG(Temperature) from Weather where TimeStamp between \""
          << utl::UTCDateTime(startTime).GetInMySQLFormat() << "\" and \""
          // FLOOR is not SQLite compatible, better use ROUND(XXX - 0.5)
          << utl::UTCDateTime(stopTime).GetInMySQLFormat() << "\" group by ROUND(UNIX_TIMESTAMP(TimeStamp)/"
          << timeToAverage / utl::second << " -0.5) order by TimeStamp asc";
    std::cout << query.str() << std::endl;
  } else {
    ostringstream error_msg;
    error_msg << "Site " << site
              << " is not implemented. The only current available site is \"CRS\"";
    ERROR(error_msg);
    throw utl::NonExistentComponentException(error_msg.str());
   //query << "select AVG(UNIX_TIMESTAMP(Time)), AVG(Temperature) from Weather where WeatherStation == "
   //      << site << " and TimeStamp between " << utl::UTCDateTime(startTime).GetInMySQLFormat()
   //      << " and " << utl::UTCDateTime(stopTime).GetInMySQLFormat() << " group by FLOOR(TimeStamp/"
   //      << timeToAverage / utl::second << ") order by TimeStamp asc";
  }

  if (Query(query.str(), QueryInfoMessage("monitoring", "temperature")) == eNotFound) {
    std::cout << "error in DB Query" << std::endl;
    return false;
  }

  utl::LeapSeconds leapSeconds;

  vector<string> sqlResult;

  std::vector<std::pair<unsigned long, double> > temp_vector;
  while (FetchRow(sqlResult, false) == eFound) {
    unsigned long gpsSeconds = 0;
    leapSeconds.ConvertUnixToGPS(long(boost::lexical_cast<double>(sqlResult[0])), gpsSeconds);
    const double temperature = boost::lexical_cast<double>(sqlResult[1]);
    //std::cout << "filling temperature buffer utc: " << sqlResult[0] << " gps: " << gpsSeconds << " " << temperature << std::endl;
    std::pair<unsigned long, double> temp_pair(gpsSeconds, temperature);
    temp_vector.push_back(temp_pair);
  }
  fTemperatureBuffer[site] = temp_vector;
  fTemperatureBufferInterval[site] = std::make_pair(startTime.GetGPSSecond(), stopTime.GetGPSSecond());

  return true;
}

}