FFixOpticalEfficiencyLossManager.cc

Go to the documentation of this file.

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

#include <boost/lexical_cast.hpp>

#include <fdet/FFixOpticalEfficiencyLossManager.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("FFixOpticalEfficiencyLossManager", FFixOpticalEfficiencyLossManager);


void
FFixOpticalEfficiencyLossManager::Init(const std::string& configLink)
{
  fHasDefaultOpticalEfficiencyCorrection = false;
  VManager::Init(configLink);
  Initialize();
  ostringstream info;
  if (fHasDefaultOpticalEfficiencyCorrection)
    info << "fixed optical efficiency correction is " << fOpticalEfficiencyCorrection;
  else
    info << " no default fixed optical efficiency correction";

  if (!fPerTelescopeOpticalEfficiencyCorrection.empty()) {
    for (map<int, map<int, double> >::const_iterator eyeIt = fPerTelescopeOpticalEfficiencyCorrection.begin(),
         eyeEnd = fPerTelescopeOpticalEfficiencyCorrection.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;

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


void
FFixOpticalEfficiencyLossManager::Initialize()
{
  Branch defaultOpticalEffBranch = fBranch.GetChild("fixedOpticalEfficiencyCorrection");
  if (defaultOpticalEffBranch) {
    defaultOpticalEffBranch.GetData(fOpticalEfficiencyCorrection);
    fHasDefaultOpticalEfficiencyCorrection = true;
  } else
    fHasDefaultOpticalEfficiencyCorrection = false;

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

    Branch opticalEffBranch = perTel.GetFirstChild();
    while (opticalEffBranch) {
      double opticalEff = 0;
      opticalEffBranch.GetData(opticalEff);

      const AttributeMap& attrs = opticalEffBranch.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("telescopeOpticalEfficiencyCorrection 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);
      fPerTelescopeOpticalEfficiencyCorrection[eyeId][telId] = opticalEff;

      opticalEffBranch = opticalEffBranch.GetNextSibling();
    }

  } // end have optical eff correction per-tel

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


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

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


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

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

  returnData.clear();

  if (componentProperty == "pixel_optical_efficiency_corrections") {
    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 opticalEff = 0;
    if (GetOpticalEfficiencyCorrectionForTelescope(eyeId, telId, opticalEff)) {

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

      return eFound;
    }
  }

  return eNotFound;
}


bool
FFixOpticalEfficiencyLossManager::GetOpticalEfficiencyCorrectionForTelescope(const unsigned int eyeId,
                                            const unsigned int telId,
                                            double& value)
  const
{
  map<int, map<int, double> >::const_iterator eyeIt = fPerTelescopeOpticalEfficiencyCorrection.find(eyeId);
  if (eyeIt == fPerTelescopeOpticalEfficiencyCorrection.end()) {
    if (fHasDefaultOpticalEfficiencyCorrection) {
      value = fOpticalEfficiencyCorrection;
      return true;
    } else
      return false;
  }

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

  value = telIt->second;
  return true;
}


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


VManager::Status
FFixOpticalEfficiencyLossManager::GetData(int& returnData,
                          const string& componentProperty,
                          const string& componentName,
                          const IndexMap&)
  const
{
  // this manager only knows about fd_optical_efficiency
  if (componentName != "fd_optical_efficiency")
    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/FFixOpticalEfficiencyLossManager.o -k"
// End: