RSimulationStationListManager.cc

Go to the documentation of this file.

#include <io/REASIOException.h>

#include <rdet/RSimulationStationListManager.h>
#include <rdet/RManagerRegister.h>

#include <det/Detector.h>

#include <evt/Event.h>
#include <evt/ShowerSimData.h>
#include <evt/RadioSimulation.h>

#include <utl/UTCDateTime.h>
#include <utl/TimeStamp.h>
#include <utl/UTMPoint.h>
#include <utl/Point.h>
#include <utl/ReferenceEllipsoid.h>
#include <utl/ErrorLogger.h>

#include <fwk/CentralConfig.h>
#include <fwk/RunController.h>
#include <fwk/LocalCoordinateSystem.h>

#include <boost/algorithm/string/predicate.hpp>
#include <boost/lexical_cast.hpp>

#include <iostream>
#include <string>
#include <map>


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


REGISTER_R_MANAGER("RSimulationStationListManager", RSimulationStationListManager);


namespace rdet {

  string RSimulationStationListManager::Utf8To7Bit(const string& str)
   const
  {
    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 RSimulationStationListManager::Init(const string& configLink)
  {
    // first call shadowed VManager::Init()
    VSQLManager::Init(configLink);

    Branch topBranch = CentralConfig::GetInstance()->GetTopBranch("RSimulationStationListManager");

    topBranch.GetChild("ReadInAdditionalStationViaXML").GetData(fReadInAdditionalStationViaXML);
    topBranch.GetChild("ReadInAdditionalStationViaSQL").GetData(fReadInAdditionalStationViaSQL);

    ostringstream out;

    // Add stations from a XML station list    
    if (fReadInAdditionalStationViaXML) {
      Branch stationList = fBranch.GetChild("stationList");

      int number_of_xml_stations = 0;
      for (Branch cB = stationList.GetFirstChild(); cB; cB = cB.GetNextSibling()) {

        if (cB.GetName() == "station") {

          RStationListManager::StationData station;
          station.fSource = "XML";

          station.fId = FindComponent<int>("id", cB.GetAttributes());
          cB.GetChild("northing").GetData(station.fNorthing);
          cB.GetChild("easting").GetData(station.fEasting);
          cB.GetChild("altitude").GetData(station.fAltitude);
          station.fName = cB.GetChild("name").GetDataString();
          cB.GetChild("commission").GetData(station.fCommissionTime);
          cB.GetChild("decommission").GetData(station.fDecommissionTime);
          cB.GetChild("inGrid").GetData(station.fInGrid);
          cB.GetChild("ellipsoid").GetData(station.fEllipsoid);
          cB.GetChild("zone").GetData(station.fZone);
          cB.GetChild("band").GetData(station.fBand);
          cB.GetChild("nChannels").GetData(station.fNChannels);
          cB.GetChild("firstChannelId").GetData(station.fFirstChannelId);
          cB.GetChild("lastChannelId").GetData(station.fLastChannelId);

          const bool ok =
            fStationManager.ConditionalAddStationData(station);

          if (!ok) {
            ostringstream error;
            error << "multiple instances of station id " << station.fId
                  << " found in XML / SQL configuration";
            ERROR(error);
            throw utl::XMLParseException(error.str());
          }

          number_of_xml_stations++;
        }
      }

      out << "\n\tInitialized " << number_of_xml_stations << " radio stations via XML list.";
    }

  out << "\n\tInitialize stations from SQL DB: " << fReadInAdditionalStationViaSQL << "\n";
  INFO(out);
  }


  void
  RSimulationStationListManager::AddVirtualStation(RStationListManager::StationData& station)
  {
    fStationManager.AddOrReplaceStationData(station);
  }

  bool
  RSimulationStationListManager::HasStationData(const int id)
   const
  {
    return fStationManager.HasStationData(id);
  }


  VManager::Status
  RSimulationStationListManager::GetListOfChannelIds(std::vector<int>& resultData,
                                                     const string& /*componentProperty*/,
                                                     const det::VManager::IndexMap& componentIndex)
    const
  {
    std::vector<int> result;
    int firstChannelId = 0;
    int lastChannelId = 0;
    if (fStationManager.GetData(firstChannelId, "firstChannelId",  componentIndex) == eFound &&
        fStationManager.GetData(lastChannelId, "lastChannelId", componentIndex) == eFound) {
      for (int i = firstChannelId; i <= lastChannelId; ++i)
        result.push_back(i);
      resultData = result;
      return eFound;
    }
    return eNotFound;
  }


}

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

  // Remove only station from SQL source
  fStationManager.ClearStations("SQL");

  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";

    station.fId = lexical_cast<int>(IdElZoBaNoEaAlNaIGNCFCLCCTDT[0]);
    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';
      }
      
      fStationManager.AddOrReplaceStationData(station);

      // const bool ok = fStationManager.ConditionalAddStationData(station);
      // if (!ok) {
      //   ostringstream err;
      //   err << "problem adding station to list for station-id " << station.fId
      //       << "found in SQL / XML 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();
}