Diaphragm.cc

Go to the documentation of this file.

#include <sstream>

#include <boost/lexical_cast.hpp>

#include <fdet/Diaphragm.h>

#include <utl/Reader.h>
#include <utl/ErrorLogger.h>
#include <utl/MathConstants.h>
#include <utl/Math.h>
#include <utl/UTCDateTime.h>

#include <det/VManager.h>
#include <det/Detector.h>
#include <fdet/FDetector.h>
#include <fdet/Eye.h>
#include <fdet/Telescope.h>

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


Diaphragm::Diaphragm(const unsigned int eyeId, const unsigned int telId,
                     const std::string& physEyeIdString,
                     const std::string& physTelIdString) :
  fEyeId(eyeId),
  fTelescopeId(telId),
  fPhysicalEyeIdString(physEyeIdString),
  fPhysicalTelescopeIdString(physTelIdString),
  fRadius(0),
  fArea(0),
  fCorrectorRingCommissionTime(0)
{
}


Diaphragm::~Diaphragm()
{
  delete fRadius;
  delete fCorrectorRingCommissionTime;
}

void Diaphragm::Update() {

  delete fRadius;
  fRadius = 0;

  delete fArea;
  fArea = 0;

  delete fCorrectorRingCommissionTime;
  fCorrectorRingCommissionTime = 0;
}


double
Diaphragm::GetRadius()
  const
{
  return GetDiaphragmData(fRadius, "radius", "diaphragm", "radius of diaphragm");
}


double
Diaphragm::GetArea()
  const
{
  return kPi*Sqr(GetRadius());
}


bool
Diaphragm::HasCorrectorRing()
  const
{
  if (!fCorrectorRingCommissionTime) {
    string timeString;
    GetDiaphragmData(timeString, "CorrectorRingCommission", "telescope",
                     "Corrector ring commission time");
    fCorrectorRingCommissionTime =
      new TimeStamp(boost::lexical_cast<UTCDateTime>(timeString).GetTimeStamp());
  }

  return *fCorrectorRingCommissionTime < det::Detector::GetInstance().GetTime();
}


template<typename T>
inline
const T&
Diaphragm::GetDiaphragmData(T*& requestedData, 
                            const std::string& property,
                            const std::string& component,
                            const std::string& errorMsg)
  const
{
  if (!requestedData) {
    requestedData = new T;
    GetDiaphragmData(*requestedData, property, component, errorMsg);
  }
  return *requestedData;
}


template<typename T>
inline
void
Diaphragm::GetDiaphragmData(T& requestedData,
                            const std::string& property,
                            const std::string& component,
                            const std::string& errorMsg)
  const
{  
  const VManager& manager = Detector::GetInstance().GetFManagerRegister();

  det::VManager::IndexMap indexMap;  
  indexMap["eyeId"] = fPhysicalEyeIdString;
  indexMap["telescopeId"] = fPhysicalTelescopeIdString;

  if (property == "radius")
    indexMap["correctorId"] = (HasCorrectorRing() ? "large" : "small");

  const VManager::Status foundFlag =
    manager.GetData(requestedData, property, component, indexMap);

  if (foundFlag == VManager::eNotFound) {
    ostringstream err;
    err << "Did not find requested component for " << errorMsg << "; "
        << VManager::QueryInfoMessage(property, component, indexMap);
    ERROR(err);
    throw NonExistentComponentException(err.str());
  }
}


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