RBadStationSQLManager.cc

Go to the documentation of this file.

#include "RBadStationSQLManager.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>

using namespace std;


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


namespace rdet {

void
RBadStationSQLManager::Init(const string& configLink)
{
  VSQLManager::Init(configLink);
  AddAvailability<unsigned long long int>("BadStation");
}


det::VManager::Status
RBadStationSQLManager::InternalGetData(std::vector<int>& returnData, const std::string& componentProperty,
                                       const std::string& componentName, const IndexMap& /*componentIndex*/)
  const
{
  if (componentProperty != "BadStation")
    return eNotFound;

  if (fBadPeriodList.empty()) {
    std::cout << "Buffer BadStation Database" << std::endl;
    BufferBadPeriodTable();
  }

  union I2LL {
    int fI[2];
    unsigned int long long fL;
  };

  I2LL llReturn;
  llReturn.fL = GetBadPeriodFromBuffer(boost::lexical_cast<int>(componentName));
  //returnData = GetBadPeriod(componentName);  // direct query to database
  returnData.resize(2);
  for (unsigned int i = 0; i < 2; ++i)
    returnData[i] = llReturn.fI[i];
  return eFound;
}


det::VManager::Status
RBadStationSQLManager::GenericGetData(Handle& returnData,
                                      const std::string& component,
                                      const std::string& property,
                                      const IndexMap& /*index*/)
  const
{
  if (!(returnData.Is<unsigned long long int>() && component == "BadStation"))
    return eNotFound;

  if (fBadPeriodList.empty()) {
    std::cout << "Buffer BadStation Database" << std::endl;
    BufferBadPeriodTable();
  }

  returnData.Get<unsigned long long int>() = GetBadPeriodFromBuffer(boost::lexical_cast<int>(property));
  return eFound;
}


int
RBadStationSQLManager::GetBadPeriod(const int stationId)
  const
{
  std::cout << "\nRBadStationSQLManager::GetBadPeriod()" << std::endl;
  const utl::TimeStamp& currentTime = det::Detector::GetInstance().GetTime();
  const utl::UTCDateTime currentDateTime(currentTime);
  const string mySQLTime = currentDateTime.GetInMySQLFormat();
  ostringstream query;
  query << "select Reason from RBadStationList where" << "     StartTime<\"" << mySQLTime << "\" "
        << " and StopTime>\"" << mySQLTime << "\" and StationName = \"" << stationId << "\";";
  std::cout << query.str() << endl;

  const int queryResult =
    Query(query.str(), QueryInfoMessage("Station", boost::lexical_cast<string>(stationId)));
  cout << "Query Result = " << queryResult << endl;
  if (queryResult == eNotFound) {
    std::cout << "RdBadStationSQLManager: No bad period for station " << stationId << " at time "
              << utl::UTCDateTime(currentTime) << std::endl;
    return 0;  // return 0 in case of no bad period
  }

  int result = 0;
  vector<string> sqlResult;
  while (FetchRow(sqlResult, false) == eFound) {
    cout << "while " << endl;
    result = result | boost::lexical_cast<int>(sqlResult[0]);  // combine different BadStationReasons with a logic or
  }
  if (!result) {
    std::cout << "RdBadStationSQLManager: No bad period for station " << stationId << " at time "
              << utl::UTCDateTime(currentTime) << std::endl;
    return 0;  // return 0 in case of no bad period
  }
  std::cout << "RdBadStationSQLManager: Found bad period for station " << stationId << " at time "
            << utl::UTCDateTime(currentTime) << " with reason = " << result << std::endl;
  return result;
}


unsigned long long int
RBadStationSQLManager::GetBadPeriodFromBuffer(const int stationId)
  const
{
  //std::cout << "\nRBadStationSQLManager::GetBadPeriodFromBuffer()" << std::endl;

  // get current time from detector
  const utl::TimeStamp& currentTime = det::Detector::GetInstance().GetTime();
  const utl::UTCDateTime currentDateTime = utl::UTCDateTime(currentTime);
  const unsigned int currentGPSSecond = currentDateTime.GetTimeStamp().GetGPSSecond();

  const std::vector<BadPeriod>& vBadPeriod = fBadPeriodList[stationId];

  unsigned long long int reason = 0;
  for (std::vector<BadPeriod>::const_iterator itBadPeriod = vBadPeriod.begin();
       itBadPeriod != vBadPeriod.end(); ++itBadPeriod) {

    if ((itBadPeriod->startGPSSecond <= currentGPSSecond) &&
        (itBadPeriod->stopGPSSecond >= currentGPSSecond)) {
      reason = reason | itBadPeriod->reason;
      //std::cout << "RdBadStationSQLManager: Found bad period for station " << stationId
      //          << " at time " << utl::UTCDateTime(currentTime) << " = " << currentGPSSecond
      //          << " GPSSecond with reason = " << reason << std::endl;
    }
  }

  return reason;
}


//  bool RBadStationSQLManager::BufferBadPeriodsForCurrentDetector() const
//  {
//    std::cout << "\nRBadStationSQLManager::BufferBadPeriodTable()" << std::endl;
//
//    // load full station list from radio detector
//    const rdet::RDetector& rDetector = det::Detector::GetInstance().GetRDetector();
//    const std::vector<int>& fullStationList = rDetector.GetFullStationList();
//
//    // loop over all stations
//    for(int i = 0; i < fullStationList.size(); ++i) {
//      ostringstream query;
//
//      string stationName = rDetector.GetStation(fullStationList[i]).GetName();
//
//      // select all entries for this station in DB
//      query << "select Reason, StartTime, StopTime, Comments, Reporter from RBadStationList where StationName = \""
//            << stationName << "\";";
//
//      std::vector<BadPeriod> vBadPeriod;        // vector to store all bad periods of station i
//
//      vector<string> sqlResult;
//      while(FetchRow(sqlResult, false) == eFound) {
//        BadPeriod sBadPeriod;
//        sBadPeriod.reason = boost::lexical_cast<unsigned int>(sqlResult[0]);
//        sBadPeriod.startGPSSecond = boost::lexical_cast<unsigned int>(sqlResult[1]);
//        sBadPeriod.stopGPSSecond = boost::lexical_cast<unsigned int>(sqlResult[2]);
//        sBadPeriod.comment = boost::lexical_cast<std::string>(sqlResult[3]);
//        sBadPeriod.reporter = boost::lexical_cast<std::string>(sqlResult[4]);
//
//        vBadPeriod.push_back(sBadPeriod);
//      }
//      fBadPeriodList.insert(std::pair<std::string,std::vector<BadPeriod> >(stationName,vBadPeriod));
//    }
//
//    return true;
//  }


bool
RBadStationSQLManager::BufferBadPeriodTable()
  const
{
  utl::LeapSeconds leapSeconds;
  //INFO("RBadStationSQLManager::BufferBadPeriodTable()");

  std::vector<BadPeriod> vBadPeriod;        // vector to store all bad periods of station i

  ostringstream query;
  // select all entries for all stations in DB
  //  query << "select RStationId, Reason, UNIX_TIMESTAMP(StartTime), UNIX_TIMESTAMP(StopTime), Comments, ReporterId from RBadStationList where ReviewStatus>0 order by RStationId asc";
  query << "SELECT DISTINCT PartName, ReasonPattern, GPSStart, GPSStop FROM `BadPeriod` "
           "LEFT JOIN PartsRel using (BadPeriod_id) "
           "LEFT JOIN Parts on PartsRel.ComponentId = Parts.Parts_id "
           "WHERE Status_id = 3 AND Projects_id = 3 AND SiteId = 140 "
           "order by PartName asc, GPSStart asc";
  // Projects_id 3 is RD
  // SiteId 140 is AERA
  // Status_id 3 is "confirmed"

  std::string error;
  if (Query(query.str(), error) == eNotFound) {
    ostringstream error_msg;
    error_msg << "BadPeriod has no entries. " << error << std::endl;
    ERROR(error_msg);
    return false;
  }

  ostringstream info;
  vector<string> sqlResult;
  int counter = 0;
  int stationId = 0;
  while (FetchRow(sqlResult, false) == eFound) {
    ++counter;

    const int gotId = boost::lexical_cast<int>(sqlResult[0]);
    // save bad periods for station i-1 and clear vector
    if (stationId != gotId) {

      //cout << "station id has changed from " << stationId << " to " << gotId << endl;
      // save bad periods of station i
      if (!vBadPeriod.empty()) {
        info << "\n\tBuffer bad periods for station " << stationId << ": " << vBadPeriod.size() << " bad periods in total";
        fBadPeriodList.insert(std::pair<int, std::vector<BadPeriod> >(stationId, vBadPeriod));
      }
      vBadPeriod.clear();  // clear bad period vector
    }

    stationId = gotId;

    BadPeriod sBadPeriod;
    sBadPeriod.reason = boost::lexical_cast<unsigned long long int>(sqlResult[1]);
    sBadPeriod.startGPSSecond = boost::lexical_cast<unsigned int>(sqlResult[2]);
    sBadPeriod.stopGPSSecond = boost::lexical_cast<unsigned int>(sqlResult[3]);
    //cout << counter << ": station" << stationId << ", "
    //     << sBadPeriod.startGPSSecond << " - " << sBadPeriod.stopGPSSecond << ", " << sBadPeriod.reason << endl;

    //leapSeconds.ConvertUnixToGPS(boost::lexical_cast<unsigned int>(sqlResult[2]), sBadPeriod.startGPSSecond);
    //leapSeconds.ConvertUnixToGPS(boost::lexical_cast<unsigned int>(sqlResult[3]), sBadPeriod.stopGPSSecond);

    //sBadPeriod.comment = boost::lexical_cast<std::string>(sqlResult[4]);
    //sBadPeriod.reporter = boost::lexical_cast<std::string>(sqlResult[5]);

    vBadPeriod.push_back(sBadPeriod);
  }

  // save last station
  if (!vBadPeriod.empty()) {
    info << "\n\tSaving bad periods for last station (station " << stationId << ", " << vBadPeriod.size() << " bad periods)" << endl;
    fBadPeriodList.insert(std::pair<int, std::vector<BadPeriod> >(stationId, vBadPeriod));
  }
  INFO(info);

  return true;
}

}