EventPointingManager.cc

Go to the documentation of this file.

#include <sstream>

#include <fwk/CentralConfig.h>
#include <fwk/RunController.h>

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

#include <det/Detector.h>

#include <fdet/FDetector.h>
#include <fdet/EventPointingManager.h>

#include <evt/Event.h>
#include <fevt/FEvent.h>
#include <fevt/Eye.h>
#include <fevt/Telescope.h>

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


REGISTER_F_MANAGER("EventPointingManager", EventPointingManager);


void
EventPointingManager::Init(const string& configLink)
{
  // call shadowed VManager::Init() first
  VManager::Init(configLink);

  if (!fBranch) {
    ERROR("No configuration file found ....");
  }
  
  for (Branch cB = fBranch.GetFirstChild(); cB; cB = cB.GetNextSibling()) {
    
    const string id = FindComponent<string>("id", cB.GetAttributes());
    EventPointingManager::Pointing pointing(id);
    cB.GetChild("minElevation").GetData(pointing.minElevation);
    cB.GetChild("maxElevation").GetData(pointing.maxElevation);
    
    if (pointing.minElevation > pointing.maxElevation) {
      ostringstream err;
      err << "You defined minimal elevation larger than maximal elevation! Please fix!\n"
          << "      Error in : id=" <<  id 
          << " minElevation=" << pointing.minElevation/deg << " deg, "
          << " maxElevation=" << pointing.maxElevation/deg << " deg\n";
      throw utl::XMLParseException(err.str());
    }
    
    // check consistency
    for (vector<Pointing>::const_iterator iP = fPointings.begin();
         iP != fPointings.end(); ++iP) {
      if ((pointing.minElevation > iP->minElevation &&
           pointing.minElevation < iP->maxElevation    ) || 
          (pointing.maxElevation > iP->minElevation &&
           pointing.maxElevation < iP->maxElevation    ) ||
          (pointing.minElevation < iP->minElevation &&
           pointing.maxElevation > iP->maxElevation    ) ||       
          (id == iP->pointingId) ) {
        ostringstream err;
        err << "You defined overlapping pointing elevation ranges! Please fix!\n"
            << "      Range with problem: id=" <<  id 
            << " minElevation=" << pointing.minElevation/deg << " deg, "
            << " maxElevation=" << pointing.maxElevation/deg << " deg\n"
            << "      overlapping with:  id=" <<  iP->pointingId
            << " minElevation=" << iP->minElevation/deg << " deg, "
            << " maxElevation=" << iP->maxElevation/deg << " deg";
        throw utl::XMLParseException(err.str());
      }
    }
    
    fPointings.push_back(pointing);
    
  }
}


VManager::Status
EventPointingManager::GetPointing(string& returnData,
                                  const string& componentProperty,
                                  const string& /*componentName*/,
                                  const IndexMap& componentIndex)
  const
{  
  if (componentProperty != "pointing")
    return eNotFound;
  
  IndexMap::const_iterator iEyeId, iTelId;
  iEyeId = componentIndex.find("eyeId");
  iTelId = componentIndex.find("telescopeId");
  if (iEyeId == componentIndex.end() ||
      iTelId == componentIndex.end()) {
    INFO("Called EventPointingManager with wrong number of arguments!");
    return eNotFound;
  }
  
  int eyeId, telId;
  istringstream ssEyeId(iEyeId->second);
  ssEyeId >> eyeId;
  istringstream ssTelId(iTelId->second);
  ssTelId >> telId;

//#warning AP: fix me once IoAuger is re-remerged
  if (eyeId < 5) {
    returnData = "downward";
    return eFound;
  }
  //end of temporary fixing
  
  /*
    In principle the telescope pointing is stored in the FDAS raw data and 
    could be read from there directly. However, it is more general to read
    that data during event reading and store it in the Offline/fevt::Telescope
    since this information can also be saved into Offline ROOT files as well 
    as handled correctly in Offline simulations.
  */
  
  // get current event
  const evt::Event& event = fwk::RunController::GetInstance().GetCurrentEvent();  
  if (!event.HasFEvent())
    return eNotFound;
  const fevt::FEvent& fdEvent = event.GetFEvent();
  
  if (!fdEvent.HasEye(eyeId, fevt::ComponentSelector::eInDAQ))
    return eNotFound;
  const fevt::Eye& eye = fdEvent.GetEye(eyeId, fevt::ComponentSelector::eInDAQ);

  if (!eye.HasTelescope(telId, fevt::ComponentSelector::eInDAQ))
    return eNotFound;
  const fevt::Telescope& tel = eye.GetTelescope(telId, fevt::ComponentSelector::eInDAQ);
  
  const string& pointing = tel.GetRawTelPointing();
  istringstream pointingSS(pointing);
  
  string what;
  pointingSS >> what;
  if (what == "data:") {
    double angle;
    pointingSS >> angle;
    
    for (vector<Pointing>::const_iterator iP = fPointings.begin();
         iP != fPointings.end(); ++iP) {
      if (angle > iP->minElevation/deg && angle < iP->maxElevation/deg) {
        returnData = iP->pointingId;
        return eFound;
      }
    }
    if (IsReportingErrors()) {
      ostringstream info;
      info << "Pointing for angle=" << angle << " not defined. Available settings are:";
      for (vector<Pointing>::const_iterator iP = fPointings.begin();
           iP != fPointings.end(); ++iP) {
        info << "\n        id=" << iP->pointingId << ","
             << " minElevation=" << iP->minElevation/deg << " deg, "
             << " maxElevation=" << iP->maxElevation/deg << " deg";
      }    
      INFO(info);
    }
    
    return eNotFound;
  }
  else if (what == "sim:") {
    string id;
    pointingSS >> id;
    returnData = id;

    return eFound;
  }
  
  return eNotFound;
}


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