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

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

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

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


REGISTER_F_MANAGER("FdUpTimeFileManager", FdUpTimeFileManager);


const double FdUpTimeFileManager::fgSearchMapBinning = 10000; // .*s; // [s]


UpTimePeriod::UpTimePeriod(TFile* const file)
{
  fRootFilePtr = file;
  if (fRootFilePtr) {
    fDataTree = (TTree*)(fRootFilePtr->Get("AugerUpTime"));
    if (fDataTree) {
      TBranch* const startB = fDataTree->GetBranch("uptime_gpsStart");
      startB->SetAddress(&fGpsStart);
      startB->GetEntry(0);
      TBranch* const stopB = fDataTree->GetBranch("uptime_gpsStop");
      stopB->SetAddress(&fGpsStop);
      stopB->GetEntry(stopB->GetEntries() - 1);

      fHeaderTree = (TTree*)(fRootFilePtr->Get("Header"));
      if (fHeaderTree) {
        TBranch* const UpTimeVerB = fHeaderTree->GetBranch("SoftwareVersion");
        UpTimeVerB->SetAddress(&fFileVersion);
        UpTimeVerB->GetEntry(0);
      } else
        fFileVersion = 0;
    } else {
      ostringstream err;
      err << " FdUpTimeFileManager input file=" << file->GetName()
          << " is corrupt! Up times will not be available!";
      ERROR(err);
      fRootFilePtr = nullptr;
    }
  }
}


bool
UpTimePeriodSortFunction(const UpTimePeriod& first, const UpTimePeriod& second)
{
  return first < second;
}


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

  fVerbosity = 0;

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

  const SaveCurrentTDirectory save;
  for (fRootFileIterator = fFileList.begin(); fRootFileIterator != fFileList.end(); ++fRootFileIterator) {
    UpTimePeriod rootUpTime;
    TFile* const rootFile = TFile::Open(fRootFileIterator->c_str(), "READ");
    if (!rootFile || rootFile->IsZombie()) {
      ostringstream err;
      err << fRootFileIterator->c_str()
          << " is an UpTime file corrupted or inexistent!";
      ERROR(err);
      continue;
    } else {
      rootUpTime = UpTimePeriod(rootFile);
      if (rootUpTime.fRootFilePtr)
        fUpTimeVector.push_back(rootUpTime);
    }
  }

  if (fUpTimeVector.size() != fFileList.size()) {
    ostringstream err;
    err << "UpTime file(s) unavailable!";
    ERROR(err);
    throw IOFailureException(err.str());
  }
  if (fFileList.empty())
    WARNING("EMPTY FILE LIST!");
  Initialize();
}


void
FdUpTimeFileManager::Initialize()
{
  ostringstream msg;
  msg << "Initializing FdUpTimeFileManager index map ...";
  auto verbosityB = fBranch.GetChild("verbosity");
  if (verbosityB) {
    verbosityB.GetData(fVerbosity);
    msg << "\n\tverbosity level: " << fVerbosity;
  }
  INFO(msg);

  // 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("veto_fraction");  // for eye
  fAvailableComponents.insert("ADCVariance");  // for channel
  fAvailableComponents.insert("Threshold");  // for channel
  fAvailableComponents.insert("Baseline");  // for channel

  // build index
  sort(fUpTimeVector.begin(), fUpTimeVector.end(), UpTimePeriodSortFunction);
  for (fUpTimeVectorIterator = fUpTimeVector.begin(); fUpTimeVectorIterator != fUpTimeVector.end(); ++fUpTimeVectorIterator) {

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

    for (unsigned int i = 0; i < (unsigned int)startB->GetEntries(); ++i) {

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

      unsigned int bin1 = (unsigned int)(gpsStart / fgSearchMapBinning);
      unsigned int bin2 = (unsigned int)(gpsStop  / fgSearchMapBinning);

      vector<unsigned int> iCurr;
      iCurr.push_back(bin1);
      if (bin1 != bin2)
        iCurr.push_back(bin2);

      Index& refIndex = fUpTimeVectorIterator->fFileVersion ? fIndexHeadered : fIndexUnheadered;

      for (unsigned int j = 0; j < iCurr.size(); ++j) {
        if (refIndex.find(iCurr[j]) == refIndex.end() || refIndex[iCurr[j]].back().second.fRootFilePtr != fUpTimeVectorIterator->fRootFilePtr)
          refIndex[iCurr[j]].push_back(make_pair(make_pair(i, i), *fUpTimeVectorIterator));
        else {  // change bounds
          if (i < refIndex[iCurr[j]].back().first.first)
            refIndex[iCurr[j]].back().first.first = i;
          if (i > refIndex[iCurr[j]].back().first.second)
            refIndex[iCurr[j]].back().first.second = i;
        }
      }
    }
  }

  if (fVerbosity > 3) {
    for (int j = 0; j < 2; ++j) {
      Index& verbRefIndex = !j ? fIndexHeadered : fIndexUnheadered;
      cerr << "\t == " << (!j ? "Headered" : "Unheadered") << " files ==\n";
      for (auto iIndex = verbRefIndex.begin(); iIndex != verbRefIndex.end(); ++iIndex) {
        cerr << " => index-maxp-entry: bin=" << iIndex->first << ":\n";
        for (auto iVector = iIndex->second.begin(); iVector != iIndex->second.end(); ++iVector)
          cerr << "\tstart=" << iVector->first.first
               << " stop="   << iVector->first.second
               << " TFile="  << iVector->second.fRootFilePtr->GetName() << '\n';
      }
    }
  }
}


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

  if (!fUpTimeVector.size())
    return VManager::eNotFound;

  if (!ReadData())
    return VManager::eNotFound;

  if (componentProperty == "has_fduptime") {
    returnData = 1;//0xff;//cout << returnData << endl;
    return VManager::eFound;
  }

  if (componentProperty == "uptime_gpsStart") {
    returnData = fDataValidity.GetStartTime().GetGPSSecond();
    return VManager::eFound;
  } else if (componentProperty == "uptime_gpsStop") {
    returnData = fDataValidity.GetStopTime().GetGPSSecond();
    return VManager::eFound;
  }

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

  if (componentProperty == "status") {

    if (componentName == "telescope") {

      const int dataId = GetTelIndex(componentIndex);
      const auto iData = fTelescopeStatus.find(dataId);
      if (iData == fTelescopeStatus.end()) {
        INFO_TERSE("Requested property of FdUpTimeFileManager not available!");
        return VManager::eNotFound;
      }

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

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

      const int eyeId = GetEyeIndex(componentIndex);

      if (fVerbosity > 2) {
        ostringstream info;
        info << " eyeIndex=" << eyeId;
        for (auto iI = fEyeStatus.begin(); iI != fEyeStatus.end(); ++iI) {
          info << "\n eyeStatus[" << iI->first << "] = "
               << iI->second;
        }
        INFO(info);
      }

      const auto iData = fEyeStatus.find(eyeId);
      if (iData == fEyeStatus.end()) {
        INFO_TERSE("Requested property of FdUpTimeFileManager not available!");
        return VManager::eNotFound;
      }

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

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

      returnData = fCDASStatus;
      return VManager::eFound;

    }
  }

  return VManager::eNotFound;
}


VManager::Status
FdUpTimeFileManager::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;

   // check if data available
  if (!fUpTimeVector.size())
    return VManager::eNotFound;

  if (!ReadData())
    return VManager::eNotFound;

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

  if (componentProperty == "has_fduptime") {
    returnData = 1;//0xff;// cout << returnData;
    return VManager::eFound;
  }
  if (componentName == "channel") {
    // channel property
    return GetChannelData(returnData, componentProperty, componentName, componentIndex);
  } else if (componentProperty == "veto_fraction") {
    if (componentName == "eye" || componentName == "CDAS")
      return GetVetoFraction(returnData, componentProperty, componentName, componentIndex);
  } else if (componentName == "telescope" || componentName == "eye" || componentName == "CDAS") {
    // eye, tel, cdas property
    return GetUpTimeFraction(returnData, componentProperty, componentName, componentIndex);
  }

  return VManager::eNotFound;
}


VManager::Status
FdUpTimeFileManager::GetUpTimeFraction(double& returnData,
                                       const std::string& componentProperty,
                                       const std::string& componentName,
                                       const IndexMap& componentIndex)
  const
{
  // check if data available
  if (!fUpTimeVector.size())
    return VManager::eNotFound;

  if (!ReadData())
    return VManager::eNotFound;

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

  if (componentProperty == "uptime_fraction") {

    if (componentName == "telescope") {

      int dataId = GetTelIndex(componentIndex);
      auto iData = fTelescopeUpTimeFraction.find(dataId);
      if (iData == fTelescopeUpTimeFraction.end()) {
        INFO_TERSE("Requested property of FdUpTimeFileManager not available!");
        return VManager::eNotFound;
      }

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

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

      int eyeId = GetEyeIndex(componentIndex);
      auto iData = fEyeUpTimeFraction.find(eyeId);
      if (iData == fEyeUpTimeFraction.end()) {
        INFO_TERSE("Requested property of FdUpTimeFileManager not available!");
        return VManager::eNotFound;
      }

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

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

      returnData = fCDASUpTimeFraction;
      return VManager::eFound;

    }

  }

  return VManager::eNotFound;
}


VManager::Status
FdUpTimeFileManager::GetVetoFraction(double& returnData,
                                     const std::string& componentProperty,
                                     const std::string& componentName,
                                     const IndexMap& componentIndex)
  const
{
  // check if data available
  if (!fUpTimeVector.size())
    return VManager::eNotFound;

  if (!ReadData())
    return VManager::eNotFound;

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

  if (componentProperty == "veto_fraction") {

     if (componentName == "eye") {

      int eyeId = GetEyeIndex(componentIndex);
      const auto iData = fFDASVetoFraction.find(eyeId);
      if (iData == fFDASVetoFraction.end()) {
        INFO_TERSE("Requested property of FdUpTimeFileManager not available!");
        return VManager::eNotFound;
      }

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

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

      int eyeId = GetEyeIndex(componentIndex);
      const auto iDataSD = fCDASVetoFraction.find(eyeId);
      if (iDataSD == fCDASVetoFraction.end()) {
        INFO_TERSE("Requested property of FdUpTimeFileManager not available!");
        return VManager::eNotFound;
      }

      returnData = iDataSD->second;
      return VManager::eFound;

    }

  }

  return VManager::eNotFound;
}


int
FdUpTimeFileManager::GetEyeIndex(const IndexMap& componentIndex)
  const
{
  const auto iEyeId = componentIndex.find("eyeId");
  if (iEyeId == componentIndex.end()) {
    cerr << "WRONG iEyeId = " << iEyeId->second << '\n';
    INFO_TERSE("Called FdUpTimeFileManager with wrong number of arguments!");
    return -1;
  }

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


int
FdUpTimeFileManager::GetTelIndex(const IndexMap& componentIndex)
  const
{
  const auto iEyeId = componentIndex.find("eyeId");
  const auto iTelId = componentIndex.find("telescopeId");
  if (iEyeId == componentIndex.end() || iTelId == componentIndex.end()) {
    INFO_TERSE("Called FdUpTimeFileManager with wrong number of arguments!");
    return -1;
  }

  const auto eyeId = boost::lexical_cast<int>(iEyeId->second);
  const auto telId = boost::lexical_cast<int>(iTelId->second);
  const int dataId = 6 * (eyeId - 1) + telId;
  return dataId;
}


int
FdUpTimeFileManager::GetChannelIndex(const IndexMap& componentIndex)
  const
{
  const auto iChannelId = componentIndex.find("channelId");
  if (iChannelId == componentIndex.end()) {
    INFO_TERSE("Called FdUpTimeFileManager with wrong number of arguments!");
    return -1;
  }

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


VManager::Status
FdUpTimeFileManager::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:";
    for (auto imap = componentIndex.begin(); imap != componentIndex.end(); ++imap) {
      info << "\n index=\"" << imap->first << "\" -> \"" << imap->second << '"';
    }
    INFO(info);
  }

  const 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";
    INFO(info);
  }

  const auto iData = fChannelInfo.find(dataId);
  if (iData == fChannelInfo.end()) {
    INFO_TERSE("Requested property of FdUpTimeFileManager not available!");
    return VManager::eNotFound;
  }

  const auto& info = iData->second;

  if (fVerbosity > 2)
    cerr << " channel vector size=" << info.size() << '\n';

  channelId -= 1; // index starts at 0
  returnData = 0;
  if ((unsigned int)(channelId) < info.size()) {
    if (componentProperty == "ADCVariance")
      returnData = info[channelId].fVariance;
    else if (componentProperty == "Threshold")
      returnData = info[channelId].fThreshold;
    else if (componentProperty == "Baseline")
      returnData = info[channelId].fBaseline;
    else
      return VManager::eNotFound;
  }

  if (fVerbosity > 2)
    cerr << " VAR=" << returnData << '\n';

  return VManager::eFound;
}


bool
FdUpTimeFileManager::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
  fEyeUpTimeFraction.clear();
  fFDASVetoFraction.clear();
  fTelescopeUpTimeFraction.clear();
  fEyeStatus.clear();
  fTelescopeStatus.clear();
  fCDASStatus = 0;
  fCDASUpTimeFraction = 0.;
  fCDASVetoFraction.clear();
  fChannelInfo.clear();

    // using the index map to get first bounds ...
  unsigned int iBin = (unsigned int)(now / fgSearchMapBinning);
  const ConstIndexIterator iIndex[2] = { fIndexHeadered.find(iBin), fIndexUnheadered.find(iBin) };

  if (iIndex[0] == fIndexHeadered.end() && iIndex[1] == fIndexUnheadered.end())
    return false;

  unsigned int lower = 0;
  unsigned int upper = 0;
  string fileName;
  bool foundLimits = false;
  TTree* actualDataTree = nullptr;
  double upTimeVer = 0;

  for (int j = 0; j < 2; ++j) {

    if (iIndex[j] == (!j ? fIndexHeadered.end() : fIndexUnheadered.end()))
      continue;

    for (auto iVector = iIndex[j]->second.begin(); iVector != iIndex[j]->second.end(); ++iVector) {
      if (iVector->second.fGpsStart <= now && now < iVector->second.fGpsStop) {
        lower = iVector->first.first;
        upper = iVector->first.second;
        fileName = iVector->second.fRootFilePtr->GetName();
        actualDataTree = iVector->second.fDataTree;
        upTimeVer = iVector->second.fFileVersion;
        foundLimits = true;
        break;
      }
    }
    if (foundLimits)
      break;
  }
  if (!foundLimits)
    return false;

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

  // start looking into TTree
  TBranch* const startB = actualDataTree->GetBranch("uptime_gpsStart");
  UInt_t gpsStart = 0;
  startB->SetAddress(&gpsStart);
  TBranch* const stopB = actualDataTree->GetBranch("uptime_gpsStop");
  UInt_t gpsStop = 0;
  stopB->SetAddress(&gpsStop);

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

    index = lower + (upper - lower)/2;
    startB->GetEntry(index);
    stopB->GetEntry(index);

    if (gpsStart <= now && now < gpsStop) {
      foundit = true;
    } else {
      if (now < gpsStart)
        upper = index - 1;
      else
        lower = index + 1;
    }
    ++nSearch;

    if (fVerbosity > 2) {
      cerr << " search loop: nSearch=" << nSearch
           << " gpsStart=" << gpsStart
           << " gpsStop=" << gpsStop
           << " foundit=" << foundit
           << " index=" << index << '\n';
    }

  }

  if (fVerbosity > 2) {
    cerr << " END search loop: "
         << " index=" << index << '\n';
  }

  if (foundit) {
    Double_t tel_up_time_fraction[27] = { 0 };
    UInt_t tel_status[27] = { 0 };
    Double_t eye_up_time_fraction[5] = { 0 };
    UInt_t eye_status[5] = { 0 };
    Double_t cDAS_up_time_fraction = 0;
    Double_t fDAS_veto_fraction[5] = { 0 };
    Double_t cDAS_conn_fraction[5] = { 0 };
    Double_t cDAS_veto_fraction[5] = { 0 };
    UInt_t cDAS_status = 0;
    UInt_t time_start = 0;
    UInt_t time_stop = 0;
    UShort_t channel_var[27][kNPixelPerTel] = { { 0 } };
    UShort_t channel_threshold[27][kNPixelPerTel] = { { 0 } };
    UShort_t channel_baseline[27][kNPixelPerTel] = { { 0 } };

    actualDataTree->SetBranchAddress("uptime_gpsStart", &time_start);
    actualDataTree->SetBranchAddress("uptime_gpsStop", &time_stop);
    actualDataTree->SetBranchAddress("TelescopeUpFraction", &tel_up_time_fraction);
    actualDataTree->SetBranchAddress("EyeUpFraction", &eye_up_time_fraction);
    if (fVerbosity > 2)
      cerr << "UpTimeFile Version is " << upTimeVer << '\n';
    if (upTimeVer < 3) {
      actualDataTree->SetBranchAddress("TelescopeStatus", &tel_status);
      actualDataTree->SetBranchAddress("EyeStatus",eye_status);
      actualDataTree->SetBranchAddress("CDASUpFraction", &cDAS_up_time_fraction);
    } else {
      actualDataTree->SetBranchAddress("FDASVetoFraction", &fDAS_veto_fraction);
      actualDataTree->SetBranchAddress("CDASConnFraction", &cDAS_conn_fraction);
      actualDataTree->SetBranchAddress("CDASVetoFraction", &cDAS_veto_fraction);
    }
    actualDataTree->SetBranchAddress("CDASStatus", &cDAS_status);
    actualDataTree->SetBranchAddress("ADCVariance", &channel_var);
    actualDataTree->SetBranchAddress("ADCThreshold", &channel_threshold);
    actualDataTree->SetBranchAddress("ADCBaseline", &channel_baseline);

    actualDataTree->GetEntry(index);

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

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

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

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

        fTelescopeUpTimeFraction[telIndex] = tel_up_time_fraction[telIndex1];
        if (upTimeVer < 3)
          fTelescopeStatus[telIndex] = tel_status[telIndex1];
        else if (fTelescopeUpTimeFraction[telIndex] > 0)
          fTelescopeStatus[telIndex] = 1;
        else
          fTelescopeStatus[telIndex] = 0;
        fChannelInfo[telIndex].clear();
        for (unsigned int channel = 0; channel < kNPixelPerTel; ++channel) {
          fChannelInfo[telIndex].push_back(
            ChannelInfo(
              channel_var[telIndex1][channel],  // VAR
              channel_threshold[telIndex1][channel],  // threshold
              channel_baseline[telIndex1][channel]  // baseline
            )
          );
        }
      }

      const int iEye1 = iEye - 1;
      if (upTimeVer < 3) {
        fEyeStatus[iEye] = eye_status[iEye1];
        fEyeUpTimeFraction[iEye] = eye_up_time_fraction[iEye1];
        fFDASVetoFraction[iEye] = 1;
        fCDASVetoFraction[iEye] = 1;
      } else {
        fFDASVetoFraction[iEye] = fDAS_veto_fraction[iEye1];
        fEyeUpTimeFraction[iEye] = eye_up_time_fraction[iEye1];
        if (fEyeUpTimeFraction[iEye] > 0)
          fEyeStatus[iEye] = 1;
        fCDASVetoFraction[iEye] = cDAS_veto_fraction[iEye1];
      }

    } // end for eye

    fCDASStatus = cDAS_status;

    if (upTimeVer < 3)
      fCDASUpTimeFraction = cDAS_up_time_fraction;
    else
      fCDASUpTimeFraction = 1;

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

  }

  if (fVerbosity > 2) {
    cerr << " ReadData result is valid from start: "
         << fDataValidity.GetStartTime().GetGPSSecond()
         << " end: " << fDataValidity.GetStopTime().GetGPSSecond() << '\n';
  }

  return foundit;
}