SModelsXMLManager.cc

Go to the documentation of this file.

#include <boost/lambda/lambda.hpp>
#include <boost/lexical_cast.hpp>
#include <sdet/SModelsXMLManager.h>
#include <utl/ErrorLogger.h>
#include <utl/TabulatedFunction.h>
#include <sdet/SDetector.h>
#include <sdet/SManagerRegister.h> // needed for registration macro

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


REGISTER_S_MANAGER("SModelsXMLManager", SModelsXMLManager)


void
SModelsXMLManager::Init(const string& configLink)
{
  VManager::Init(configLink);
  FillMaps();
  AddAvailability<unsigned int>("scintillator");
  AddAvailability<unsigned int>("electronics");
}


// Generic data getters
// --------------------
template<typename T>
VManager::Status
SModelsXMLManager::InternalGetData(T& 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;

  dataBranch.GetData(returnData);
  return eFound;
}


VManager::Status
SModelsXMLManager::GetData(TabulatedFunction& 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 yB = dataBranch.GetChild("y");
  if (!yB)
    return eNotFound;

  vector<double> y;
  yB.GetData(y);

  // As a convenience, scale all ordinate values if a scale factor is given
  double scaleY;
  Branch scaleYB = dataBranch.GetChild("scaleY");
  if (scaleYB) {
    scaleYB.GetData(scaleY);
    for_each(y.begin(), y.end(), _1 *= scaleY);
  }

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

  return eFound;
}


Branch
SModelsXMLManager::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 (station id and PMT id) or (station id and isuub),
   * 3 (station id, isuub, PMT id)
   */
  const int nIndices = componentIndex.size();

  // The component attribute map is currently used in cases where a PMT index
  // is specified (that is we have differing data applying to the 3 PMT's in
  // a station).  The commonest application for this is presumably specifying
  // the PMT positions.
  string stationId;
  string hardwareVersion;
  IndexMap componentAtts;

  Branch dataB;

  // stationId must be present in indices
  const IndexMap::const_iterator stIt = componentIndex.find("stationId");
  if (stIt == componentIndex.end()) {
    if (IsReportingErrors())
      INFO(string("Request with " + boost::lexical_cast<string>(nIndices) +
                  " indices, none of which specifies 'stationId'; ") +
           QueryInfoMessage(componentProperty, modelType, componentIndex));
    return dataB;
  }
  stationId = stIt->second;

  // isUUB must be present in indices
  const IndexMap::const_iterator hardIt = componentIndex.find("isUUB");
  if (hardIt == componentIndex.end()) {
    if (IsReportingErrors())
      INFO(string("Request with " + boost::lexical_cast<string>(nIndices) +
                  " indices, none of which specifies 'isUUB'; ") +
           QueryInfoMessage(componentProperty, modelType, componentIndex));
    return dataB;
  }
  hardwareVersion = hardIt->second;

  switch (nIndices) {
  // Two indices must be stationId and isUUB. dataB is returned if this
  // is not the case. As such, switch starts with case 3.
  case 1:
  case 2:
    break;
  case 3:
    {
      const IndexMap::const_iterator pmtIt = componentIndex.find("PMTId");
      if (pmtIt == componentIndex.end()) {
        if (IsReportingErrors())
          INFO(string("Request with three indices, "
                      "none of which specifies 'PMTId'; ") +
               QueryInfoMessage(componentProperty, modelType, componentIndex));
        return dataB;
      }
      componentAtts["PMTId"] = pmtIt->second;
    }
    break;
  case 4:
    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;
  }

  IndexIndexMap hardwareVersionsMap;
  const std::map<std::string, IndexIndexMap>::const_iterator sHardwareVersions =
    fStationModelMap.find(stationId);
  if (sHardwareVersions != fStationModelMap.end())
    hardwareVersionsMap = sHardwareVersions->second;
  else if (!fAllStationsModelMap.empty())
    hardwareVersionsMap = fAllStationsModelMap;
  else {
    ostringstream err;
    err << "Cannot map station " << stationId << " to the list of known hardware "
           "versions since hardware versions for 'all' does not exist.";
    ERROR(err);
    return dataB;
  }

  // selecting modelMap based on hardware version
  IndexMap modelMap;
  const IndexIndexMap::const_iterator sModels =
    hardwareVersionsMap.find(hardwareVersion);
  if (sModels != hardwareVersionsMap.end())
    modelMap = sModels->second;
  else {
    ostringstream err;
    err << "cannot access model map for requested hardware version "
        << hardwareVersion << " since this version "
        << "does not exist for the specified station or 'all' station "
        << "configuration if that was requested.";
    ERROR(err);
    return dataB;
  }

  string modelId;
  {
        string modelTypeFull;
        /*
         * As different "models" are used for the same "type" in the case of
         * PMTs (e.g. small PMT vs. scintillator PMT), and the mangager mapping 
         * machinery is not setup to hand such cases, the PMT models in the modelMap
         * are matched to the the model being queried by a string where the model
         * type has the PMTId concatenated to it's end.
         */
        if (modelType == "PMT" || modelType == "pmtElectronics") {
          modelTypeFull = modelType+componentAtts["PMTId"];
        } else {
          modelTypeFull = modelType;
        }
    const IndexMap::const_iterator mIt = modelMap.find(modelTypeFull);
    if (mIt != modelMap.end()) {
      modelId = mIt->second;
    }
  }

  // Get the requested data from the DOM
  //
  IndexMap atts;
  atts["id"] = modelId;

  Branch stationModelsB = fBranch.GetChild("stationModels");
  if (!stationModelsB)
    return stationModelsB;

  Branch modelTypeB = stationModelsB.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
SModelsXMLManager::FillMaps()
{
  // fill fStationIdMap from DetectorConfig file
  // Parse information between <stationConfig> tags and fill fStationModelMap
  //
  Branch stationConfigB = fBranch.GetChild("stationConfig");
  for (Branch setB = stationConfigB.GetFirstChild();
       setB; setB = setB.GetNextSibling()) {
    /*
     * If unique specifications were to be applied to individual stations,
     * a loop over "generic" and "unique" branches would be added here.
     * For now, all stations adhere to the two possible hardware versions
     * (pre/post AugerPrime) with identical properties for each type of 
     * hardware (e.g. identical quantum efficiency for all PMTs with 
     * id="photonis-XP1805").
     */
    Branch hardwareVersionsB = setB.GetChild("hardwareVersions");

    std::map<std::string, IndexMap> hardwareVersionMap;

    for (Branch hardwareB = hardwareVersionsB.GetFirstChild();
         hardwareB; hardwareB = hardwareB.GetNextSibling()) { // loop on hardware versions

      IndexMap modelMap;
      
      for (Branch modelB = hardwareB.GetFirstChild();
           modelB; modelB = modelB.GetNextSibling()) { // loop on models
        
        const IndexMap atts(modelB.GetAttributes());
        /*
         * As different "models" are used for the same "type" in the case of
         * PMTs (e.g. small PMT vs. scintillator PMT), and the mangager mapping 
         * machinery is not setup to hand such cases, the PMT models in the modelMap
         * are matched to the the model being queried by a string where the model
         * type has the PMTId concatenated to it's end.
         */
        if (modelB.GetName() == "PMT" || modelB.GetName() == "pmtElectronics") {
          modelMap[modelB.GetName()+atts.find("PMTId")->second] = atts.find("id")->second;
        } else {
          modelMap[modelB.GetName()] = atts.find("id")->second;
        }
      }

      hardwareVersionMap[hardwareB.GetAttributes().find("isUUB")->second] = modelMap;

    }

    // check if these hardware versions apply to all stations
    IndexMap optAtts;
    optAtts["id"] = "all";
    Branch allStationsB = setB.GetChild("stations", optAtts);
    if (allStationsB)
      fAllStationsModelMap = hardwareVersionMap;
    else {
      // if not get the station ids
      Branch stationsB = setB.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);

          // write an entry in map<Id, map<model type, model id> >
          fStationModelMap[stationIdString] = hardwareVersionMap;
        }
    }
  }
}


det::VManager::Status
SModelsXMLManager::GenericGetData(Handle& returnData,
                                  const std::string& component,
                                  const std::string& property,
                                  const IndexMap& index)
  const
{
  if (!returnData.Is<unsigned int>())
    return eNotFound;
  if (!((property == "barCount" && component == "scintillator") || 
        (property == "traceBins" && component == "electronics")))
    return eNotFound;

  Branch dataBranch =
    FindBranch(property, component, index);

  if (!dataBranch)
    return eNotFound;
  
  returnData.Get<unsigned int>() = dataBranch.Get<unsigned int>();
  
  return eFound;
}