FModelsXMLManager.cc

Go to the documentation of this file.

#include <boost/lambda/lambda.hpp>

#include <fdet/FModelsXMLManager.h>
#include <fwk/CentralConfig.h>
#include <det/VManager.h>
#include <utl/ErrorLogger.h>
#include <utl/Reader.h>
#include <fdet/FManagerRegister.h> // needed for registration macro

using namespace std;
using namespace fdet;
using namespace utl;
using namespace det;
using namespace boost::lambda;


REGISTER_F_MANAGER("FModelsXMLManager", FModelsXMLManager)


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


// Generic data getters
// --------------------
template<typename T>
VManager::Status
FModelsXMLManager::GetModelData(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 VManager::eNotFound;

  // Extract data from the branch
  dataBranch.GetData(returnData);

  // Found the data. To be returned as type T
  return VManager::eFound;
}


VManager::Status
FModelsXMLManager::GetTabulatedModelData(TabulatedFunction& tabulatedReturnData,
                                         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 VManager::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 abscissaBranch = dataBranch.GetChild("x");
  if (!abscissaBranch)
    return VManager::eNotFound;
  vector<double> abscissaVector;
  abscissaBranch.GetData(abscissaVector);

  Branch ordinateBranch = dataBranch.GetChild("y");
  if (!ordinateBranch)
    return VManager::eNotFound;
  vector<double> ordinateVector;
  ordinateBranch.GetData(ordinateVector);

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

  for (unsigned int i = 0; i < abscissaVector.size(); ++i)
    tabulatedReturnData.PushBack(abscissaVector[i], ordinateVector[i]);

  return VManager::eFound;
}


Branch
FModelsXMLManager::FindBranch(const string& componentProperty,
                              const string& modelType,
                              const IndexMap& componentIndex)
  const
{
  
  string telescopeId;
  //string eyeId;
  //string pmtId; // pixel or channel (NOT USED)
  
  // Act on the Branch request based on the number of indices specified 
  // Number of indices can be 1 (just the telescope id), 2 (telescope and 
  // mirror segment id's) or 3 (telescope, mirror segment, ... )
  //
  //int nIndices = componentIndex.size();
  
  // The component attribute map is currently used in cases where a mirror 
  // segment index is specified (that is we have differing data applying 
  // different to mirror segments in a telescope).  
  //
  const IndexMap::const_iterator iterTel = componentIndex.find("telescopeId");
  const IndexMap::const_iterator iterEye = componentIndex.find("eyeId");
  // const IndexMap::const_iterator iterPixel = componentIndex.find("pixelId");
  
  if (iterTel == componentIndex.end() || 
      iterEye == componentIndex.end()) {
    
    if (IsReportingErrors()) {
      INFO(string("Request with two indices, "
                  "none of them specifies 'telescopeId' and 'eyeId'; ") +
           QueryInfoMessage(componentProperty, modelType, componentIndex));
    }
    
  } else {

    // condensed stupid index
    telescopeId = iterEye->second + " " + iterTel->second;
  }
  
  IndexMap componentAtts;
  
  const IndexMap::const_iterator iterMirrorSeg = componentIndex.find("mirrorSegmentId");
  if (iterMirrorSeg != componentIndex.end())
    componentAtts["mirrorSegmentId"] = iterMirrorSeg->second;

  const IndexMap::const_iterator iterCorrectorId = componentIndex.find("correctorId");
  if (iterCorrectorId != componentIndex.end())
    componentAtts["size"] = iterCorrectorId->second;

  IndexMap modelMap;
  const map<string, IndexMap>::const_iterator iModelMap = fTelescopeModelMap.find(telescopeId);
  if (iModelMap != fTelescopeModelMap.end())
    modelMap = iModelMap->second;

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

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

  if (!fBranch)
    return fBranch;

  Branch modelsB = fBranch.GetChild("telescopeModels");
  if (!modelsB)
    return modelsB;

  Branch modelB = modelsB.GetChild(modelType, atts);
  if (!modelB)
    return modelB;

  // First, attempt to find the dataB without providing componentAtts map
  // to further specify a component.  componentAtts is currently used to 
  // identify a particular mirror segment in a telescope or to 
  // distinguish between telescope with and without corrector lens.
  Branch dataB = modelB.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 = modelB.GetChild(componentProperty, componentAtts);

  return dataB;
}


void
FModelsXMLManager::FillMaps()
{
  // fill fTelescopeIdMap from DetectorConfig file
  // Parse information between <telescopeConfig> tags and fill 
  // fTelescopeModelMap
  Branch configB = fBranch.GetChild("telescopeConfig");

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

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

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

    }

    // loop on eyes (to which this model applies)
    Branch eyesB = protoB.GetChild("eyes");
    for (Branch eyeB = eyesB.GetFirstChild();
         eyeB; eyeB = eyeB.GetNextSibling()) {

      IndexMap atts = eyeB.GetAttributes();
      const string eyeIdString = atts.find("id")->second;

      // loop on telescopes (to which this model applies)
      Branch telescopesB = eyeB.GetChild("telescopes");
      for (Branch telB = telescopesB.GetFirstChild();
           telB; telB = telB.GetNextSibling()) {

        IndexMap atts2 = telB.GetAttributes();
        const string telescopeIdString =
          eyeIdString + " " + atts2.find("id")->second;

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