FOpticalEfficiencyLossSQLManager.cc

Go to the documentation of this file.

#include <string>
#include <sstream>

#include <boost/lexical_cast.hpp>

#include <fdet/FOpticalEfficiencyLossSQLManager.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 <fdet/FManagerRegister.h>
#include <fdet/FDetector.h>

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


REGISTER_F_MANAGER("FOpticalEfficiencyLossSQLManager", FOpticalEfficiencyLossSQLManager);


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

VManager::Status
FOpticalEfficiencyLossSQLManager::GetData(double& /*returnData*/,
                                          const string& /*componentProperty*/,
                                          const string& /*componentName*/,
                                          const IndexMap& )
  const
{
  return eNotFound;
}


VManager::Status
FOpticalEfficiencyLossSQLManager::GetData(map<int, utl::TabulatedFunction>& returnData,
                                          const string& componentProperty,
                                          const string& componentName,
                                          const IndexMap& componentIndex)
  const
{
  // this manager only knows about fd_optical_efficiency
  if (componentName != "fd_optical_efficiency") 
    return eNotFound;

  returnData.clear();

  if (componentProperty == "pixel_optical_efficiency_corrections") {
    const fdet::FDetector& fdet = det::Detector::GetInstance().GetFDetector();
    const double wavelength = fdet.GetReferenceLambda();

    const string& eyeIdString = componentIndex.find("eyeId")->second;
    const string& telescopeIdString = componentIndex.find("telescopeId")->second;
    const unsigned int eyeId = boost::lexical_cast<unsigned int>(eyeIdString);
    const unsigned int telId = boost::lexical_cast<unsigned int>(telescopeIdString);

    double opticalEff = 0;
    if (GetOpticalEfficiencyCorrectionForTelescope(eyeId, telId, opticalEff)) {

      for (int iPix = 1; iPix <= 440; ++iPix) {
        TabulatedFunction effVsWavelength;
        effVsWavelength.PushBack(wavelength, opticalEff);
        returnData.insert(make_pair(iPix, effVsWavelength));
      }

      return eFound;
    }
  }

  return eNotFound;
}


bool
FOpticalEfficiencyLossSQLManager::GetOpticalEfficiencyCorrectionForTelescope(const unsigned int eyeId,
                                                                             const unsigned int telId,
                                                                             double& value)
  const
{
  const TimeStamp detTime = Detector::GetInstance().GetTime();
  const int gpsSecond = detTime.GetGPSSecond();
  const string tel = ConvertEyeTelToTelId(eyeId, telId);

  ostringstream queryBefore;
  ostringstream queryAfter;

  boost::tuple<double, int> before; //cal. const., GPS sec.
  boost::tuple<double, int> after;

  queryBefore << "SELECT " << tel << ", GPSsecond FROM constants, software WHERE constants.GPSsecond <= \"" << gpsSecond
        << "\" AND constants.software_id = software.software_id AND software.software_version = \"" << fDatabaseSoftwareVersion
        << "\" AND constants." << tel << " IS NOT NULL ORDER BY constants.GPSsecond DESC, constants.constants_id DESC LIMIT 1";

  if ( Query(queryBefore) != eNotFound ) {
    if ( FetchRowMany(before) == eNotFound ) {
      before.get<1>() = 0;
    }
  } else {
    before.get<1>() = 0;
  }

  queryAfter << "SELECT " << tel << ", GPSsecond FROM constants, software WHERE constants.GPSsecond > \"" << gpsSecond
        << "\" AND constants.software_id = software.software_id AND software.software_version = \"" << fDatabaseSoftwareVersion
        << "\" AND constants." << tel << " IS NOT NULL ORDER BY constants.GPSsecond, constants.constants_id DESC LIMIT 1";

  if ( Query(queryAfter) != eNotFound ) {
    if ( FetchRowMany(after) == eNotFound ) {
      after.get<1>() = 0;
    }
  } else {
    after.get<1>() = 0;
  }

  if (before.get<1>() != 0 && after.get<1>() != 0) {
    if ((gpsSecond - before.get<1>()) < (after.get<1>()-gpsSecond)) {
      value = before.get<0>();
    } else {
      value = after.get<0>();
    }
  } else if (before.get<1>() != 0) {
    value = before.get<0>();
  } else if (after.get<1>() != 0) {
    value = after.get<0>();
  } else {
    // no recalibration if we have no information in the database
    value = 1.;
  }

  return true;
}


VManager::Status
FOpticalEfficiencyLossSQLManager::GetData(vector<int>& returnData,
                                          const string& componentProperty,
                                          const string& componentName,
                                          const IndexMap& /*componentIndex*/)
  const
{
  // pixel status is not stored in the database
  if (componentProperty != "status" || componentName != "fd_optical_efficiency")
    return eNotFound;
  returnData.clear();
  returnData.resize(441, 0);  // eGood
  return eFound;
}


VManager::Status
FOpticalEfficiencyLossSQLManager::GetData(int& returnData,
                                          const string& componentProperty,
                                          const string& componentName,
                                          const IndexMap& componentIndex)
  const
{
  // this manager only knows about fd_optical_efficiency
  if (componentName != "fd_optical_efficiency")
    return eNotFound;

  const TimeStamp detTime = Detector::GetInstance().GetTime();
  const int gpsSecond = detTime.GetGPSSecond();

  const string& eyeIdString = componentIndex.find("eyeId")->second;
  const string& telescopeIdString = componentIndex.find("telescopeId")->second;
  const unsigned int eyeId = boost::lexical_cast<unsigned int>(eyeIdString);
  const unsigned int telId = boost::lexical_cast<unsigned int>(telescopeIdString);
  string tel = ConvertEyeTelToTelId(eyeId, telId);

  ostringstream queryBefore;
  ostringstream queryAfter;

  vector<unsigned int> GPSbefore; //unsigned needed, otherwise we are outside of range when summing
  vector<unsigned int> GPSafter;

  queryBefore << "SELECT GPSsecond FROM constants, software WHERE constants.GPSsecond <= \"" << gpsSecond
        << "\" AND constants.software_id = software.software_id AND software.software_version = \"" << fDatabaseSoftwareVersion
        << "\" AND constants." << tel << " IS NOT NULL ORDER BY constants.GPSsecond DESC, constants.constants_id DESC LIMIT 2";

  if ( Query(queryBefore) != eNotFound ) {
    FetchColumn(GPSbefore);
  }

  queryAfter << "SELECT GPSsecond FROM constants, software WHERE constants.GPSsecond > \"" << gpsSecond
        << "\" AND constants.software_id = software.software_id AND software.software_version = \"" << fDatabaseSoftwareVersion
        << "\" AND constants." << tel << " IS NOT NULL ORDER BY constants.GPSsecond, constants.constants_id DESC LIMIT 2";

  if ( Query(queryAfter) != eNotFound ) {
    FetchColumn(GPSafter);
  }

  /* optical efficiency loss correction is valid between the SQL stored GPSseconds:
     a) GPS_(n-2) GPS_(n-1) gpsSecond ... GPS_(n+1) GPS_(n+2)
         -> (start,end) = ( 0.5*(GPS_(n-2)+GPS_(n-1)), 0.5*(GPS_(n-1)+GPS_(n+1))*0.5 );
     b) GPS_(n-2) GPS_(n-1) ... gpsSecond GPS_(n+1) GPS_(n+2)
         -> (start,end) = ( 0.5*(GPS_(n-1)+GPS_(n+1)), 0.5*(GPS_(n+1)+GPS_(n+2))*0.5 );
  */

  int GPSstart = 0; 
  int GPSend = 0;

  const unsigned int veryEarly = UTCDateTime(2000, 1, 1).GetTimeStamp().GetGPSSecond();
  const unsigned int veryLate = UTCDateTime(2037, 11, 30).GetTimeStamp().GetGPSSecond();

  GPSbefore.resize(2, veryEarly);
  GPSafter.resize(2, veryLate);

  //we have two records before and after the gpsSecond -> use the scheme above
  //and put "very late"/"very early" to appropriate place if necessary
  if ( (gpsSecond - GPSbefore[0]) < (GPSafter[0] - gpsSecond) ) {
    if (GPSbefore[1] == veryEarly) {
      GPSstart = veryEarly;
    } else {
      GPSstart = (GPSbefore[1]+GPSbefore[0])/2;
    }

    GPSend = (GPSbefore[0]+GPSafter[0])/2;
  } else {
    GPSstart = (GPSbefore[0]+GPSafter[0])/2;

    if (GPSafter[1] == veryLate) {
      GPSend = veryLate;
    } else {
      GPSend = (GPSafter[0]+GPSafter[1])/2;
    }
  }

  if (GPSbefore[0] == veryEarly) {
    GPSstart = veryEarly;
  }
  if (GPSafter[0] == veryLate) {
    GPSend = veryLate;
  }

  if (componentProperty == "start_time") {
    returnData = GPSstart;
    return eFound;
  }

  if (componentProperty == "end_time") {
    returnData = GPSend;
    return eFound;
  }

  return eNotFound;
}

string
FOpticalEfficiencyLossSQLManager::ConvertEyeTelToTelId(const int eyeId,
                                                       const int telId)
  const
{
  ostringstream tel;
  tel << "Tel" << (eyeId-1)*6+telId;
  return tel.str();
}