FdChannelMappingManager.cc

Go to the documentation of this file.

#include <sstream>
#include <string>
#include <set>
#include <map>
#include <utility>
#include <algorithm>

#include <boost/lexical_cast.hpp>

#include <utl/Reader.h>
#include <utl/TimeStamp.h>
#include <utl/ErrorLogger.h>
#include <utl/AugerException.h>

#include <fwk/CentralConfig.h>

#include <det/Detector.h>
#include <det/ValidityStamp.h>

#include <fdet/FDetector.h>
#include <fdet/FdChannelMappingManager.h>

#include <TFile.h>
#include <TTree.h>
#include <TDirectory.h>

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


REGISTER_F_MANAGER("FdChannelMappingManager", FdChannelMappingManager);


FdChannelMappingManager::FdChannelMappingManager()
{ }


FdChannelMappingManager::~FdChannelMappingManager()
{ }


void
FdChannelMappingManager::Init(const std::string& configLink)
{
  VManager::Init(configLink);

  // parse XML
  if (!FillMaps()) {
    ERROR_TERSE("error during init!");
    throw(NoDataForModelException("FdChannelMappingManager"));
  }

  // list of properties
  fPropertiesList.insert("channel_mapping");
  fPropertiesList.insert("pixel_mapping");
}


VManager::Status
FdChannelMappingManager::GetMapping(int& returnData,
                                    const string& componentProperty,
                                    const string& componentName,
                                    const IndexMap& componentIndex)
  const
{  
  // check component availability
  if (componentName != "electronics")
    return eNotFound;

  // check property availability
  if (fPropertiesList.find(componentProperty) == fPropertiesList.end())
    return eNotFound;

  // check size of index map
  if (componentIndex.size() != 3)
    return eNotFound;

  // retrive the component indices
  const IndexMap::const_iterator iEyeId =
    componentIndex.find("eyeId");
  const IndexMap::const_iterator iTelId =
    componentIndex.find("telescopeId");
  if (iEyeId == componentIndex.end() || iTelId == componentIndex.end()) {
    INFO("Called FdChannelMappingManager with wrong number of arguments!");
    return eNotFound;
  }

  const int eyeId = boost::lexical_cast<int>(iEyeId->second);
  const int telId = boost::lexical_cast<int>(iTelId->second);
  const int indexEyeTel = eyeId*6*440 + telId*440;

  IndexMap::const_iterator iId;
  if (componentProperty == "channel_mapping")
    iId = componentIndex.find("channelId");
  else if (componentProperty == "pixel_mapping")
    iId = componentIndex.find("pixelId");
  else {
    INFO("Called FdChannelMappingManager with missing pixelId/channelId!");
    return eNotFound;
  }
  const int id = boost::lexical_cast<int>(iId->second);
  const int dataId = indexEyeTel + id;

  returnData = id;  // default return is pixelid=chanelId

  for (ConstPeriodIterator iPeriod = fPeriods.begin();
       iPeriod != fPeriods.end(); ++iPeriod) {

    if (!iPeriod->validity.IsValid())
      continue;

    if (componentProperty == "channel_mapping") {
      const Mapping& channelMapping = iPeriod->channels;
      const map<int, int>::const_iterator iMapping =
        channelMapping.find(dataId);
      if (iMapping != channelMapping.end()) {
        returnData = iMapping->second;  // REMAP
        break;
      }
    }

    if (componentProperty == "pixel_mapping") {
      const Mapping& pixelMapping = iPeriod->pixels;
      const map<int, int>::const_iterator iMapping =
        pixelMapping.find(dataId);
      if (iMapping != pixelMapping.end()) {
        returnData = iMapping->second;
        break;
      }
    }
    
  }

  return eFound;
}
  
  
  
bool
FdChannelMappingManager::FillMaps()
{  
  fPeriods.clear();

  Branch topB =
    fwk::CentralConfig::GetInstance()->GetTopBranch("FdChannelMappingManager");

  for (Branch cB = topB.GetFirstChild(); cB; cB = cB.GetNextSibling()) {

    int eyeId;
    cB.GetChild("eye").GetData(eyeId);
    int telId;
    cB.GetChild("telescope").GetData(telId);
    const int indexEyeTel = eyeId*6*440 + telId*440;
    utl::TimeStamp begin;
    cB.GetChild("begin").GetData(begin);
    utl::TimeStamp end;
    cB.GetChild("end").GetData(end);
    det::ValidityStamp validity(begin, end);

    Mapping pixelMapping;
    Mapping channelMapping;

    for (Branch b = cB.GetChild("mapping").GetFirstChild();
         b; b = b.GetNextSibling()) {
      
      const AttributeMap atts = b.GetAttributes();
      const int pixelId = boost::lexical_cast<int>(atts.find("id")->second);

      int channelId;
      b.GetChild("channel").GetData(channelId);

      // check for double existence of pixels/channels
      if (pixelMapping.count(indexEyeTel + pixelId) ||
          channelMapping.count(indexEyeTel + channelId)) {
        ERROR_TERSE("double existance of pixels/channels");
        return false;
      }

      pixelMapping[indexEyeTel + pixelId] = channelId;
      channelMapping[indexEyeTel + channelId] = pixelId;

    }

    // consitency check
    for (ConstMappingIterator iPixel = pixelMapping.begin();
         iPixel != pixelMapping.end(); ++iPixel) {

      // check if each pixel has a channel (nothing is lost)
      const int pixelId = iPixel->first;
      ConstMappingIterator iChannel = channelMapping.find(pixelId);
      if (iChannel == channelMapping.end()) {
        ERROR_TERSE("Wrong pixel mapping!");
        return false;
      }
    }

    Period mappingPeriod;
    mappingPeriod.validity = validity;
    mappingPeriod.pixels = pixelMapping;
    mappingPeriod.channels = channelMapping;
    fPeriods.push_back(mappingPeriod);

  }

  return true;
}


// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// compile-command: "make -C .. -k"
// End: