RStationListSQLManager.cc

Go to the documentation of this file.

#include <map>
#include <boost/lexical_cast.hpp>
#include <det/Detector.h>
#include <rdet/RStationListSQLManager.h>
#include <rdet/RManagerRegister.h>
#include <utl/UTCDateTime.h>
#include <utl/TimeStamp.h>

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

REGISTER_R_MANAGER("RStationListSQLManager", RStationListSQLManager)
;

namespace rdet {

string Utf8To7Bit(const string& str)
{
  ostringstream res;

  for (string::const_iterator it = str.begin(); it != str.end(); ++it) {
    const int i = (unsigned char) (*it);
    switch (i) {
      // ntilde; appears in two ways: 0xf1 and 0xc3b1
      case 195:
        ++it;
        if (it != str.end() && int((unsigned char) (*it)) == 177)
          res << "~n";
        break;
      case 241:
        res << "~n";
        break;
      default:
        // drop unprintable chars
        if (32 <= i && i < 127)
          res << *it;
        break;
    }
  }

  return res.str();
}

}

void RStationListSQLManager::Init(const string& configLink)
{
  // first call shadowed VManager::Init()
  VSQLManager::Init(configLink);
}

void RStationListSQLManager::Update() const
{
  const TimeStamp& curTime = Detector::GetInstance().GetTime();
  if (Commissioned.IsInRange(curTime))
    return;

  ostringstream info;
  info << "Request station_list SQL Data for time: " << curTime;
  INFO(info);

  // clear station list
  fStationManager.ClearStationList();

  TimeStamp minValidTime(0, 0);
  TimeStamp maxValidTime(2147483647U, 999999999.9999999);
  TimeStamp tmpTime;
  ostringstream query;
  query << "SELECT "
        "RStationId, "
        "ellipsoid, zone, band, "
        "northing, easting, altitude, "
        "name, "
        "inGrid, "
        "nChannels, firstChannelId, lastChannelId, "
        "max(Commission), min(Decommission) "
        "FROM RStation left join RHardWareAssociation using (RStationId) "
        "left join utm_data using (utm_data_id) "
        "where Commission<\""
        << UTCDateTime(curTime).GetInMySQLFormat() << "\" "
        "and Decommission>\""
        << UTCDateTime(curTime).GetInMySQLFormat() << "\" "
        "GROUP BY RStationId ORDER BY RStationId ASC";
  //jr this selects the comission/decomission of the station
  //   with latest Commision before and the earliest decommission after
  //   the actual detector(event) time of the attached Channel

  if (Query(query.str(), QueryInfoMessage("all station_list", "station_list")) == eNotFound) {
    const string err = "No station_list SQL data found! Query: " + query.str();
    throw DataNotFoundInDBException(err);
  }

  // this query cannot be parsed low-level since this breaks mysql/sqlite compatibility 
  // boost::tuple supports only up to 10 types in template parameters
  // therefore use vector<string> and cast where necessairy
  // this mysql-double->string->double conversion might cause rounding effects! 
  // (but not for the actual RStationList)

  vector<string> IdElZoBaNoEaAlNaIGNCFCLCCTDT;
  while (FetchRow(IdElZoBaNoEaAlNaIGNCFCLCCTDT, false) == eFound) {

    RStationListManager::StationData station;
    station.fSource = "SQL";  // to identify that the describtion of this station should come from an SQL manager

    station.fId = lexical_cast<int>(IdElZoBaNoEaAlNaIGNCFCLCCTDT[0]);
    if (!fStationManager.HasStationData(station.fId)) {
      station.fEllipsoid = IdElZoBaNoEaAlNaIGNCFCLCCTDT[1];
      station.fZone = lexical_cast<int>(IdElZoBaNoEaAlNaIGNCFCLCCTDT[2]);
      station.fBand = IdElZoBaNoEaAlNaIGNCFCLCCTDT[3];
      station.fNorthing = lexical_cast<double>(IdElZoBaNoEaAlNaIGNCFCLCCTDT[4]);
      station.fEasting = lexical_cast<double>(IdElZoBaNoEaAlNaIGNCFCLCCTDT[5]);
      station.fAltitude = lexical_cast<double>(IdElZoBaNoEaAlNaIGNCFCLCCTDT[6]);
      station.fName = Utf8To7Bit(IdElZoBaNoEaAlNaIGNCFCLCCTDT[7]);
      station.fInGrid = lexical_cast<int>(IdElZoBaNoEaAlNaIGNCFCLCCTDT[8]);
      station.fNChannels = lexical_cast<int>(IdElZoBaNoEaAlNaIGNCFCLCCTDT[9]);
      station.fFirstChannelId = lexical_cast<int>(IdElZoBaNoEaAlNaIGNCFCLCCTDT[10]);
      station.fLastChannelId = lexical_cast<int>(IdElZoBaNoEaAlNaIGNCFCLCCTDT[11]);
      //jr check for empty Times  and crude conversion from human readbale UTC as of mysql to AugerTimeFormat e.g. used in SStationList.xml
      //   ComissionTime is defined in DB as 'NOT NULL'
      //   if NULL is returned (here size()==0 ), then the join found no RHardWareAssociation,
      //   thus we do not add this station to the full list!
      if (IdElZoBaNoEaAlNaIGNCFCLCCTDT[12].size() == 0) {
        ostringstream err;
        err << "No configuration for station-id " << station.fId << " found -> station ignored";
        ERROR(err);
      } else {
        if (IdElZoBaNoEaAlNaIGNCFCLCCTDT[12].size() < 19) {
          station.fCommissionTime = "2029-12-31T00:00:00Z";
          ostringstream warn;
          warn << "Empty Comissioning-Time for station " << station.fId << " now set to "
               << station.fCommissionTime;
          INFO(warn);
        } else {
          station.fCommissionTime = IdElZoBaNoEaAlNaIGNCFCLCCTDT[12];
          station.fCommissionTime[10] = 'T';
          station.fCommissionTime[19] = 'Z';
        }
        if (IdElZoBaNoEaAlNaIGNCFCLCCTDT[13].size() < 19) {
          station.fDecommissionTime = "2030-01-01T00:00:00Z";
          ostringstream warn;
          warn << "Empty Decomissioning-Time for station " << station.fId << " now set to "
               << station.fDecommissionTime;
          INFO(warn);
        } else {
          station.fDecommissionTime = IdElZoBaNoEaAlNaIGNCFCLCCTDT[13];
          station.fDecommissionTime[10] = 'T';
          station.fDecommissionTime[19] = 'Z';
        }
        const bool ok = fStationManager.ConditionalAddStationData(station);
        if (!ok) {
          ostringstream err;
          err << "problem adding station to list for station-id " << station.fId
              << "found in SQL configuration";
          ERROR(err);
        }
      }
      tmpTime = boost::lexical_cast<UTCDateTime>(station.fCommissionTime).GetTimeStamp();
      if (tmpTime > minValidTime) {
        minValidTime = tmpTime;
      }
      tmpTime = boost::lexical_cast<UTCDateTime>(station.fDecommissionTime).GetTimeStamp();
      if (tmpTime < maxValidTime) {
        maxValidTime = tmpTime;
      }
    }
  }

  TimeStamp maxDecommission(0, 0);
  // Check if there are additional stations commissioned within the minValidTime..maxValidTime timerange
  query.str("");
  query << "SELECT max(Decommission) "
        "FROM RStation "
        "left join RHardWareAssociation using (RStationId) left join utm_data using (utm_data_id)"
        "where Decommission<\""
        << UTCDateTime(curTime).GetInMySQLFormat() << "\"";
  if (Query(query.str(), QueryInfoMessage("all station_list", "station_list")) == eNotFound) {
    const string err = "No decommissioned stations found before current time! Query: "
        + query.str();
    throw DataNotFoundInDBException(err);
  } else {
    vector<string> sql_result;
    if (FetchRow(sql_result, false) == eFound) {
      if (sql_result[0].size() >= 19) {
        std::string temp = sql_result[0];
        temp[10] = 'T';
        temp[19] = 'Z';
        maxDecommission = boost::lexical_cast<UTCDateTime>(temp).GetTimeStamp();
      }
    }
  }
  minValidTime = max(maxDecommission, minValidTime);

  TimeStamp minCommission = TimeStamp::Max();
  // Check if there are additional stations commissioned within the minValidTime..maxValidTime timerange
  query.str("");
  query << "SELECT min(Commission) "
        "FROM RStation "
        "left join RHardWareAssociation using (RStationId) left join utm_data using (utm_data_id)"
        "where Commission>\""
        << UTCDateTime(curTime).GetInMySQLFormat() << "\"";
  if (Query(query.str(), QueryInfoMessage("all station_list", "station_list")) == eNotFound) {
    const string err = "No now commissioned stations found after current time! Query: "
        + query.str();
    throw DataNotFoundInDBException(err);
  } else {
    vector<string> sql_result2;
    if (FetchRow(sql_result2, false) == eFound) {
      if (sql_result2[0].size() >= 19) {
        std::string temp = sql_result2[0];
        temp[10] = 'T';
        temp[19] = 'Z';
        minCommission = boost::lexical_cast<UTCDateTime>(temp).GetTimeStamp();
      }
    }
  }
  maxValidTime = min(minCommission, maxValidTime);

  Commissioned.SetTimeRange(minValidTime, maxValidTime);
  FreeResult();
  // close SQL to save one connection, but this leads to IsInitialized=0
  //  Close();
}

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// End: