FCalibSQLManager.cc

Go to the documentation of this file.

#include <string>
#include <sstream>

#include <boost/lexical_cast.hpp>

#include <fdet/FCalibSQLManager.h>
#include <fwk/CentralConfig.h>
#include <det/Detector.h>

#include <utl/ErrorLogger.h>
#include <utl/TimeStamp.h>
#include <utl/UTCDateTime.h>
#include <utl/Reader.h>
#include <utl/TabulatedFunction.h>
#include <utl/AugerException.h>
#include <utl/ShadowPtr.h>
#include <utl/StringCompare.h>

#include <fdet/FManagerRegister.h>
#include <fdet/FDetector.h>
#include <fdet/Eye.h>
#include <fdet/Telescope.h>

using namespace std;
using namespace fdet;
using namespace utl;
using namespace det;
using namespace fwk;


REGISTER_F_MANAGER("FCalibSQLManager", FCalibSQLManager);

void
FCalibSQLManager::Init(const std::string& configLink)
{
  VSQLManager::Init(configLink);

  fEyesToIgnore.clear();

  if (fBranch.GetChild("eyesToIgnore"))
      fBranch.GetChild("eyesToIgnore").GetData(fEyesToIgnore);
}

VManager::Status
FCalibSQLManager::GetData(double& returnData,
                          const string& componentProperty,
                          const string& componentName,
                          const IndexMap& componentIndex)
  const
{
  // ATTENTION to be implemented with caching.

  if (componentProperty == "pixel_t_offset") {

    const int pixeltoffsetid = GetPixelTOffsetId(componentIndex);
    if (!pixeltoffsetid) {
      ERROR("Could not retrieve pixel_t_offset_id");
      return eNotFound;
    }

    ostringstream query;
    query << "SELECT pixel_t_offset FROM pixel_t_offset "
             "WHERE pixel_t_offset_id = " << pixeltoffsetid;

    return (Query(query, QueryInfoMessage(componentProperty, componentName)) == eNotFound) ?
      eNotFound : FetchRow(returnData);

  } else if (componentProperty == "elecgain" || componentProperty == "status") {

    const IndexMap::const_iterator pIt = componentIndex.find("pixelId");
    if (pIt == componentIndex.end()) {
      if (IsReportingErrors())
        ERROR("'pixelId' not found for " + QueryInfoMessage(componentProperty, componentName));
      return eNotFound;
    }

    const string& pixelId = pIt->second;

    ostringstream query;

    if (componentName == "fd_calib") {

      query << "SELECT " << componentProperty << " FROM pixel_calib "
               "WHERE working_calib_id = " << GetWorkingCalibId(componentIndex) << " "
               "AND pixel_number = " << pixelId;

    } else if (componentName == "low_gain_calib") {

      const int pixel = boost::lexical_cast<int>(pixelId);

      const unsigned int telId = boost::lexical_cast<unsigned int>(componentIndex.find("telescopeId")->second);
      const fdet::Eye& detEye =
        det::Detector::GetInstance().GetFDetector().GetEye(componentIndex.find("eyeId")->second);
      const fdet::Telescope& detTel = detEye.GetTelescope(telId);

      query << "SELECT elec_gain FROM low_gain_channel "
               "WHERE working_calib_id = " << GetWorkingCalibId(componentIndex) << " "
               "AND channel_number = " << (pixel - detTel.GetLastPixelId());
      // how are virtual channel mapped in the DB?

    } else {
      ERROR(string("Can not handle call for ") + QueryInfoMessage(componentProperty, componentName));
      return eNotFound;
    }

    return (Query(query, QueryInfoMessage(componentProperty, componentName)) == eNotFound) ?
      eNotFound : FetchRow(returnData);

  }
  return eNotFound;
}


VManager::Status
FCalibSQLManager::GetData(map<int, utl::TabulatedFunction>& returnData,
                          const string& componentProperty,
                          const string& componentName,
                          const IndexMap& componentIndex)
  const
{
  returnData.clear();

  if (componentProperty != "pixel_calibs") {
    ERROR(string("Can not handle call for ") + QueryInfoMessage(componentProperty, componentName));
    return eNotFound;
  }

  if (fEyesToIgnore.size() > 0) {
    unsigned int eyeId;
    istringstream eyeIds(componentIndex.find("eyeId")->second);
    eyeIds >> eyeId;

    for (vector<unsigned int>::const_iterator it = fEyesToIgnore.begin(); it != fEyesToIgnore.end(); it++) {
      if (*it == eyeId)
        return eNotFound;
    }
  }

  const int workingCalibId = GetWorkingCalibId(componentIndex);

  if (workingCalibId < 0) {
    ERROR("Could not retrieve working_calib_id");
    return eNotFound;
  }

  ostringstream query;

  query << "SELECT pixel_number, wavelength, cal_const FROM pixel_wavelength_calib, pixel_calib "
           "WHERE pixel_calib.working_calib_id = " << workingCalibId << " "
           "AND pixel_wavelength_calib.pixel_calib_id = pixel_calib.pixel_calib_id";

  if (Query(query, QueryInfoMessage(componentProperty, componentName)) == eNotFound)
    return eNotFound;

  const unsigned int numCols = NumFields();

  if (numCols != 3) {
    ERROR("Found wrong number of rows in the pixel calibration query!");
    return eNotFound;
  }

  int curPix = -1;

  // prevent memory leaks
  ShadowPtr<TabulatedFunction> calVsWavelength;

  boost::tuple<int, double, double> pixelNumber_wavelength_calConst;

  while (FetchNextRowMany(pixelNumber_wavelength_calConst) == eFound) {

    const int& pixelNumber = pixelNumber_wavelength_calConst.get<0>();
    // Untangle the stream of data from the query into navigable structure
    if (pixelNumber != curPix) {
      if (calVsWavelength)
        returnData.insert(make_pair(curPix, *calVsWavelength));

      calVsWavelength = new TabulatedFunction;
      curPix = pixelNumber;
    }

    const double& wavelength = pixelNumber_wavelength_calConst.get<1>();
    const double& calConst = pixelNumber_wavelength_calConst.get<2>();
    calVsWavelength->PushBack(wavelength*nanometer, calConst);

  }

  if (calVsWavelength)
    returnData.insert(make_pair(curPix, *calVsWavelength));

  return eFound;
}


VManager::Status
FCalibSQLManager::GetData(int& returnData,
                          const string& componentProperty,
                          const string& componentName,
                          const IndexMap& componentIndex)
  const
{
  // Retrieve validity interval for data
  if (componentProperty != "start_time" && componentProperty != "end_time") {
    ERROR(string("Can not handle call for ") + QueryInfoMessage(componentProperty, componentName));
    return eNotFound;
  }

  ostringstream query;
  query << "SELECT " << componentProperty << " FROM working_calib "
           "WHERE working_calib_id = " << GetWorkingCalibId(componentIndex);

  if (Query(query) == eNotFound)
    return eNotFound;

  if (FetchRow(returnData) == eFound)
    return eFound;

  query.str("");
  query << "SELECT start_time "
           "FROM working_calib, software, building_camera "
           "WHERE working_calib.building_camera_id = building_camera.building_camera_id "
           "AND building_camera.building_number = " << componentIndex.find("eyeId")->second << " "
           "AND building_camera.camera_number = " << componentIndex.find("telescopeId")->second;

  if (!utl::StringEquivalent(fDatabaseSoftwareVersion, "default"))
    query << " "
             "AND working_calib.software_id = software.software_id "
             "AND software.software_version = '" << fDatabaseSoftwareVersion << '\'';

  const TimeStamp detTime = Detector::GetInstance().GetTime();
  query << " "
           "AND working_calib.start_time > '"<< detTime.GetGPSSecond()<< "' "
           "ORDER BY working_calib.start_time, working_calib.last_modified DESC "
           "LIMIT 1";

  if (Query(query, QueryInfoMessage(componentProperty, componentName)) == eNotFound)
    return eNotFound;

  if (FetchRow(returnData) == eNotFound)
    // set time to "infinity"
    returnData = UTCDateTime(2030, 1, 1).GetTimeStamp().GetGPSSecond();

  return eFound;
}


VManager::Status
FCalibSQLManager::GetData(vector<int>& returnData,
                          const string& componentProperty,
                          const string& componentName,
                          const IndexMap& componentIndex)
  const
{
  if (componentProperty != "status" || componentName != "fd_calib")
    return eNotFound;

  returnData.clear();

  ostringstream query;

  query << "SELECT pixel_number, status FROM pixel_calib "
           "WHERE working_calib_id = " << GetWorkingCalibId(componentIndex)
           << " ORDER BY pixel_number DESC";

  if (Query(query) == eNotFound)
    return eNotFound;

  boost::tuple<int, int> pixelId_status;
  if (FetchRowMany(pixelId_status, false) != eFound)
    return eNotFound;

  const int maxPixelId = pixelId_status.get<0>();

  // missing pixels will have status -1
  returnData.resize(maxPixelId + 1, -1);
  returnData[maxPixelId] = pixelId_status.get<1>();

  while (FetchRowMany(pixelId_status, false) == eFound)
    returnData[pixelId_status.get<0>()] = pixelId_status.get<1>();

  FreeResult();

  return eFound;
}


int
FCalibSQLManager::GetWorkingCalibId(const IndexMap& componentIndex)
  const
{
  const TimeStamp detTime = Detector::GetInstance().GetTime();

  // Compose the SQL query

  const string& eyeId = componentIndex.find("eyeId")->second;
  const string& telescopeId = componentIndex.find("telescopeId")->second;

  // first get the working_calib_id

  ostringstream query;
  query << "SELECT working_calib_id "
           "FROM working_calib LEFT JOIN building_camera "
           "ON working_calib.building_camera_id=building_camera.building_camera_id ";

   if (!utl::StringEquivalent(fDatabaseSoftwareVersion, "default"))
     query << " LEFT JOIN software "
              "ON working_calib.software_id = software.software_id ";

   query << "WHERE building_camera.building_number = " << eyeId << " "
            "AND building_camera.camera_number = " << telescopeId <<" "
            "AND working_calib.start_time <= \""<< detTime.GetGPSSecond() << "\" "
            "AND (working_calib.end_time > \"" << detTime.GetGPSSecond() << "\" "
             "OR working_calib.end_time IS NULL) ";

  if (!utl::StringEquivalent(fDatabaseSoftwareVersion, "default"))
    query <<  "AND software.software_version = \"" << fDatabaseSoftwareVersion << '"';

  query << " ORDER BY working_calib.last_modified DESC, working_calib.start_time DESC, working_calib_id DESC "
           "LIMIT 1";

  int ret = -1;

  /*
  if (Query(query) == eNotFound || FetchRow(ret) == eNotFound)
    throw DataNotFoundInDBException("working_calib_id", "working_calib",
                                    componentIndex, boost::lexical_cast<string>(detTime));
  */


  if ( Query(query) != eNotFound )
    FetchRow(ret);

  return ret;
}


// ATTENTION: to be modified.
// returns 0  if query fails
int
FCalibSQLManager::GetPixelTOffsetId(const IndexMap& componentIndex)
  const
{
  const int workingCalibId = GetWorkingCalibId(componentIndex);
  const string& pixelId = componentIndex.find("pixelId")->second;

  ostringstream query;
  query << "SELECT pixel_t_offset_id FROM pixel_calib "
           "WHERE working_calib_id = " << workingCalibId << " "
           "AND pixel_number = " << pixelId;

  int result = 0;
  if (Query(query, QueryInfoMessage("pixel_calib", "pixel_t_offset_id")) == eFound)
    FetchRow(result);

  return result;
}


std::vector<double>
FCalibSQLManager::FindAvailableWavelengths(const int pixelCalibId)
  const
{
  ostringstream query;
  query << "SELECT wavelength FROM pixel_wavelength_calib "
           "WHERE pixel_calib_id = " <<  pixelCalibId;

  vector<double> retWavelengths;

  if (Query(query, QueryInfoMessage("pixel_wavelength_calib", "wavelength")) == eFound)
    FetchColumn(retWavelengths);

  return retWavelengths;
}


// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// compile-command: "make -C .. FDetector/FCalibSQLManager.o -k"
// End: