FdUpTimeSQLManager.cc

Go to the documentation of this file.

#include <string>
#include <sstream>

#include <boost/lexical_cast.hpp>

#include <fdet/FdUpTimeSQLManager.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>
#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("FdUpTimeSQLManager", FdUpTimeSQLManager);


void 
FdUpTimeSQLManager::Init(const std::string& configLink)
{

  VManager::Init(configLink);

  fVerbosity = 0;
  if (fBranch.GetChild("verbosity")) {
    fBranch.GetChild("verbosity").GetData(fVerbosity);
    cout << " FdUpTimeSQLeManager verbosity level = " << fVerbosity << endl;
  }


  // list of properties for telescope
  fAvailableComponents.insert("has_fduptime");
  fAvailableComponents.insert("uptime_gpsStart");
  fAvailableComponents.insert("uptime_gpsStop");
  fAvailableComponents.insert("uptime_fraction");
  fAvailableComponents.insert("status");
  fAvailableComponents.insert("ADCVariance"); // for channel
  fAvailableComponents.insert("Threshold"); // for channel
  fAvailableComponents.insert("Baseline"); // for channel


}

VManager::Status FdUpTimeSQLManager::GetData(double& returnData,
                                              const std::string& componentProperty,
                                              const std::string& componentName,
                                              const IndexMap& componentIndex) const {


  // check if property can be provided by manager
  if (fAvailableComponents.find(componentProperty) == fAvailableComponents.end())
    return VManager::eNotFound;

  if (!ReadData()) {
    ERROR("******************************************");
    ERROR("* Index not found (gps-second)           *");
    ERROR("******************************************");
    return VManager::eNotFound;
  }

  if (fVerbosity>2) {
    ostringstream info;
    info << "called GetData(double) for componentName=" << componentName
         << " componentProperty=" << componentProperty << " and index map: \n" ;
    for (IndexMap::const_iterator imap = componentIndex.begin();
         imap!=componentIndex.end(); imap++) {
      info << " index=\"" << imap->first << "\" -> \"" << imap->second << "\"\n";
    }
    INFO(info);
  }

  if (componentProperty == "has_fduptime") {
    returnData = 1;
    return VManager::eFound;
  }
  if (componentName=="channel") {

    // channel property
    return GetChannelData(returnData, componentProperty, componentName, componentIndex);

  } else if(componentName=="telescope" || componentName=="eye" || componentName=="CDAS") {

    // eye, tel, cdas property
    return GetOnTimeFraction(returnData, componentProperty, componentName, componentIndex);

  }

  return VManager::eNotFound;
}


VManager::Status FdUpTimeSQLManager::GetOnTimeFraction(double& returnData,
                                                        const std::string& componentProperty,
                                                        const std::string& componentName,
                                                        const IndexMap& componentIndex) const {

  
  if (fVerbosity>2) {
    ostringstream info;
    info << "called GetOnTimeFraction for componentName=" << componentName
         << " componentProperty=" << componentProperty << " and index map: \n" ;
    for (IndexMap::const_iterator imap = componentIndex.begin();
         imap!=componentIndex.end(); imap++) {
      info << " index=\"" << imap->first << "\" -> \"" << imap->second << "\"\n";
    }
    INFO(info);
  }

  if (componentProperty=="uptime_fraction") {

    if (componentName=="telescope") {

      int dataId = GetTelIndex(componentIndex);
      map<int, double>::const_iterator iData = fTelescopeOnTimeFraction.find(dataId);
      if (iData == fTelescopeOnTimeFraction.end()) {
        INFO_TERSE("Requested property of FdUpTimeSQLManager not available!");
        return VManager::eNotFound;
      }

      returnData = iData->second;
      return VManager::eFound;
    }


    if (componentName=="eye") {

      int eyeId = GetEyeIndex(componentIndex);
      map<int, double>::const_iterator iData = fEyeOnTimeFraction.find(eyeId);
      if (iData == fEyeOnTimeFraction.end()) {
        INFO_TERSE("Requested property of FdUpTimeSQLManager not available!");
        return VManager::eNotFound;
      }

      returnData = iData->second;
      return VManager::eFound;
    }


    if (componentName=="CDAS") {

      returnData = fCDASOnTimeFraction;
      return VManager::eFound;
    }
  }

  return VManager::eNotFound;
}



int FdUpTimeSQLManager::GetEyeIndex(const IndexMap& componentIndex) const {

  IndexMap::const_iterator iEyeId;
  iEyeId = componentIndex.find("eyeId");
  if (iEyeId == componentIndex.end()) {

    INFO_TERSE("Called FdUpTimeSQLManager with wrong number of arguments!");
    return -1;
  }

  int eyeId;
  istringstream ssEyeId(iEyeId->second);
  ssEyeId >> eyeId;

  return eyeId;
}


int FdUpTimeSQLManager::GetTelIndex(const IndexMap& componentIndex) const {

  IndexMap::const_iterator iEyeId, iTelId;
  iEyeId = componentIndex.find("eyeId");
  iTelId = componentIndex.find("telescopeId");
  if (iEyeId == componentIndex.end() ||
      iTelId == componentIndex.end()) {

    INFO_TERSE("Called FdUpTimeSQLManager with wrong number of arguments!");
    return -1;
  }

  int eyeId, telId;
  istringstream ssEyeId(iEyeId->second);
  ssEyeId >> eyeId;
  istringstream ssTelId(iTelId->second);
  ssTelId >> telId;
  int dataId = (eyeId-1) * 6 + telId;

  return dataId;
}

int FdUpTimeSQLManager::GetChannelIndex(const IndexMap& componentIndex) const {

  IndexMap::const_iterator iChannelId;
  iChannelId = componentIndex.find("channelId");
  if (iChannelId == componentIndex.end()) {
    INFO_TERSE("Called FdUpTimeSQLManager with wrong number of arguments!");
    return -1;
  }

  int channelId;
  istringstream ssChannelId(iChannelId->second);
  ssChannelId >> channelId;

  return channelId;
}



VManager::Status
FdUpTimeSQLManager::GetChannelData(double& returnData,
                                    const std::string& componentProperty,
                                    const std::string&,
                                    const IndexMap& componentIndex)
  const
{
  // index is linear --> ((eyeId-1) * 6 + telId) * 440 + channelId;
  //  int dataId = GetChannelIndex(componentIndex);

  if (fVerbosity>2) {
    ostringstream info;
    info << "called GetChannelData with componentProperty=" << componentProperty << " and index map: \n" ;
    for (IndexMap::const_iterator imap = componentIndex.begin();
         imap!=componentIndex.end(); imap++) {
      info << " index=\"" << imap->first << "\" -> \"" << imap->second << "\"\n";
    }
    INFO(info);
  }

  int dataId = GetTelIndex(componentIndex);
  int channelId = GetChannelIndex(componentIndex);

  if (fVerbosity>2) {
    ostringstream info;
    info << " (eye/tel) dataId=" << dataId << " channelId=" << channelId
         << " fChannelInfo.size()=" << fChannelInfo.size() << " # tels " <<  endl;
    INFO(info);
  }

  map<int, vector<ChannelInfo > >::const_iterator iData = fChannelInfo.find(dataId);
  if (iData == fChannelInfo.end()) {
    INFO_TERSE("Requested property of FdUpTimeSQLManager not available!");
    return VManager::eNotFound;
  }

  const vector<ChannelInfo>& info = iData->second;

  if (fVerbosity>2) {
    cout << " channel vector size=" << info.size() << endl;
  }

  channelId -= 1; // index starts at 0
  returnData = 0;
  if( (unsigned int)channelId < info.size() ) {

    if (componentProperty=="ADCVariance") returnData = info[channelId].Variance;
    else if (componentProperty=="Threshold") returnData = info[channelId].Threshold;
    else if (componentProperty=="Baseline") returnData = info[channelId].Baseline;
    else return VManager::eNotFound;
  }

  if (fVerbosity>2) {
    cout << " VAR=" << returnData << endl;
  }

  return VManager::eFound;

}





 bool FdUpTimeSQLManager::ReadData() const {


  if (fVerbosity>2) {
    INFO("enter ReadData ");
  }

  if (fDataValidity.IsValid()) {
    if (fVerbosity>2) {
      INFO("Data is still valid ");
    }
    return true;
  }

  unsigned int now = det::Detector::GetInstance().GetTime().GetGPSSecond();

  // really get the data from the TTree
  fEyeOnTimeFraction.clear();
  fTelescopeOnTimeFraction.clear();
  fEyeStatus.clear();
  fTelescopeStatus.clear();
  fCDASStatus=0;
  fCDASOnTimeFraction=0.;
  fChannelInfo.clear();


  bool foundit = true;

  ostringstream query;
  query << "SELECT * FROM UptimeTelescope as a, UptimeBin as b WHERE b.GPSStart >= " << now << " AND b.GPSStop < " << now;

  //Query(query);



 //  eNotFound : FetchRow(returnData

//   MYSQL *connMonit = mysql_init(NULL);
//   if (!mysql_real_connect(connMonit, server,
//                        user, password,dbnames[4], 0, NULL, 0)) {
//     fprintf(stderr, "%s\n", mysql_error(connMonit));
//     exit(0);
//   }

//   ostringstream query;
//   query << "SELECT * FROM upTimes WHERE " << "uptime_start_time <= \"" << now << "\" AND " << "uptime_end_time > \"" << now << "\"";

//   if (fVerbosity>2) cout << "Query:\t" << query << endl;
     
//   if ( mysql_query(conn[ieye], queryFirst) ) {
//      if (verbose) cout << "Error with query:\t" << queryFirst << endl;
//       } else {
//      totRes = mysql_store_result(conn[ieye]); 
//      if ( ! mysql_num_rows(totRes) )
//        if (verbose) {
//          cout << "Warning: query returned empty result \t" << queryFirst << endl; 
//          lastTime[currt] = start + TIMEWINDOW;
//        }

//      while ((dtRow = mysql_fetch_row(totRes)) != NULL) {
          
//        countme++;
          

//        lastDT[currt] = atof(dtRow[0]);
//        lastRun[currt] = atoi(dtRow[1]);
//        lastVeto[currt] = atof(dtRow[4]);



//     TSQLResult *result = fDataTree->Query(query.str().c_str());
//     if (result->GetRowCount()) {
//     INFO_TERSE("FdUpTimeSQLManager cannot identify row");
//     }

//     TSQLRow *row = result->Next();


//     row





//     for (int iEye=1; iEye<=5; iEye++) {

//       int nTel = 6;
//       if (iEye==5) nTel = 3;

//       for (int iTel=1; iTel<=nTel; iTel++) {

//         int telIndex = (iEye-1)*6 + iTel;

//         fTelescopeOnTimeFraction[telIndex] = tel_up_time_fraction[telIndex-1];
//         fTelescopeStatus[telIndex] = tel_status[telIndex-1];

//         fChannelInfo[telIndex].clear();
//         for(unsigned int channel=0; channel<kNPixelPerTel; channel++) {
//           fChannelInfo[telIndex].push_back(ChannelInfo(channel_var[telIndex-1][channel], // VAR
//                                                        channel_threshold[telIndex-1][channel],  // threshold
//                                                        channel_baseline[telIndex-1][channel])); // baseline
//         }
//       }

//       fEyeStatus[iEye] = eye_status[iEye-1];
//       fEyeOnTimeFraction[iEye] = eye_up_time_fraction[iEye-1];
//     }

//     fCDASStatus=CDAS_status;
//     fCDASOnTimeFraction=CDAS_up_time_fraction;

//     fDataValidity.SetValidityInterval(TimeStamp(time_start), TimeStamp(time_stop));

//   }

//   if (fVerbosity>2) {
//     cout << " ReadData result is valid from start: "
//          << fDataValidity.GetStartTime().GetGPSSecond()
//          << " end: " << fDataValidity.GetStopTime().GetGPSSecond()
//          << endl;
//   }


  return foundit;

//   /*
//   */
 }

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