FDetector/Telescope.h

Go to the documentation of this file.

#ifndef _fdet_Telescope_h_
#define _fdet_Telescope_h_

#include <det/ValidityStamp.h>
#include <utl/CoordinateSystem.h>
#include <utl/TabulatedFunction.h>
#include <utl/IteratorRange.h>

#include <map>
#include <string>
#include <vector>


namespace utl {
  class Point;
  class Vector;
  class TimeStamp;
}

namespace det {
  class Detector;
}

namespace fevt {
  class Pixel;
}

namespace fdet {

  class Channel;
  class Diaphragm;
  class Filter;
  class Corrector;
  class Mirror;
  class Camera;
  class Eye;
  class Pixel;


  class Telescope {

  private:
    // I beg nobody will ever think of a different camera geometry --RU ~2005
    //
    // I beg nobody will ever think of a camera geometry that can't be
    // described with a number of columns and rows --Steffen 2009
    //
    // last remaining hardcoded properties
    static const unsigned int kFirstChannel = 1;
    static const unsigned int kLastChannel = 480;

  public:
    const std::string& GetConfigSignature(const std::string& module) const;
    const std::string& GetConfigSignatureStr(const std::string& module) const;

    utl::Point GetPosition() const;
    utl::Vector GetAxis() const;

    utl::CoordinateSystemPtr GetTelescopeCoordinateSystem() const;

    unsigned int GetId() const { return fTelescopeId; }
    unsigned int GetEyeId() const { return fEyeId; }

    unsigned int GetParentPhysicalEyeId() const
    { return fIdOfParentPhysicalEye == 0 ? fEyeId : fIdOfParentPhysicalEye; }

    unsigned int GetParentPhysicalId() const
    { return fIdOfParentPhysicalEye == 0 ? fTelescopeId : fIdOfParentPhysicalTelescope; }

    const std::string& GetParentPhysicalEyeIdString() const
    { return fIdOfParentPhysicalEye == 0 ? fEyeIdString : fIdOfParentPhysicalEyeString; }

    const std::string& GetParentPhysicalIdString() const
    { return fIdOfParentPhysicalEye == 0 ? fTelescopeIdString : fIdOfParentPhysicalTelescopeString; }

    bool IsVirtual() const { return fIdOfParentPhysicalEye != 0; }

    const Channel& GetChannel(const unsigned int channelId) const;
    const Channel& GetChannel(const fdet::Pixel& p) const;
    const Channel& GetChannel(const fevt::Pixel& p) const;
    const Pixel& GetPixel(const unsigned int pixelId) const;
    const Pixel& GetPixel(const unsigned int row, const unsigned int col) const;

    bool HasCorrectorRing() const;

    const Diaphragm& GetDiaphragm() const;

    const Filter& GetFilter() const;

    const Corrector& GetCorrector() const;

    const Mirror& GetMirror() const;

    const Camera& GetCamera() const;

    const utl::TimeStamp& GetCommissionTime() const;

    const utl::TimeStamp& GetDecommissionTime() const;

    double GetDiaphragmArea() const;
    double GetDiaphragmRadius() const;

    unsigned int GetFirstPixelId() const { return 1; }
    unsigned int GetLastPixelId() const;

    unsigned int GetFirstChannelId() const { return kFirstChannel; }
    unsigned int GetLastChannelId() const { return kLastChannel; }

    unsigned int GetFirstRow() const;
    unsigned int GetFirstColumn() const;
    unsigned int GetLastRow() const;
    unsigned int GetLastColumn() const;

    utl::Vector GetCameraPixelDirection(const unsigned int pixelId) const;
    utl::Vector GetCameraPixelDirection(const unsigned int row, const unsigned int col) const;

    double GetModelRelativeEfficiency(const double wl) const;
    double GetModelMeanEfficiency(const std::string& configSignature, const double wl) const;

    double GetMeasuredRelativeEfficiency(const double wl) const;
    const utl::TabulatedFunction& GetMeasuredRelativeEfficiency() const;

    typedef std::vector<utl::Vector>::const_iterator OutOfBorderPixelsIterator;

    OutOfBorderPixelsIterator OutOfBorderPixelsBegin() const;
    OutOfBorderPixelsIterator OutOfBorderPixelsEnd() const;
    OFFLINE_DECLARE_CONST_ITERATOR_RANGE(OutOfBorderPixelsIterator, OutOfBorderPixels);

    // dynamic properties
    double GetUpTimeFraction() const;
    bool IsInAquisition() const;
    int GetDAQStatus() const;

    std::string GetTelescopePointingId() const;

    typedef std::map<std::string, double> PointingAngleSet;
    PointingAngleSet GetTelescopePointingPhi() const;
    PointingAngleSet GetTelescopePointingElevation() const;

    double GetModelMinWavelength() const;
    double GetModelMaxWavelength() const;

    void CachePixelCalibrations() const;

    void CachePixelOpticalEfficiencyCorrections() const;

    bool CachePixelCloudData() const;

    void UpdateFdUpTime() const;

  protected:
    double GetModelWavelengthDependence(const double wl) const;

  private:
    typedef std::map<unsigned int, const Channel*> InternalChannelCollection;
    typedef std::map<unsigned int, Pixel*> InternalPixelCollection;
    typedef std::vector<utl::Vector> InternalPixelDirCollection;

    void CacheTelescopePointing() const;
    Telescope(const unsigned int eyeId, const unsigned int telescopeId);
    ~Telescope();

    Telescope(const Telescope& tel);
    Telescope& operator=(const Telescope& tel);

    void Update();

    void GenerateOutOfBorderPixels() const;

    template<typename T>
    inline const T& GetTelescopeData(T*& requestedData,
                                     const std::string& property,
                                     const std::string& component,
                                     const std::string& errorMsg) const;

    template<typename T>
    inline void GetTelescopeData(T& requestedData,
                                 const std::string& property,
                                 const std::string& component,
                                 const std::string& errorMsg) const;

    mutable InternalChannelCollection fChannel;
    mutable InternalPixelCollection fPixel;

    unsigned int fEyeId = 0;
    unsigned int fTelescopeId = 0;
    std::string fEyeIdString;
    std::string fTelescopeIdString;

    // Quantities filled by lazy evaluation
    mutable int fIdOfParentPhysicalEye = -1;
    mutable int fIdOfParentPhysicalTelescope = -1;
    std::string fIdOfParentPhysicalEyeString;
    std::string fIdOfParentPhysicalTelescopeString;

    mutable std::string* fConfigSignatureStr = nullptr;
    mutable std::string* fConfigSignature = nullptr;
    mutable std::string fConfigSignatureModule;

    mutable utl::Point* fPosition = nullptr;
    mutable utl::Vector* fAxis = nullptr;
    mutable utl::CoordinateSystemPtr fCoordinateSystem;

    mutable utl::TimeStamp* fCommissionTime = nullptr;
    mutable utl::TimeStamp* fDecommissionTime = nullptr;

    mutable utl::TabulatedFunction* fMeasuredRelativeEfficiency = nullptr;

    mutable std::string* fTelPointingId = nullptr;

    mutable PointingAngleSet* fTelPointingPhiMap = nullptr;
    mutable PointingAngleSet* fTelPointingElevationMap = nullptr;

    mutable InternalPixelDirCollection fOutBorderPixelsDir;

    mutable Diaphragm* fDiaphragm = nullptr;

    mutable Mirror* fMirror = nullptr;

    mutable Filter* fFilter = nullptr;

    mutable Corrector* fCorrector = nullptr;

    mutable Camera* fCamera = nullptr;

    // up time info
    mutable det::ValidityStamp fUpTimeValidityStamp;
    mutable double fUpTimeFraction = 0;
    mutable int fStatus = 0;

    mutable std::map<int, utl::TabulatedFunction> fCalibMap;
    mutable std::map<int, utl::TabulatedFunction> fOpticalEfficiencyMap;
    mutable det::ValidityStamp fCalibValidityStamp;
    mutable det::ValidityStamp fOpticalEfficiencyValidityStamp;

    friend class Eye;

  };

}


#endif