FTelescopeListXMLManager.cc

Go to the documentation of this file.

#include <fdet/FTelescopeListXMLManager.h>

#include <fwk/CentralConfig.h>
#include <utl/ErrorLogger.h>
#include <utl/Reader.h>
#include <fdet/FManagerRegister.h>

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


REGISTER_F_MANAGER("FTelescopeListXMLManager", FTelescopeListXMLManager)


FTelescopeListXMLManager::~FTelescopeListXMLManager()
{
}

/*********************************************************************/
// Generic data getters
//---------------------
template<typename T>
VManager::Status
FTelescopeListXMLManager::GetTelescopeListData(T& returnData,
                                               const string& componentProperty,
                                               const string& componentName,
                                               const IndexMap& componentIndex)
  const
{
  // For this manager, there are three cases to consider:
  //   0) no index has been provided --> requests for overall properties
  //   1) One index has been provided, specifying just the eye.  In this case, we
  //      search for data unique to an eye (name, position, coordinate system)
  //   2) Two indices have been provided, one for the eye and one for the telescope.
  //      In this case, we search for data unique to a telescope (orientation, position, commission time, etc)
  //      Note that any conversion of the telescope orientation into the frame of the eye
  //      will be done in the Eye interface class.

  if (componentIndex.empty()) {
    Branch propertyB = fBranch.GetChild(componentProperty);
    if (!propertyB)
      return eNotFound;

    propertyB.GetData(returnData);
    return eFound;
  }
  else if (componentIndex.size() == 1) {
    return GetEyeData(returnData, componentProperty,
                      componentName, componentIndex);
  }
  else if (componentIndex.size() == 2) {
    return GetTelescopeData(returnData, componentProperty,
                            componentName, componentIndex);
  }
  else {
    if (IsReportingErrors()) {
      INFO(string("More than three indices found; ") +
           QueryInfoMessage(componentProperty, componentName, componentIndex));
    }
    return eNotFound;
  }

  return eNotFound; // never reached.
}


/*********************************************************************/
// Getter for eye-level data
template<typename T>
VManager::Status
FTelescopeListXMLManager::GetEyeData(T& returnData,
                                     const string& componentProperty,
                                     const string& componentName,
                                     const IndexMap& componentIndex)
  const
{
  const IndexMap::const_iterator it = componentIndex.find("eyeId");
  if (it == componentIndex.end()) {
    INFO(string("Only one index found and it is not 'eyeId'; ") +
         QueryInfoMessage(componentProperty, componentName, componentIndex));
    return eNotFound;
  }

  if (componentName != "eye"
      && componentName != "virtualEye") {
    return eNotFound;
  }
  const bool isVirtual = componentName == "virtualEye";

  IndexMap atts;
  atts["id"] = it->second;

  Branch eyeB = fBranch.GetChild(componentName, atts);
  if (!eyeB) {
    // If we're looking for the parent eye for a virtual eye,
    // we short circuit the manager loop by claiming that we found the
    // information.
    if (isVirtual && componentProperty == "parentEye")
      return eFound;

    // The name is available from virtual eyes as well!
    if (componentProperty == "name")
      eyeB = fBranch.GetChild("virtualEye", atts);

    if (!eyeB)
      return eNotFound;
  }

  Branch propertyB = eyeB.GetChild(componentProperty);
  if (!propertyB)
    return eNotFound;

  propertyB.GetData(returnData);

  return eFound;
}


/*********************************************************************/
// Getter for telescope-level data
template<typename T>
VManager::Status
FTelescopeListXMLManager::GetTelescopeData(T& returnData,
                                           const string& componentProperty,
                                           const string& componentName,
                                           const IndexMap& componentIndex)
  const
{
  // First validate the componentIndex
  const IndexMap::const_iterator eIt = componentIndex.find("eyeId");
  if (eIt == componentIndex.end()) {
    INFO(string("Two indices found, neither of them is 'eyeId'; ") +
         QueryInfoMessage(componentProperty, componentName, componentIndex));
    return eNotFound;
  }

  const IndexMap::const_iterator tIt = componentIndex.find("telescopeId");
  if (tIt == componentIndex.end()) {
    INFO(string("Two indices found, neither of them is 'telescopeId'; ") +
         QueryInfoMessage(componentProperty, componentName, componentIndex));
    return eNotFound;
  }

  // validate componentName
  const bool isVirtual = componentName == "virtualTelescope";
  if (componentName != "telescope" && !isVirtual) {
    return eNotFound;
  }

  // the "pointing" property is just a fallback solution,
  // we have to redirect it to "defaultPointing"
  const string componentPropertyReal = (componentProperty == "pointing")
                                       ? "defaultPointing"
                                       : componentProperty;

  IndexMap atts;
  atts["id"] = eIt->second;
  Branch eyeB = fBranch.GetChild((isVirtual ? "virtualEye" : "eye"), atts);
  if (!eyeB) {
    // If we're looking for the from* info for a virtual tel,
    // we short circuit the manager loop by claiming that we found the
    // information.
    if (isVirtual
        && (componentProperty == "fromEye"
            || componentProperty == "fromTelescope")) {
      return eFound;
    }

    return eNotFound;
  }

  atts["id"] = tIt->second;
  Branch telescopeB = eyeB.GetChild("telescopes").GetChild("telescope", atts);
  if (!telescopeB)
    return eNotFound;

  Branch propertyB = telescopeB.GetChild(componentPropertyReal);
  if (!propertyB)
    return eNotFound;

  propertyB.GetData(returnData);

  return eFound;
}


/*********************************************************************/
// Special Getter for list of all Eye Id's and Telescope Id's present
// in the XML file.
VManager::Status
FTelescopeListXMLManager::GetFullEyeTelescopeList(list<int>& returnList,
                                                  const string& componentProperty,
                                                  const string& componentName,
                                                  const IndexMap& componentIndex)
  const
{
  // There are two possible requests indicated by the componentProperty:
  // 1) eyeList       : request for all eyes present in the XML file
  // 2) telescopeList : request for all telescopes present in the XML file

  if (componentProperty == "eyeList") {

    Branch topB = fBranch;
    for (Branch cb = topB.GetFirstChild(); cb; cb = cb.GetNextSibling()) {
      if (cb.GetName() == "eye"
          || cb.GetName() == "virtualEye") {
        istringstream is(cb.GetAttributes().find("id")->second);
        int id;
        is >> id;
        returnList.push_back(id);
      }
    }

  }
  else if (componentProperty == "telescopeList") {

    // There must be an index indicating which eye we are interested in
    if (componentIndex.size() != 1) {
      INFO(string("Invalid number of indices specified "
                  "in request for 'telescopeList'; ") +
           QueryInfoMessage(componentProperty, componentName, componentIndex));
      return eNotFound;
    }

    // The supplied index element must be 'eyeId'
    const IndexMap::const_iterator eIt = componentIndex.find("eyeId");
    if (eIt == componentIndex.end()) {
      INFO(string("Invalid indices for retrieving 'telescopeList'; ") +
           QueryInfoMessage(componentProperty, componentName, componentIndex));
      return eNotFound;
    }

    Branch topB = fBranch;

    IndexMap eyeAtts;
    eyeAtts["id"] = eIt->second;
    Branch eyeB = topB.GetChild("eye", eyeAtts);
    // If this fails, check for a virtual eye, too
    if (!eyeB)
      eyeB = topB.GetChild("virtualEye", eyeAtts);

    if (!eyeB) {
      ostringstream info;
      info << "Could not find requested eye in XML file: " << eIt->second;
      INFO(info);
      return eNotFound;
    }

    // Loop on all telescopes and put them in the list
    for (Branch telescopeB = eyeB.GetChild("telescopes").GetFirstChild();
         telescopeB; telescopeB = telescopeB.GetNextSibling())
    {
      const IndexMap telescopeAtts = telescopeB.GetAttributes();
      istringstream is(telescopeAtts.find("id")->second);
      int telescopeId;
      is >> telescopeId;
      returnList.push_back(telescopeId);

    }

  } // end if componentProperty == telescopeList
  else {
    INFO(string("Could not interpret the request with ") +
         QueryInfoMessage(componentProperty, componentName, componentIndex));
    return eNotFound;
  }

  return eFound;
}


/*********************************************************************/
VManager::Status
FTelescopeListXMLManager::GetTelescopePointingData(std::map<std::string, double>& returnData,
                                                   const string& componentProperty,
                                                   const string& componentName,
                                                   const IndexMap& componentIndex)
  const
{
  if (componentIndex.size() != 2)
    return eNotFound;

  if (componentProperty != string("opticalAxisPhi")
      && componentProperty != string("opticalAxisElevation")) {
    return eNotFound;
  }

  // First find the requested eye
  const IndexMap::const_iterator eIt = componentIndex.find("eyeId");

  if (eIt == componentIndex.end()) {
    INFO(string("No 'eyeId' in componentIndex; ") +
         QueryInfoMessage(componentProperty, componentName, componentIndex));
    return eNotFound;
  }

  IndexMap atts;
  atts["id"] = eIt->second;
  Branch eyeB = fBranch.GetChild("eye", atts);
  if (!eyeB)
    return eNotFound;

  // Next, find the requested telescope for the given eye
  const IndexMap::const_iterator tIt = componentIndex.find("telescopeId");

  if (tIt == componentIndex.end()) {
    INFO(string("Two indices found, neither of them is 'telescopeId'; ") +
         QueryInfoMessage(componentProperty, componentName, componentIndex));
    return eNotFound;
  }

  atts["id"] = tIt->second;
  Branch telescopeB = eyeB.GetChild("telescopes").GetChild("telescope", atts);
  if (!telescopeB)
    return eNotFound;

  Branch pointingsB = telescopeB.GetChild(string("pointings"));

  Branch pointingB = pointingsB.GetFirstChild();
  while (pointingB) {
    AttributeMap attrs = pointingB.GetAttributes();
    const std::string pointingId = attrs.find(string("id"))->second;
    double angle;
    pointingB.GetChild(componentProperty).GetData(angle);
    returnData[pointingId] = angle;
    pointingB = pointingB.GetNextSibling();
  }

  return eFound;
}


/*********************************************************************/
VManager::Status
FTelescopeListXMLManager::GetData(utl::TabulatedFunction& returnData,
                                  const std::string& componentProperty,
                                  const std::string& componentName,
                                  const IndexMap& componentIndex)
  const
{
  if (componentProperty == "relativeResponse") {

    vector<double> wavelength;
    Status s =
      GetTelescopeListData(wavelength, "relativeResponseLambda",
                           componentName, componentIndex);

    if (s != eFound)
      return s;

    vector<double> value;
    s = GetTelescopeListData(value, "relativeResponseValue",
                             componentName, componentIndex);

    if (s != eFound)
      return s;

    returnData = TabulatedFunction(wavelength, value);

    return VManager::eFound;

  } else if (componentProperty == "MHzTimeCorrection") {

    vector<double> correctionFactors;
    Status s =
      GetTelescopeListData(correctionFactors, "MHzCorrectionFactors",
                           componentName, componentIndex);
    if (s != eFound)
      return s;

    vector<double> months;
    s = GetTelescopeListData(months, "MHzCorrectionTimes",
                             componentName, componentIndex);
    if (s != eFound)
      return s;

    returnData = TabulatedFunction(months, correctionFactors);
    return eFound;

  } else
    return eNotFound;
}