T2LifeROOTFileManager.cc

Go to the documentation of this file.

#include <utl/Reader.h>
#include <utl/TimeStamp.h>
#include <utl/ErrorLogger.h>
#include <utl/SaveCurrentTDirectory.h>

#include <fwk/CentralConfig.h>

#include <det/Detector.h>
#include <det/ValidityStamp.h>

#include <sdet/T2LifeROOTFileManager.h>

#include <boost/lexical_cast.hpp>

#include <TFile.h>
#include <TTree.h>
#include <TBits.h>

#include <sstream>
#include <string>
#include <set>
#include <map>
#include <utility>
#include <algorithm>
#include <iomanip>

using namespace fwk;
using namespace det;
using namespace sdet;
using namespace utl;
using namespace std;


REGISTER_S_MANAGER("T2LifeROOTFileManager", T2LifeROOTFileManager);


const double T2LifeROOTFileManager::fgSearchMapBinning = 10000; //s


void
T2LifeROOTFileManager::Init(const std::string& configLink)
{
  VManager::Init(configLink);

  // ************************ DEBUG **************************************************
  fVerbosity = 0;
  if (fBranch.GetChild("verbosity")) {
    fBranch.GetChild("verbosity").GetData(fVerbosity);
    cout << " T2LifeROOTFileManager verbosity level = " << fVerbosity << endl;
  }
  // **********************************************************************************

  fBranch.GetChild("file").GetData(fFileName);

  const SaveCurrentTDirectory save;
  TFile* file = TFile::Open(fFileName.c_str(), "READ");
  if (!file || file->IsZombie()) {
    ostringstream err;
    err << " T2LifeROOTFileManager input file=" << fFileName
        << " is corrupt! Up times will not be available!" << endl;
    INFO_TERSE(err);
    file = 0;
    fDataTree = 0;
  } else
    fDataTree = (TTree*)(file->Get("T2Life"));

  if (fDataTree) {

    // list of properties for telescope
    fAvailableComponents.insert("station_in_acquisition");

    // create index map for fast lookup
    TBranch* const startB = fDataTree->GetBranch("gpsStart");
    TBranch* const endB = fDataTree->GetBranch("gpsStop");
    UInt_t gpsStart = 0;
    UInt_t gpsEnd = 0;
    startB->SetAddress(&gpsStart);
    endB->SetAddress(&gpsEnd);

    INFO_TERSE("initializing T2LifeROOTFileManager index map ... ");
    int nT2bullshit = 0;
    for (unsigned int i = 0; i < (unsigned int)startB->GetEntries(); ++i) {

      startB->GetEntry(i);
      endB->GetEntry(i);

      unsigned int index_start = (unsigned int)(gpsStart / fgSearchMapBinning);
      unsigned int index_end = (unsigned int)(gpsEnd / fgSearchMapBinning);

      if (gpsStart < 756950400 || gpsEnd < 756950400) {

        // ************************ DEBUG **************************************************
        if (fVerbosity >= 3) {
          ostringstream warn;
          warn << " removing broken T2 period: start=" << gpsStart
               << " end=" << gpsEnd;
          WARNING(warn.str());
        }
        // **********************************************************************************

        ++nT2bullshit;
        continue;
      }

      if (gpsStart > gpsEnd) {
        // ************************ DEBUG **************************************************
        if (fVerbosity >= 3) {
          cout << " strange T2 period: start=" << gpsStart
               << " end=" << gpsEnd
               << endl;
        }
        // **********************************************************************************
      }
      vector<unsigned int> iCurr;
      if (index_end == index_start) {
        iCurr.push_back(index_end);
      } else {
        for (unsigned int iIndex = min(index_start, index_end);
             iIndex <= max(index_start, index_end); ++iIndex) {
          iCurr.push_back(iIndex);
        }
      }

      for (unsigned int j = 0; j < iCurr.size(); ++j) {

        int iIndex = iCurr[j];

        if (fIndex.find(iIndex) == fIndex.end()) {

          fIndex[iIndex] = make_pair(i, i);

        } else { // change bounds

          if (i < fIndex[iIndex].first)
            fIndex[iIndex].first = i;

          if (i > fIndex[iIndex].second)
            fIndex[iIndex].second = i;

        }
      }
    }

    // ************************ DEBUG **************************************************
    if (fVerbosity > 3) {
      cout << " row of T2 files with wrong gps times: " << nT2bullshit << endl;
      for (IndexIterator iIndex = fIndex.begin();
           iIndex != fIndex.end(); ++iIndex) {
        cout << " index-maxp-entry: bin=" << iIndex->first
             << " start=" << iIndex->second.first
             << " end=" << iIndex->second.second << endl;
      }
    }
    // **********************************************************************************

  }

  ostringstream info;
  info << "using T2 ROOT file: " << fFileName;
  INFO(info);
}


VManager::Status
T2LifeROOTFileManager::GetOkFlag(int& returnData,
                                 const std::string& componentProperty,
                                 const std::string& componentName,
                                 const IndexMap& componentIndex)
  const
{
  if (!fDataTree ||
      fAvailableComponents.find(componentProperty)==fAvailableComponents.end()) {
    return VManager::eNotFound;
  }

  if (!ReadData()) {
    ostringstream warn;
    warn << "*****************************************************\n"
            " property=" << componentProperty << " component=" << componentName
         << " index=(";
    for (IndexMap::const_iterator imap = componentIndex.begin();
         imap != componentIndex.end(); ++imap) {
      warn << "\"" << imap->first << "\"=\"" << imap->second << "\" ";
    }
    warn << ")  NOT found in data source for specified time!\n"
            "Returning zero \n"
            "*****************************************************";
    WARNING(warn);
    returnData = 0;
    return VManager::eFound;
  }

  // ************************ DEBUG **************************************************
  if (fVerbosity > 2) {
    cout << "called GetOkFlag for componentName=" << componentName
         << " componentProperty=" << componentProperty << " and index map:\n";
    for (IndexMap::const_iterator imap = componentIndex.begin();
         imap != componentIndex.end(); ++imap) {
      cout << " index=\"" << imap->first << "\" -> \"" << imap->second << "\"\n";
    }
  }
  // **********************************************************************************

  if (componentProperty == "station_in_acquisition") {

    if (componentName == "is_in_acquisition") {

      int dataId = GetStationIndex(componentIndex);
      //dataId++;

      // ************************ DEBUG **************************************************
      if (fVerbosity > 2)
        cout << " no stations=" << fStationList.size() << " id=" << dataId << endl;
      // **********************************************************************************

      returnData = 0;
      if( (unsigned int)dataId < fStationList.size())
        returnData = fStationList[dataId];

      // ************************ DEBUG **************************************************
      if (fVerbosity > 2)
        cout << " IsInDAQ=" << returnData << endl;
      // **********************************************************************************

      return VManager::eFound;

    }
  }

  return VManager::eNotFound;
}


bool
T2LifeROOTFileManager::ReadData()
  const
{
  // ************************ DEBUG **************************************************
  if (fVerbosity > 2)
    INFO( " enter ReadData ");
  // **********************************************************************************

  if (fDataValidity.IsValid()) {
    // ************************ DEBUG **************************************************
    if (fVerbosity > 2)
      INFO (" T2 data still valid ");
    // **********************************************************************************
    return true;
  }

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

  // really get the data from the TTree
  fStationList.clear();

  // using the index map to get first bounds ...
  unsigned int iBin = (unsigned int)(now / fgSearchMapBinning);

  ConstIndexIterator iIndex = fIndex.find(iBin);
  if (iIndex == fIndex.end()) {
    ostringstream err;
    err << "Index not found! now/gps=" << now << ", iBin=" << iBin;
    ERROR(err);
    return false;
  }

  unsigned int lower = iIndex->second.first;
  unsigned int upper = iIndex->second.second;

  // ************************ DEBUG **************************************************
  if (fVerbosity > 2) {
    ostringstream info;
    info << " index: now=" << now
         << " index=" << iBin
         << " lower=" << lower
         << " upper=" << upper;
    INFO(info);
  }
  // **********************************************************************************

  // start looking into TTree

  TBranch* const startB = fDataTree->GetBranch("gpsStart");
  TBranch* const endB = fDataTree->GetBranch("gpsStop");
  UInt_t gpsStart = 0;
  UInt_t gpsEnd = 0;
  startB->SetAddress(&gpsStart);
  endB->SetAddress(&gpsEnd);

  int nSearch = 0;
  int index = 0 ;
  bool foundit = false;
  while (!foundit && upper >= lower) {

    index = lower + (upper - lower)/2; // binary search !

    startB->GetEntry(index);
    endB->GetEntry(index);

    if (now >= gpsStart && now < gpsEnd) { // found entry ?

      foundit = true;

    } else { // not yet found right entry -> new seach boundaries

      if (now < gpsStart)
        upper = index - 1;
      else           
        lower = index + 1;
    }

    ++nSearch;

    // ************************ DEBUG **************************************************
    if (fVerbosity > 3) {
      cout << " search loop: nSearch=" << nSearch
           << " gpsStart=" << gpsStart
           << " gpsEnd=" << gpsEnd
           << " foundit=" << foundit
           << " index=" << index
           << endl;
    }
    // **********************************************************************************

  }

  // ************************ DEBUG **************************************************
  if (fVerbosity > 2) {
    cout << " END search loop: "
         << " foundit=" << foundit
         << " index=" << index
         << endl;
  }
  // **********************************************************************************

  if (foundit) {

    UInt_t time_start = 0;
    UInt_t time_stop = 0;
    TBits* stationBits = new TBits();

    fDataTree->SetBranchAddress("gpsStart", &time_start);
    fDataTree->SetBranchAddress("gpsStop", &time_stop);
    fDataTree->SetBranchAddress("stationArray", &stationBits);

    fDataTree->GetEntry(index);

    const unsigned int nStations = stationBits->GetNbits();

    // station-index is the 'stationId'
    fStationList.resize(nStations + 1);
    for (unsigned int iStation = 1; iStation <= nStations; ++iStation) {

      if (stationBits->TestBitNumber(iStation))
        fStationList[iStation] = 1;
      else
        fStationList[iStation] = 0;

    }

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

    delete stationBits;
  }

  // ************************ DEBUG **************************************************
  if (fVerbosity > 2) {
    cout << " ReadData result is valid from start: " << fDataValidity.GetStartTime().GetGPSSecond()
         << " end: " << fDataValidity.GetStopTime().GetGPSSecond()
         << endl;
    if (fVerbosity > 4) {
      cout << " Stations UP:\n";
      int n = 0;
      for (unsigned int i = 0; i<fStationList.size(); ++i) {
        if (fStationList[i]) {
          ++n;
          if (n > 1)
            cout << ", ";
          cout << setw(4) << i;
        }
        if (n == 25) {
          n = 0;
          cout << "\n";
        }
      }
      cout << "\n";
    }
  }
  // **********************************************************************************

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

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

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


int
T2LifeROOTFileManager::GetStationIndex(const IndexMap& componentIndex)
  const
{
  IndexMap::const_iterator iStationId = componentIndex.find("stationId");
  if (iStationId == componentIndex.end()) {
    INFO_TERSE("Called T2LifeROOTFileManager with wrong number of arguments!");
    return -1;
  }

  return boost::lexical_cast<int>(iStationId->second);
}