FDetector/Eye.h

Go to the documentation of this file.

#ifndef _fdet_Eye_h_
#define _fdet_Eye_h_

#include <list>
#include <set>
#include <boost/iterator/indirect_iterator.hpp>
#include <boost/iterator/filter_iterator.hpp>

#include <utl/CoordinateSystemPtr.h>

#include <det/ValidityStamp.h>

namespace utl {
  class Point;
  class TabulatedFunction;
  class TimeInterval;
}

namespace det{
  class Detector;
}


namespace fdet {

  class Telescope;
  class FDetector;

  struct TelIsCommissioned {
    bool operator()(const fdet::Telescope& tel) const;
  };


  class Eye {

  private:
    typedef std::list<int> FullTelescopeIdList;
    typedef std::list<Telescope*> FullTelescopeList;
    typedef FullTelescopeList::iterator FullTelescopeIterator;
    typedef FullTelescopeList::const_iterator FullTelescopeConstIterator;

    typedef boost::indirect_iterator<FullTelescopeIterator,
                                     Telescope&> InternalTelescopeIterator;
    typedef boost::indirect_iterator<FullTelescopeConstIterator,
                                     const Telescope&> InternalConstTelescopeIterator;

    InternalTelescopeIterator FullTelescopesBegin()
    { return InternalTelescopeIterator(fFullTelescopeList.begin()); }
    InternalConstTelescopeIterator FullTelescopesBegin() const
    { return InternalConstTelescopeIterator(fFullTelescopeList.begin()); }
    InternalTelescopeIterator FullTelescopesEnd()
    { return InternalTelescopeIterator(fFullTelescopeList.end()); }
    InternalConstTelescopeIterator FullTelescopesEnd() const
    { return InternalConstTelescopeIterator(fFullTelescopeList.end()); }

  public:
    unsigned int GetFirstTelescopeId() const;

    unsigned int GetLastTelescopeId() const;

    typedef boost::filter_iterator<TelIsCommissioned,
                                   InternalConstTelescopeIterator> TelescopeIterator;

    TelescopeIterator TelescopesBegin() const
    { return TelescopeIterator(TelIsCommissioned(), FullTelescopesBegin(), FullTelescopesEnd()); }

    TelescopeIterator TelescopesEnd() const
    { return TelescopeIterator(TelIsCommissioned(), FullTelescopesEnd(), FullTelescopesEnd()); }

    const Telescope& GetTelescope(const unsigned int telescopeId) const;

    utl::Point GetPosition() const;


    utl::CoordinateSystemPtr GetEyeCoordinateSystem() const;


    utl::CoordinateSystemPtr GetLocalCoordinateSystem() const;

    double GetBackwallAngle() const;

    const std::string& GetName() const;
    const std::string& GetNameAbbr() const;

    unsigned int GetId() const { return fEyeId; }

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

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

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

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

    const utl::TabulatedFunction& GetTimeCorrectionFactors() const;
    const utl::TimeInterval& GetSDTimeOffset() const;

    double GetUpTimeFraction() const;
    double GetFDASVetoFraction() const;
    double GetCDASVetoFraction() const;
    bool IsInAquisition() const;
    int GetDAQStatus() const;

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

  private:
    Eye(const unsigned int eyeId);
    ~Eye();
    Eye(const Eye&);
    Eye& operator=(const Eye&);

    void Update();

    void GetFullTelescopeList() const;
    void UpdateFdUpTime() const;

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

    unsigned int fEyeId;
    // Id held also as a string as that is what is passed through the manager interface
    std::string fEyeIdString;

    // If this is > 0, we have a virtual eye
    mutable int fIdOfParentPhysicalEye;
    std::string fIdOfParentPhysicalEyeString;

    mutable FullTelescopeList fFullTelescopeList;

    // List of all Telescopes available in the external sources
    // (external sources are, for example, the XML files containing
    // the telescope/eye list or perhaps at some point a MySQL database
    mutable FullTelescopeIdList* fFullTelescopeIdList;

    // Quantities filled by lazy evaluation
    // ------------------------------------
    mutable utl::Point* fPosition;
    mutable std::string* fName;
    mutable std::string* fNameAbbr;
    mutable utl::CoordinateSystemPtr fCoordinateSystem;
    mutable double* fBackwallAngle; // angle of the back wall from the east
    mutable utl::TabulatedFunction* fTimeCorrectionFactors;
    mutable utl::TimeInterval* fSDTimeOffset;

    // up time info
    mutable det::ValidityStamp fUpTimeValidityStamp;
    mutable double fUpTimeFraction;
    mutable double fCDASVetoFraction;
    mutable double fFDASVetoFraction;
    mutable int fStatus;

    friend class FDetector;

  };

}


#endif

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