RModelsXMLManager.cc

Go to the documentation of this file.

#include <boost/lambda/lambda.hpp>

#include <rdet/RDetector.h>
#include <rdet/RModelsXMLManager.h>
#include <rdet/RManagerRegister.h> // needed for registration macro
#include <rdet/RSimulationStationListManager.h>

#include <utl/ErrorLogger.h>
#include <utl/TabulatedFunction.h>
#include <utl/TabulatedFunctionComplexLgAmpPhase.h>
#include <utl/ComplexLgAmpPhase.h>

using namespace rdet;
using namespace std;
using namespace utl;
using namespace det;
using namespace xercesc;
using namespace boost::lambda;


REGISTER_R_MANAGER("RModelsXMLManager", RModelsXMLManager)


void
RModelsXMLManager::Init(const string& configLink)
{
  VManager::Init(configLink);
  FillMaps();
}


// Generic data getters
// --------------------
template<typename T>
VManager::Status
RModelsXMLManager::InternalGetData(T& returnData,
                                   const string& componentProperty,
                                   const string& componentName,
                                   const IndexMap& componentIndex)
  const
{
  if (componentName == "stationList")
    return VManager::eNotFound;

  // this check is also repeated in RModelsXMLManager::FindBranch() taking into account componentIndex.size() == 0
  if (componentIndex.size()) {
    const IndexMap::const_iterator stIt = componentIndex.find("station");
    if (stIt == componentIndex.end()) {
      if (IsReportingErrors()) {
        INFO(string("Request with two indices, "
                    "neither of which specifies 'stationId'; ") +
        QueryInfoMessage(componentProperty, componentName, componentIndex));
      }
    }
    else {
      // returns eNotFound if the station description is not suppose to be from XML
      if (RSimulationStationListManager::GetSourceType(componentIndex.find("station")->second) != "XML")
        return eNotFound;
    }
  }
  else {
    if (componentProperty == "addSStationList") {
      fBranch.GetChild("AddStationsFromSManager").GetData(returnData);
      return eFound;
    }
  }

  // Find where requested data resides in DOM
  Branch dataBranch =
    FindBranch(componentProperty, componentName, componentIndex);

  if (!dataBranch) {
    return eNotFound;
  }

  dataBranch.GetData(returnData);

  return eFound;
}


VManager::Status
RModelsXMLManager::GetTFCLAPData(TabulatedFunctionComplexLgAmpPhase& returnData,
                           const string& componentProperty,
                           const string& componentName,
                           const IndexMap& componentIndex)
  const
{
  // Find where requested data resides in DOM
  Branch dataBranch =
    FindBranch(componentProperty, componentName, componentIndex);

  if (!dataBranch)
    return eNotFound;

  // Since this is tabulated data, retrieve the ordinate and abscissa
  // NOTE THAT IT IS ASSUMED THAT THE ABSCISSA IS LABELED "x" AND
  // THE ORDINATE IS LABELED "y"
  Branch xB = dataBranch.GetChild("x");
  if (!xB)
    return eNotFound;

  vector<double> x;
  xB.GetData(x);

  Branch lgAmpB = dataBranch.GetChild("LgAmp");
  if (!lgAmpB)
    return eNotFound;

  vector<double> lgAmp;
  lgAmpB.GetData(lgAmp);

  Branch phaseB = dataBranch.GetChild("Phase");
  if (!phaseB)
    return eNotFound;

  vector<double> phase;
  phaseB.GetData(phase);

  const unsigned int n = x.size();
  returnData = TabulatedFunctionComplexLgAmpPhase();
  for (unsigned int i = 0; i < n; ++i)
    returnData.PushBack(x[i], ComplexLgAmpPhase(lgAmp[i],phase[i]));

  return eFound;
}


VManager::Status
RModelsXMLManager::GetDataMap(std::map<std::string,double>& returnData,
                              const string& componentProperty,
                              const string& componentName,
                              const IndexMap& componentIndex)
  const
{
  // returns eNotFound if the station description is not suppose to be from XML
  if (RSimulationStationListManager::GetSourceType(componentIndex.find("station")->second) != "XML")
    return eNotFound;

  // Find where requested data, e.g. RResponseMapList, resides in DOM
  Branch dataBranch =
    FindBranch(componentProperty, componentName, componentIndex);
  
  if (!dataBranch)
    return eNotFound;

  do {
    string ResponseId;
    dataBranch.GetChild("ResponseId").GetData(ResponseId);
    double ResponseWeight;
    dataBranch.GetChild("ResponseWeight").GetData(ResponseWeight);

    returnData[ResponseId] += ResponseWeight;
  } while ((dataBranch = dataBranch.GetNextSibling()));

  return eFound;
}


Branch
RModelsXMLManager::FindBranch(const string& componentProperty,
                              const string& modelType,
                              const IndexMap& componentIndex)
  const
{
  // Act on the Branch request based on the number of indices specified
  // Number of indices can be 1 (just the station id), 2 (channel and station id's)
  const int nIndices = componentIndex.size();

  IndexMap componentAtts;

  Branch dataB;


  switch (nIndices) {
  case 1:
    {
      // FS: The following if block looks fishy...
      //     However I did not find a case where the only index is a station (id):
      //     This should be the case if this manager should return the answer, but it can
      //     very well be that a component with only one index is requested and a other manager 
      //     is providing the answer!
      const IndexMap::const_iterator stIt = componentIndex.begin();
      if (stIt->first == "station") {
        componentAtts["channel"] = stIt->second;
        break;
      }
      
      if (IsReportingErrors())
        INFO(string("If data request is made using 1 index, "
                    "that index must specify 'station'; ") +
             QueryInfoMessage(componentProperty, modelType, componentIndex));
      return dataB;
    }
    break;
  case 2:
    {
      const IndexMap::const_iterator stIt = componentIndex.find("station");
      if (stIt == componentIndex.end()) {
        if (IsReportingErrors()) {
          INFO(string("Request with two indices, "
                      "neither of which specifies 'stationId'; ") +
               QueryInfoMessage(componentProperty, modelType, componentIndex));
        }
        return dataB;
      }
      componentAtts["station"] = stIt->second;

      const IndexMap::const_iterator chIt = componentIndex.find("channel");
      if (chIt != componentIndex.end())
        componentAtts["channel"] = chIt->second;
      else
        return dataB;
    }
    break;
  case 3:
    if (IsReportingErrors())
      INFO(string("Three indices in query: not yet supported; ") +
           QueryInfoMessage(componentProperty, modelType, componentIndex));
    return dataB;

  default:
    if (IsReportingErrors()) {
      INFO(string("Invalid number of parameters; ") +
           QueryInfoMessage(componentProperty, modelType, componentIndex));
    }
    return dataB;
  }

  IndexMap modelMap;
  const map<pair<std::string, std::string>, IndexMap>::const_iterator sModel =
    fStationChannelModelMap.find(make_pair(componentAtts["station"], componentAtts["channel"]));

  const map<std::string, IndexMap>::const_iterator sAugerPrimeModel =
    fAugerPrimeStationsModelMap.find(componentAtts["channel"]);

  // FS: This is somewhat insecure. If we configure, in addition to AugerPrime stations, 
  // stations with and id > GetRdSdStationIdLink (30000), and do not provide a configuration for those stations,
  // they would get configured like a AugerPrime stations. One clould explicitly query the Sd station list ...
  bool isAugerPrimeStation = 
    std::atoi(componentAtts["station"].c_str()) > det::Detector::GetInstance().GetRDetector().GetRdSdStationIdLink();

  const map<std::string, IndexMap>::const_iterator sDefaultModel =
    fDefaultStationsModelMap.find(componentAtts["channel"]);

  if (sModel != fStationChannelModelMap.end())
    modelMap = sModel->second;
  else if (isAugerPrimeStation && sAugerPrimeModel != fAugerPrimeStationsModelMap.end())
    modelMap = sAugerPrimeModel->second;
  else if (sDefaultModel != fDefaultStationsModelMap.end())
    modelMap = sDefaultModel->second;
  else if (IsReportingErrors()) {
    ostringstream err;
    err << "Cannot map channel " << componentAtts["channel"] << " to the list of known models "
           "since model for 'default' does not exist.";
    ERROR(err);
    return dataB;
  }

  string modelId;
  {
    const IndexMap::const_iterator mIt = modelMap.find(modelType);
    if (mIt != modelMap.end())
      modelId =  mIt->second;
  }

  Branch channelModelsB = fBranch.GetChild("channelModels");
  if (!channelModelsB)
    return channelModelsB;

  // Get the requested data from the DOM
  IndexMap atts({{ "id", modelId }});
  Branch modelTypeB = channelModelsB.GetChild(modelType, atts);
  if (!modelTypeB)
    return modelTypeB;

  // First, attempt to find the dataB without providing componentAtts map
  // to further specify a component.  componentAtts is currently used to
  // identify a particular PMT in a tank.
  // If no attributes are present to specify, for example, a particular PMT,
  // then the data are assumed to be valid for all PMTs associated with
  // the particular model type.  This should generally be the case.  The only
  // instance (I can think of) where this is not true is in specification
  // of the PMT position, as the three PMT's are clearly located in three
  // different places in the tank.
  dataB = modelTypeB.GetChild(componentProperty);

  // If no data found when no componentAtts specified, specify the componentAtts.
  // This will find data unique to a PMT in the tank
  if (!dataB)
    dataB = modelTypeB.GetChild(componentProperty, componentAtts);

  return dataB;
}


void
RModelsXMLManager::FillMaps()
{
  // fill fChannelIdMap from DetectorConfig file
  // Parse information between <channelConfig> tags and fill fChannelModelMap
  //
  Branch channelConfigB = fBranch.GetChild("channelConfig");

  for (Branch protoB = channelConfigB.GetFirstChild();
       protoB; protoB = protoB.GetNextSibling()) { // loop on prototypes

    Branch modelsB = protoB.GetChild("models");
    IndexMap modelMap;
    for (Branch modelB = modelsB.GetFirstChild();
         modelB; modelB = modelB.GetNextSibling()) { // loop on models

      const IndexMap atts(modelB.GetAttributes());
      modelMap[modelB.GetName()] = atts.find("id")->second;
    }

    // check if this model applies to default stations
    IndexMap optAtts;
    IndexMap optAtts2;

    optAtts["id"] = "default";
    optAtts2["id"] = "AugerPrime";

    if (protoB.GetChild("stations", optAtts)) {
      Branch channelsB = protoB.GetChild("channels");
      if (channelsB){
        // loop on channels (to which this model applies)
        for (Branch channelB = channelsB.GetFirstChild();
             channelB; channelB = channelB.GetNextSibling()) {

          const IndexMap atts(channelB.GetAttributes());
          const string channelIdString(atts.find("id")->second);
          fDefaultStationsModelMap[channelIdString] = modelMap;
        }
      }
    } else if (protoB.GetChild("stations", optAtts2)) {
      Branch channelsB = protoB.GetChild("channels");
      if (channelsB){
        // loop on channels (to which this model applies)
        for (Branch channelB = channelsB.GetFirstChild();
             channelB; channelB = channelB.GetNextSibling()) {

          const IndexMap atts(channelB.GetAttributes());
          const string channelIdString(atts.find("id")->second);
          fAugerPrimeStationsModelMap[channelIdString] = modelMap;
        }
      }
    } else {
      // get stations
      Branch stationsB = protoB.GetChild("stations");
      if (stationsB) {
        // loop on stations (to which this model applies)
        for (Branch stationB = stationsB.GetFirstChild();
             stationB; stationB = stationB.GetNextSibling()) {

          const IndexMap atts(stationB.GetAttributes());
          const string stationIdString(atts.find("id")->second);
          Branch channelsB = protoB.GetChild("channels");
          if (channelsB) {
            // loop on channels (to which this model applies)
            for (Branch channelB = channelsB.GetFirstChild();
                channelB; channelB = channelB.GetNextSibling()) {
                const IndexMap atts(channelB.GetAttributes());
                const string channelIdString(atts.find("id")->second);
                fStationChannelModelMap[pair<std::string, std::string>(stationIdString,channelIdString)] = modelMap;
            }
          }
        }
      }
    }
  }
  /*
    for (std::map<pair<std::string, std::string>, IndexMap>::const_iterator fSCMMiter = fStationChannelModelMap.begin();
       fSCMMiter!=fStationChannelModelMap.end();++fSCMMiter) {
    pair<std::string, std::string> tIndex = fSCMMiter->first;
    cout << "IndexMap Controll-loop: "
         << "Station " << tIndex.first
         << "Channel " << tIndex.second
         << endl;
         }
  */
}