FFixCalibManager.cc

Go to the documentation of this file.

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

#include <boost/lexical_cast.hpp>

#include <fdet/FFixCalibManager.h>
#include <fwk/CentralConfig.h>
#include <det/Detector.h>

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

#include <fdet/FManagerRegister.h>
#include <fdet/FDetector.h>
#include <fdet/Telescope.h>

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


REGISTER_F_MANAGER("FFixCalibManager", FFixCalibManager);


void
FFixCalibManager::Init(const std::string& configLink)
{
  fHasDefaultCalibConst = false;
  VManager::Init(configLink);
  Initialize();
  ostringstream info;
  if (fHasDefaultCalibConst)
    info << "fixed calibration constant is " << fCalibConst << " ph/ADC";
  else
    info << " no default fixed calibration constant";

  if (!fPerTelescopeCalibConst.empty()) {
    for (map<int, map<int, double> >::const_iterator eyeIt = fPerTelescopeCalibConst.begin(),
         eyeEnd = fPerTelescopeCalibConst.end(); eyeIt != eyeEnd; ++eyeIt) {

      for (map<int, double>::const_iterator telIt = eyeIt->second.begin(),
           telEnd = eyeIt->second.end(); telIt != telEnd; ++telIt) {

        info << "\n    Override eye " << eyeIt->first << " tel " << telIt->first
             << ": " << telIt->second << " ph/ADC";

      } // end for tels
    } // end for eyes
  } // end if have per-tel calib
  INFO(info);
}


void
FFixCalibManager::Initialize()
{
  Branch defaultCalConstBranch = fBranch.GetChild("fixedCalibrationConstant");
  if (defaultCalConstBranch) {
    defaultCalConstBranch.GetData(fCalibConst);
    fHasDefaultCalibConst = true;
  } else
    fHasDefaultCalibConst = false;

  const Branch& perTel = fBranch.GetChild("perTelescope");
  if (perTel) {

    Branch caliBranch = perTel.GetFirstChild();
    while (caliBranch) {
      double caliConst = 0;
      caliBranch.GetData(caliConst);

      const AttributeMap& attrs = caliBranch.GetAttributes();
      AttributeMap::const_iterator attrEnd = attrs.end();
      AttributeMap::const_iterator eyeIdIt = attrs.find("eyeId");
      AttributeMap::const_iterator telIdIt = attrs.find("telId");
      if (eyeIdIt == attrEnd || telIdIt == attrEnd) {
        ERROR("telescopeCalibrationConstant tag is missing eyeId or telId attributes!");
        break;
      }
      const int eyeId = boost::lexical_cast<int>(eyeIdIt->second);
      const int telId = boost::lexical_cast<int>(telIdIt->second);
      fPerTelescopeCalibConst[eyeId][telId] = caliConst;

      caliBranch = caliBranch.GetNextSibling();
    }

  } // end have calib per-tel

  // list of properties
  //fAvailableComponents.insert("pixel_t_offset");
  fAvailableComponents.insert("pixel_calibs");
  fAvailableComponents.insert("status");
  fAvailableComponents.insert("start_time");
  fAvailableComponents.insert("end_time");
  // elecgain
  // status
}


VManager::Status
FFixCalibManager::GetData(double& /*returnData*/,
                          const string& componentProperty,
                          const string& componentName,
                          const IndexMap&)
  const
{
  // this manager only knows about fd_calib
  if (componentName != "fd_calib")
    return eNotFound;

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

  return eNotFound;
}


VManager::Status
FFixCalibManager::GetData(map<int, utl::TabulatedFunction>& returnData,
                          const string& componentProperty,
                          const string& componentName,
                          const IndexMap& componentIndex)
  const
{
  // this manager only knows about fd_calib
  if (componentName != "fd_calib")
    return eNotFound;

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

  returnData.clear();

  if (componentProperty == "pixel_calibs") {
    const fdet::FDetector& fdet = det::Detector::GetInstance().GetFDetector();
    const double wavelength = fdet.GetReferenceLambda();

    const string& eyeIdString = componentIndex.find("eyeId")->second;
    const string& telescopeIdString = componentIndex.find("telescopeId")->second;
    const int eyeId = boost::lexical_cast<int>(eyeIdString);
    const int telId = boost::lexical_cast<int>(telescopeIdString);

    double calibConst = 0;
    if (GetCalibConstForTelescope(eyeId, telId, calibConst)) {

      for (int iPix = 1; iPix <= 440; ++iPix) {
        TabulatedFunction calVsWavelength;
        calVsWavelength.PushBack(wavelength, calibConst);
        returnData.insert(make_pair(iPix, calVsWavelength));
      }

      return eFound;
    }
  }

  return eNotFound;
}


bool
FFixCalibManager::GetCalibConstForTelescope(const unsigned int eyeId,
                                            const unsigned int telId,
                                            double& value)
  const
{
  map<int, map<int, double> >::const_iterator eyeIt = fPerTelescopeCalibConst.find(eyeId);
  if (eyeIt == fPerTelescopeCalibConst.end()) {
    if (fHasDefaultCalibConst) {
      value = fCalibConst;
      return true;
    } else
      return false;
  }

  map<int, double>::const_iterator telIt = eyeIt->second.find(telId);
  if (telIt == eyeIt->second.end()) {
    if (fHasDefaultCalibConst) {
      value = fCalibConst;
      return true;
    } else
      return false;
  }

  value = telIt->second;
  return true;
}


VManager::Status
FFixCalibManager::GetData(vector<int>& returnData,
                          const string& componentProperty,
                          const string& componentName,
                          const IndexMap& /*componentIndex*/)
  const
{
  if (componentProperty != "status" || componentName != "fd_calib")
    return eNotFound;
  returnData.clear();
  returnData.resize(441, 0);  // eGood
  return eFound;
}


VManager::Status
FFixCalibManager::GetData(int& returnData,
                          const string& componentProperty,
                          const string& componentName,
                          const IndexMap&)
  const
{
  // this manager only knows about fd_calib
  if (componentName != "fd_calib")
    return eNotFound;

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

  if (componentProperty == "start_time") {
    // very early
    returnData = UTCDateTime(2000, 1, 1).GetTimeStamp().GetGPSSecond();
    return eFound;
  }

  if (componentProperty == "end_time") {
    // very late
    returnData = UTCDateTime(2037, 11, 30).GetTimeStamp().GetGPSSecond();
    return eFound;
  }

  return eNotFound;
}


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