T2StatFileManager.cc

Go to the documentation of this file.

#include "T2StatFileManager.h"

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

#include <fwk/CentralConfig.h>

#include <sstream>

#include <TChain.h>
#include <TDirectory.h>
#include <TFile.h>
#include <TEventList.h>

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


REGISTER_S_MANAGER("T2StatFileManager", T2StatFileManager);


T2StatFileManager::~T2StatFileManager()
{
  delete fDataTree;
  delete fDir;
}


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

  INFO_TERSE("Initializing T2StatFileManager ... ");

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

  fCommsCrisis = 0;
  if (fBranch.GetChild("CommsCrisisTreat")) {
    fBranch.GetChild("CommsCrisisTreat").GetData(fCommsCrisis);
  }

  if (fVerbosity)
    cout << " Comms-Crisis Treatment = " << fCommsCrisis << endl;

  fBranch.GetChild("files").GetData(fAllT2Files);

  if (fVerbosity) {
    ostringstream msg;
    msg << fAllT2Files.size() <<" T2Stat files to be processed.";
    INFO(msg);
  }

  //Add all files to Chain
  fDataTree = new TChain("TreeT2Stat");
  for (unsigned int i = 0; i < fAllT2Files.size(); ++i) {
    TFile* const file = TFile::Open(fAllT2Files[i].c_str(), "READ");
    if (!file || file->IsZombie()) {
      ostringstream err;
      err << " T2StatFileManager input file=" << fAllT2Files[i].c_str()
          << " is corrupt! This file will be skipped!";
      INFO_TERSE(err);
    } else {
      if (fVerbosity)
        cout << "  Adding T2Stat file: " << fAllT2Files[i].c_str() << " ..."<<endl;
      fDataTree->Add(fAllT2Files[i].c_str());
    }
  }

  if (fVerbosity) {
    ostringstream msg;
    msg << " T2Stat files added.";
    INFO(msg);
  }

  if (fDataTree) {
    // list of properties
    fAvailableComponents.insert("station_in_acquisition");

    const unsigned int nentries = fDataTree->GetEntries();

    if (fVerbosity) {
      ostringstream msg;
      msg << nentries <<" entries to be processed... It can take a while..." << endl;
      INFO(msg);
    }

    unsigned int treeTimeIn;
    unsigned int treeTimeOut;
    unsigned int treeId;

    fDataTree->SetBranchAddress("Id", &treeId);
    fDataTree->SetBranchAddress("tIn", &treeTimeIn);
    fDataTree->SetBranchAddress("tOut", &treeTimeOut);

    //Create eventlist for each station, and compute startGPS and endGPS limits.
    fDir = new TDirectory("dir", "dir", 0); // Directory to hold eventlist.
    for (unsigned int i = 0; i < nentries; ++i) {
      fDataTree->GetEntry(i);
      if (!i || treeTimeIn < fstartGPS)
        fstartGPS = treeTimeIn;
      if (!i || treeTimeOut > fendGPS)
        fendGPS = treeTimeOut;

      ostringstream listname;
      listname << "Station_" << treeId;

      if (fDir->FindObject(listname.str().c_str())) {       // Add to the list
        TEventList* const list = (TEventList*)fDir->FindObject(listname.str().c_str());
        if (fVerbosity > 4)
          cout << "  Adding to StationList: " << listname.str().c_str() << endl;
        //list->Enter(fDataTree->GetChainEntryNumber(i));
        list->Enter(fDataTree->GetEntryNumber(i));
      } else {   // Create new list for that station
        TEventList* const list = new TEventList(listname.str().c_str(), listname.str().c_str(), 0, 0);
        if (fVerbosity > 3)
          cout << " Creating StationList: " << listname.str().c_str() << endl;
        list->Enter(fDataTree->GetEntryNumber(i));
        //list->Enter(fDataTree->GetChainEntryNumber(i));
        list->DirectoryAutoAdd(fDir);
        fStationList.push_back(treeId); // Save station id of stations
      }
    } // Loop over entries in chain
  }

  INFO_TERSE("Initialization complete.");
}


VManager::Status
T2StatFileManager::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::eNotFound;
  }

  if (componentProperty == "station_in_acquisition") {
    if (componentName == "is_in_acquisition") {
      returnData = GetStationStatus(componentIndex);
      return VManager::eFound;
    }
  }

  return VManager::eNotFound;
}


bool
T2StatFileManager::ReadData()
  const
{
  if (fVerbosity > 2)
    INFO( " enter ReadData ");

  const unsigned int now = det::Detector::GetInstance().GetTime().GetGPSSecond();
  if (now < fstartGPS || now > fendGPS) {
    ostringstream err;
    err << "Detector Time not found! GPSTime=" << now << ", T2File limits: " << fstartGPS << " - "<< fendGPS;
    ERROR(err);
    return false;
  }
  return true;
}


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

  const unsigned int stationId = boost::lexical_cast<unsigned int>(iStationId->second);

  int isActive = -1;
  bool stationComm = false;

  for (unsigned int i = 0; i < fStationList.size(); ++i)
    if (fStationList[i] == stationId)
      stationComm = true;

  if (fVerbosity > 2)
    cout << "Looking for station: " << stationId << endl;

  if (stationComm) {
    isActive = 0;
    const unsigned int now = det::Detector::GetInstance().GetTime().GetGPSSecond();

    unsigned int treeTimeIn;
    unsigned int treeTimeOut;
    unsigned int treeId;

    fDataTree->SetBranchAddress("Id", &treeId);
    fDataTree->SetBranchAddress("tIn", &treeTimeIn);
    fDataTree->SetBranchAddress("tOut", &treeTimeOut);

    //Get List of station id
    ostringstream listname;
    listname << "Station_" << stationId;
    TEventList* const list = (TEventList*)fDir->FindObject(listname.str().c_str());
    const int entries = list->GetN();
    if (fVerbosity > 2)
      cout << entries << " entries for station: " << stationId << endl;
    for (int i = 0; i < entries; ++i) {     // Iteration only over the selected station.
      fDataTree->GetEntry(list->GetEntry(i));
      if (treeId != stationId) {
        ostringstream msg;
        msg << "This should never happen!!! Found id " << treeId
            << " in " << listname.str() << " list";
        ERROR(msg);
      }
      if (now < treeTimeIn)
        continue;
      if (now > treeTimeOut)
        continue;
      if (fCommsCrisis && treeTimeOut-treeTimeIn < 120)
        continue;
      isActive = 1;
      break;
    }
  } else {
    if (fVerbosity > 1) {
      ostringstream warn;
      warn << "*****************************************************\n"
              "     Station: " << stationId << " not commisioned\n"
              "*****************************************************";
      WARNING(warn);
    }
    isActive = 0;
  }
  return isActive;
}