CModelsXMLManager.cc

Go to the documentation of this file.

#include <boost/lambda/lambda.hpp>
#include <boost/lexical_cast.hpp>
#include <cdet/CModelsXMLManager.h>
#include <utl/ErrorLogger.h>
#include <utl/TabulatedFunction.h>
#include <cdet/CDetector.h>
#include <cdet/CManagerRegister.h> // needed for registration macro

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

REGISTER_C_MANAGER("CModelsXMLManager", CModelsXMLManager)

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


// Generic data getters
// --------------------
template<typename T>
VManager::Status
CModelsXMLManager::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
CModelsXMLManager::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
CModelsXMLManager::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 and RPC id's)
  // or 3 (station, Pad, channel)
  const int nIndices = componentIndex.size();

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

  Branch dataB;

  switch (nIndices) {
  case 1:
    {
      // If just 1 index, it had better be the station Id!
      const IndexMap::const_iterator stIt = componentIndex.begin();
      if (stIt->first == "stationId") {
        stationId = stIt->second;
        break;
      }
      if (IsReportingErrors())
        INFO(string("If data request is made using 1 index, "
                    "that index must specify 'stationId'; ") +
             QueryInfoMessage(componentProperty, modelType, componentIndex));
      return dataB;
    }
    break;
  case 2:
    {
      const IndexMap::const_iterator stIt = componentIndex.find("stationId");
      if (stIt == componentIndex.end()) {
        if (IsReportingErrors())
          INFO(string("Request with two indices, "
                      "neither of which specifies 'stationId'; ") +
               QueryInfoMessage(componentProperty, modelType, componentIndex));
        return dataB;
      }
      stationId = stIt->second;

      const IndexMap::const_iterator rpcIt = componentIndex.find("RPCId");
      if (rpcIt != componentIndex.end()) 
        componentAtts["RPCId"] = rpcIt->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<string, IndexMap>::const_iterator sModel =
    fStationModelMap.find(stationId);
  if (sModel != fStationModelMap.end())
    modelMap = sModel->second;
  else if (!fAllStationsModelMap.empty())
    modelMap = fAllStationsModelMap;
  else {
    ostringstream err;
    err << "Cannot map station " << stationId << " to the list of known models "
           "since model for 'all' does not exist.";
    ERROR(err);
    return dataB;
  }

  string modelId;
  {
    const IndexMap::const_iterator mIt = modelMap.find(modelType);
    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 Pad in a tank.
  // If no attributes are present to specify, for example, a particular Pad,
  // then the data are assumed to be valid for all Pads 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 Pad position, as the three Pad'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 RPC in the tank

  if (!dataB)
    dataB = modelTypeB.GetChild(componentProperty, componentAtts);

  return dataB;
}


void
CModelsXMLManager::FillMaps()
{
  // fill fStationIdMap from DetectorConfig file
  // Parse information between <stationConfig> tags and fill fStationModelMap
  //

  Branch stationConfigB = fBranch.GetChild("stationConfig");

  for (Branch protoB = stationConfigB.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 all stations
    IndexMap optAtts;
    optAtts["id"] = "all";
    Branch allStationsB = protoB.GetChild("stations", optAtts);
    if (allStationsB)

      fAllStationsModelMap = modelMap;

    else {

      // if not get the station ids
      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);

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

    }

  }
}


det::VManager::Status
CModelsXMLManager::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;
}