RDetector/Station.h

Go to the documentation of this file.

#ifndef _rdet_Station_h_
#define _rdet_Station_h_

#include <vector>
#include <list>
#include <map>
#include <string>
#include <sstream>

#include <boost/lexical_cast.hpp>
#include <boost/iterator/indirect_iterator.hpp>

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

#include <utl/AugerException.h>
#include <utl/CoordinateSystemPtr.h>
#include <utl/ReferenceEllipsoid.h>
#include <utl/Validated.h>
#include <utl/Point.h>
#include <utl/TimeStamp.h>
#include <utl/TimeRange.h>
#include <utl/TabulatedFunction.h>
#include <utl/ShadowPtr.h>


namespace utl {
  class Point;
  class TimeStamp;
}

namespace revt {
  class Channel;
}

namespace rdet {
  class Channel;
  class RDetector;


  class Station {      

  private:
    typedef std::vector<const Channel*> InternalChannelVector;
    typedef InternalChannelVector::const_iterator InternalChannelIterator;

  public:

    std::vector<int> GetListOfChannelIds() const { return fListOfChannelIds; }

    int GetInternalChannelId(const int channelId) const { return fChannelIdToInternalChannelId.at(channelId); }

    bool HasChannel(const int channelId) const { return fChannelIdToInternalChannelId.count(channelId); }

    void SetListOfChannelIds();

    int GetNChannels() const { return fListOfChannelIds.size(); }

    std::string GetName() const;
    
    int GetId() const { return fId; }

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

    ChannelIterator ChannelsBegin() const
    { return ChannelIterator(fChannelVector.begin()); }

    ChannelIterator ChannelsEnd() const
    { return ChannelIterator(fChannelVector.end()); }

    OFFLINE_MAKE_CONST_ITERATOR_RANGE(ChannelIterator, Channels)
        
    
    const utl::TimeStamp& GetCommissionTime() const
    { return GetCommissionTimeRange().GetStartTime(); }

    const utl::TimeStamp& GetDecommissionTime() const
    { return GetCommissionTimeRange().GetStopTime(); }

    const utl::TimeRange& GetCommissionTimeRange() const;
    
    //    const utl::Point& GetPosition() const;
    // temporary solution for detector creeping (bug #307)
    utl::Point GetPosition() const;
    
    utl::CoordinateSystemPtr GetLocalCoordinateSystem() const; 
  
    bool IsInGrid(const int level = 0) const;

    bool IsInEngineeringArray() const { return fId < 71; }

    // defines if a station is generated from simulation and is event based
    bool IsVirtual() const;

    // ------------------
    // Dynamic quantities
    // ------------------
    
    bool IsInAcquisition() const;

    // ---------------------
    // Station subcomponents
    // --------------------- 
    const Channel& GetChannel(const int id) const;
    
    const Channel& GetChannel(const revt::Channel& channel) const;

  private:
    Station(const int); 
    ~Station();
    
    Station(const Station&);
    Station operator=(const Station&);

    void Update() const;

    // Helper method to do the redundant work of preparing requests for station data,
    // sending it to the manager and reporting any errors. 
    // The errorMsg argument is used to construct some hopefully meaningful error message if the
    // requested component is not found. It should have a description in some human language 
    // of what was not located.

    template <typename T>
    det::VManager::Status
    GetDefaultData(T& returnData, const std::string& componentProperty) const;

    template <typename T>
    det::VManager::Status
    GetStationData(T& requestedData, 
                           const std::string& property, 
                           const std::string& component, 
                           const std::string& errorMsg,
                           const bool throwOnFailure = true) const;

    void NotFoundAndThrow(const std::string& msg) const;

    int fId;
    
    // station id held as a string as that is what is passed through the detector manager interface
    std::string fStationIdString; 

    InternalChannelVector fChannelVector;

    // Quantities filled by lazy evaluation
    // ------------------------------------
    mutable utl::Validated<std::string> fName;
    mutable utl::Validated<int> fInGrid;
    mutable utl::ReferenceEllipsoid::EllipsoidID fEllipsoid;
    mutable utl::CoordinateSystemPtr fReferenceSystem;
    mutable utl::Validated<utl::Point> fPosition;
    
    mutable utl::Validated<int> fIsInAcquisition;

    mutable utl::Validated<int> fNChannels;
    mutable utl::Validated<int> fFirstChannelId;
    mutable utl::Validated<int> fLastChannelId;

    std::vector<int> fListOfChannelIds;
    std::map<int, int> fChannelIdToInternalChannelId;

    mutable utl::Validated<utl::TimeRange> fCommissionTimeRange;
    
    friend class RDetector;

  };
  
}


#endif