FDetector/Eye.cc

Go to the documentation of this file.

#include <sstream>

#include <boost/lexical_cast.hpp>

#include <fdet/Telescope.h>
#include <fdet/Eye.h>

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

#include <utl/UTMPoint.h>
#include <utl/Point.h>
#include <utl/ReferenceEllipsoid.h>
#include <utl/Transformation.h>
#include <utl/Vector.h>
#include <utl/ErrorLogger.h>
#include <utl/Deprecator.h>

#include <fwk/CoordinateSystemRegistry.h>
#include <fwk/LocalCoordinateSystem.h>

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


bool
TelIsCommissioned::operator()(const fdet::Telescope& tel)
  const
{
  const TimeStamp& dTime = det::Detector::GetInstance().GetTime();
  return tel.GetCommissionTime() < dTime && dTime < tel.GetDecommissionTime();
}


//=============================================================================


Eye::Eye(unsigned int eyeId) :
  fEyeId(eyeId),
  //fEyeIdString(),
  fIdOfParentPhysicalEye(-1),
  fFullTelescopeIdList(0),
  fPosition(0),
  fName(0),
  fNameAbbr(0),
  fCoordinateSystem(),
  fBackwallAngle(0),
  fTimeCorrectionFactors(0),
  fSDTimeOffset(0),
  fUpTimeFraction(0),
  fStatus(0)
{
  fEyeIdString = boost::lexical_cast<string>(eyeId);
}


Eye::~Eye()
{
  delete fName;
  delete fNameAbbr;
  delete fBackwallAngle;
  delete fPosition;
  delete fFullTelescopeIdList;
  delete fTimeCorrectionFactors;

  for (FullTelescopeIterator it = fFullTelescopeList.begin();
       it != fFullTelescopeList.end(); ++it)
    delete *it;

  delete fSDTimeOffset;
}


unsigned int
Eye::GetFirstTelescopeId()
  const
{
  if (!fFullTelescopeIdList)
    return 0;
  return *std::min_element(fFullTelescopeIdList->begin(), fFullTelescopeIdList->end());
}


unsigned int
Eye::GetLastTelescopeId()
  const
{
  if (!fFullTelescopeIdList)
    return 0;
  return *std::max_element(fFullTelescopeIdList->begin(), fFullTelescopeIdList->end());
}


double
Eye::GetUpTimeFraction()
  const
{
  UpdateFdUpTime();
  return fUpTimeFraction;
}

double
Eye::GetFDASVetoFraction()
  const
{
  UpdateFdUpTime();
  return fFDASVetoFraction;
}

double
Eye::GetCDASVetoFraction()
  const
{
  UpdateFdUpTime();
  return fCDASVetoFraction;
}
bool
Eye::IsInAquisition()
  const
{
  UpdateFdUpTime();
  return fUpTimeFraction > 0;
}


int
Eye::GetDAQStatus()
  const
{
  UpdateFdUpTime();
  return fStatus;
}


void
Eye::UpdateFdUpTime()
  const
{
  if (fUpTimeValidityStamp.IsValid())
    return;

  int startTime;
  GetEyeData(startTime, "uptime_gpsStart", "eye", "start validity eye up time");
  int endTime;
  GetEyeData(endTime, "uptime_gpsStop", "eye", "end validity eye up time");
  GetEyeData(fUpTimeFraction, "uptime_fraction", "eye", "eye up time fraction");
  GetEyeData(fFDASVetoFraction, "veto_fraction", "eye", "eye veto fraction");
  GetEyeData(fCDASVetoFraction, "veto_fraction", "CDAS", "CDAS per eye veto fraction");
  GetEyeData(fStatus, "status", "eye", "eye DAQ status");
  fUpTimeValidityStamp.SetValidityInterval(startTime, endTime);
}


void
Eye::Update()
{
  // Get all telescopes indicated in the XML file
  // and construct telescopes (uses lazy evaluation).
  GetFullTelescopeList();

  if (fIdOfParentPhysicalEye < 0) {
    fIdOfParentPhysicalEye = 0; // default to being a physical eye
    GetEyeData(fIdOfParentPhysicalEye, "parentEye", "virtualEye",
               "parent eye id of virtual eye");

    fIdOfParentPhysicalEyeString
      = boost::lexical_cast<string>(fIdOfParentPhysicalEye);
  }

  //  typedef FullTelescopeList::iterator fullIt;
  for (InternalTelescopeIterator it = FullTelescopesBegin(); it != FullTelescopesEnd(); ++it)
    it->Update();
}


const Telescope&
Eye::GetTelescope(unsigned int telescopeId)
  const
{
  for (TelescopeIterator it = TelescopesBegin(); it != TelescopesEnd(); ++it)
    if (telescopeId == it->GetId())
      return *it;

  ostringstream err;
  err << "Telescope with Id = " << telescopeId << " "
         "for Eye " << fEyeIdString << " "
         "is not commissioned at detector time = "
      << Detector::GetInstance().GetTime();
  ERROR(err);
  throw utl::NonExistentComponentException(err.str());
}


Point
Eye::GetPosition()
  const
{
  if (!fPosition) {
    // WARNING("Consider using Telescope::GetPosition. It is in general more accurate. ");
    double northing;
    GetEyeData(northing, "northing", "eye", "eye position northing");
    double easting;
    GetEyeData(easting, "easting", "eye", "eye position easting");
    double altitude;
    GetEyeData(altitude, "altitude", "eye", "eye position altitude");
    int zone;
    GetEyeData(zone, "zone", "eye", "eye position zone");
    string band;
    GetEyeData(band, "band", "eye", "eye position band");

    const CoordinateSystemPtr cs = Detector::GetInstance().GetSiteCoordinateSystem();
    const ReferenceEllipsoid& e = ReferenceEllipsoid::GetWGS84();
    const UTMPoint utmp(northing, easting, altitude, zone, band.c_str()[0], e);
    fPosition = new Point(utmp.GetPoint(cs));
  }

  return *fPosition;
}


const string&
Eye::GetName()
  const
{
  return GetEyeData(fName, "name", "eye", "eye name string");
}

const string&
Eye::GetNameAbbr()
  const
{
  return GetEyeData(fNameAbbr, "nameAbbr", "eye", "eye name abbreviation string");
}

void
Eye::GetFullTelescopeList()
  const
{
  // Lazy evaluation of FullTelescopeList
  //
  if (!fFullTelescopeIdList) {

    GetEyeData(fFullTelescopeIdList, "telescopeList", "", "telescope id list");

    // Construct all telescopes
    for (FullTelescopeIdList::const_iterator it = fFullTelescopeIdList->begin();
         it != fFullTelescopeIdList->end(); ++it) {
      Telescope* const telescope = new Telescope(fEyeId, *it);
      fFullTelescopeList.push_back(telescope);
    }
  }
}


double
Eye::GetBackwallAngle()
  const
{
  return GetEyeData(fBackwallAngle, "backwallAngle", "eye", "eye backwall angle");
}


utl::CoordinateSystemPtr
Eye::GetEyeCoordinateSystem()
  const
{
  if (!fCoordinateSystem) {


    const Point pos = GetPosition();
    const CoordinateSystemPtr stdLocalCS = LocalCoordinateSystem::Create(pos);
    fCoordinateSystem = CoordinateSystem::RotationZ(GetBackwallAngle(), stdLocalCS);
  }

  return fCoordinateSystem;
}


utl::CoordinateSystemPtr
Eye::GetLocalCoordinateSystem()
  const
{
  const Point pos = GetPosition();
  return LocalCoordinateSystem::Create(pos);
}


const utl::TabulatedFunction&
Eye::GetTimeCorrectionFactors()
  const
{
  return GetEyeData(fTimeCorrectionFactors, "MHzTimeCorrection", "eye", "eye time correction factors");
}


const utl::TimeInterval&
Eye::GetSDTimeOffset()
  const
{
  if (!fSDTimeOffset) {

    double timeoffset = 0;
    GetEyeData(timeoffset, "sdTimeOffset", "eye", "eye sd time offset");
    fSDTimeOffset = new TimeInterval(timeoffset);
  }

  return *fSDTimeOffset;
}


double Eye::GetModelMinWavelength() const {
  double minWavelength = 0;
  bool first = true;
  for (InternalConstTelescopeIterator it = FullTelescopesBegin(); it != FullTelescopesEnd(); ++it) {
    if (first) {
      first = false;
      minWavelength = it->GetModelMinWavelength();
    }
    else {
      minWavelength = max(minWavelength, it->GetModelMinWavelength());
    }
  }
  return minWavelength;
}

double Eye::GetModelMaxWavelength() const {
  double maxWavelength = 0;
  bool first = true;
  for (InternalConstTelescopeIterator it = FullTelescopesBegin(); it != FullTelescopesEnd(); ++it) {
    if (first) {
      first = false;
      maxWavelength = it->GetModelMaxWavelength();
    }
    else {
      maxWavelength = min(maxWavelength, it->GetModelMaxWavelength());
    }
  }
  return maxWavelength;
}


std::set<unsigned int>
Eye::GetParticipatingEyeIds()
  const
{
  set<unsigned int> ids;

  if (!IsVirtual()) {
    ids.insert(fEyeId);
    return ids;
  }

  for (InternalConstTelescopeIterator it = FullTelescopesBegin();
       it != FullTelescopesEnd(); ++it)
    ids.insert(it->GetParentPhysicalEyeId());

  return ids;
}

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


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

  VManager::IndexMap indexMap;

  // If this is a virtual eye, fetch the information from the
  // real eye that this virtual eye resembles
  if (IsVirtual()
      && component != "virtualEye"
      && property != "telescopeList"
      && property != "name")
    indexMap["eyeId"] = fIdOfParentPhysicalEyeString;
  else
    indexMap["eyeId"] = fEyeIdString;

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

  // ERROR
  if (status == 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/Eye.o -k"
// End: