FEvent/Telescope.h

Go to the documentation of this file.

#ifndef _fevt_Telescope_h_
#define _fevt_Telescope_h_

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

#include <utl/TimeStamp.h>
#include <utl/ShadowPtr.h>
#include <utl/Vector.h>

#include <fevt/FdComponentSelector.h>
#include <fevt/TelescopeSimData.h>
#include <fevt/TelescopeRecData.h>
#include <fevt/TelescopeTriggerData.h>

#include <fdet/Camera.h>


namespace fevt {

  class Channel;
  class Pixel;


  class Telescope {

  private:
    typedef std::list<Channel*> InternalChannelContainer;
    typedef InternalChannelContainer::iterator InternalChannelIterator;
    typedef InternalChannelContainer::const_iterator InternalConstChannelIterator;

    typedef std::list<Pixel*> InternalPixelContainer;
    typedef InternalPixelContainer::iterator InternalPixelIterator;
    typedef InternalPixelContainer::const_iterator InternalConstPixelIterator;

    typedef boost::indirect_iterator<InternalPixelIterator, Pixel&> AllPixelIterator;

    typedef boost::indirect_iterator<InternalConstPixelIterator, const Pixel&> ConstAllPixelIterator;

    typedef std::vector<utl::Vector> InternalPixelDirCollection;

    AllPixelIterator AllPixelsBegin() { return AllPixelIterator(fPixels.begin()); }
    AllPixelIterator AllPixelsEnd() { return AllPixelIterator(fPixels.end()); }
    ConstAllPixelIterator AllPixelsBegin() const { return ConstAllPixelIterator(fPixels.begin()); }
    ConstAllPixelIterator AllPixelsEnd() const { return ConstAllPixelIterator(fPixels.end()); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(AllPixelIterator, ConstAllPixelIterator, AllPixels)

  public:
    Telescope(const Telescope& t) { *this = t; }
    Telescope& operator=(const Telescope& t);

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

    void Assign(const Telescope& t);

    typedef boost::indirect_iterator<InternalChannelIterator,
                                     Channel&> ChannelIterator;
    typedef boost::indirect_iterator<InternalConstChannelIterator,
                                     const Channel&> ConstChannelIterator;

    unsigned int GetNActiveChannels() const { return fChannels.size(); }
    Channel& GetChannel(const unsigned int channelId);
    const Channel& GetChannel(const unsigned int channelId) const;

    bool HasChannel(const unsigned int channelId) const;
    void MakeChannel(const unsigned int channelId);

    ChannelIterator ChannelsBegin()
    { return ChannelIterator(fChannels.begin()); }
    ChannelIterator ChannelsEnd()
    { return ChannelIterator(fChannels.end()); }
    ConstChannelIterator ChannelsBegin() const
    { return ConstChannelIterator(fChannels.begin()); }
    ConstChannelIterator ChannelsEnd() const
    { return ConstChannelIterator(fChannels.end()); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(ChannelIterator, ConstChannelIterator, Channels)

    unsigned int GetNActivePixels() const { return fPixels.size(); }

    Pixel& GetPixel(const unsigned int pixelId,
                    const ComponentSelector::Status status = ComponentSelector::eHasData);
    const Pixel& GetPixel(const unsigned int pixelId,
                          const ComponentSelector::Status status = ComponentSelector::eHasData) const;
    void MakePixel(const unsigned int pixelId,
                   const ComponentSelector::Status status = ComponentSelector::eHasData);
    bool HasPixel(const unsigned int pixelId,
                  const ComponentSelector::Status status = ComponentSelector::eHasData) const;

    typedef boost::filter_iterator<ComponentSelector,
                                   AllPixelIterator> PixelIterator;
    typedef boost::filter_iterator<ComponentSelector,
                                   ConstAllPixelIterator> ConstPixelIterator;

    PixelIterator PixelsBegin();
    PixelIterator PixelsEnd();
    ConstPixelIterator PixelsBegin() const;
    ConstPixelIterator PixelsEnd() const;
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(PixelIterator, ConstPixelIterator, Pixels)

    
    PixelIterator PixelsBegin(const ComponentSelector::Status status)
    { return PixelIterator(ComponentSelector(status), AllPixelsBegin(), AllPixelsEnd()); }
    PixelIterator PixelsEnd(const ComponentSelector::Status status)
    { return PixelIterator(ComponentSelector(status), AllPixelsEnd(), AllPixelsEnd()); }
    ConstPixelIterator PixelsBegin(const ComponentSelector::Status status) const
    { return ConstPixelIterator(ComponentSelector(status), AllPixelsBegin(), AllPixelsEnd()); }
    ConstPixelIterator PixelsEnd(const ComponentSelector::Status status) const
    { return ConstPixelIterator(ComponentSelector(status), AllPixelsEnd(), AllPixelsEnd()); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES_ARG(PixelIterator, ConstPixelIterator, Pixels, const ComponentSelector::Status arg)

    
    utl::TimeStamp GetTracesStartTime() const { return fTracesStartTime; }
    void SetTracesStartTime(const utl::TimeStamp& tstamp)
    { fTracesStartTime = tstamp; }

    fevt::TelescopeSimData& GetSimData();
    const fevt::TelescopeSimData& GetSimData() const;
    void MakeSimData();
    bool HasSimData() const { return bool(fSimData); }

    fevt::TelescopeTriggerData& GetTriggerData();
    const fevt::TelescopeTriggerData& GetTriggerData() const;
    void MakeTriggerData();
    bool HasTriggerData() const { return bool(fTriggerData); }

    fevt::TelescopeRecData& GetRecData();
    const fevt::TelescopeRecData& GetRecData() const;
    void MakeRecData();
    bool HasRecData() const { return bool(fRecData); }

    unsigned int GetTimeOffset() const { return fTimeOffset; }
    void SetTimeOffset(const unsigned int toffset) { fTimeOffset = toffset; }

    std::string GetRawTelPointing() const { return fRawTelPointing; }
    void SetRawTelPointing(const std::string& pointing) { fRawTelPointing = pointing; }

    void SetStatus(const ComponentSelector::Status status) {fStatus=status;}
    ComponentSelector::Status GetStatus() const {return fStatus;}

    typedef std::vector<utl::Vector>::const_iterator ConstMirrorEventBorderPixelsIterator;
    ConstMirrorEventBorderPixelsIterator MirrorEventBorderPixelsBegin() const;
    ConstMirrorEventBorderPixelsIterator MirrorEventBorderPixelsEnd() const;
    OFFLINE_MAKE_CONST_ITERATOR_RANGE(ConstMirrorEventBorderPixelsIterator, MirrorEventBorderPixels)

  private:
    Telescope(const unsigned int eyeId, const unsigned int telescopeId,
              const ComponentSelector::Status status = ComponentSelector::eHasData);
    ~Telescope();

    void CorrectIds(const unsigned int eyeId, const unsigned int telescopeId);

    void GenerateMirrorEventBorderPixels() const;

    unsigned int fTelescopeId = 0;
    unsigned int fEyeId = 0;
    utl::ShadowPtr<TelescopeSimData> fSimData;
    utl::ShadowPtr<TelescopeRecData> fRecData;
    utl::ShadowPtr<TelescopeTriggerData> fTriggerData;
    utl::TimeStamp fTracesStartTime;
    InternalChannelContainer fChannels;
    InternalPixelContainer fPixels;
    unsigned int fTimeOffset = 0;
    std::string fRawTelPointing = "unknown"; 
    ComponentSelector::Status fStatus;
    mutable InternalPixelDirCollection fMirrorEventBorderPixelsDir;

    friend class Eye;

  };

}


#endif