REvent/Station.h

Go to the documentation of this file.

#ifndef _revt_Station_h_
#define _revt_Station_h_

#include <utl/ShadowPtr.h>
#include <utl/AugerException.h>
#include <utl/FFTDataContainer.h>
#include <utl/TimeStamp.h>
#include <utl/Trace.h>
#include <utl/ClassHelpers.h>

#include <revt/StationConstants.h>

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


namespace revt {

  class REvent;
  class Channel;
  class StationSimData;
  class StationRecData;
  class StationTriggerData;
  class StationGPSData;
  class StationHeader;


  typedef utl::TraceV3D StationTimeSeries;
  typedef utl::TraceV3C StationFrequencySpectrum;
  typedef utl::FFTDataContainer<utl::Trace, utl::Vector3D, utl::Vector3C> StationFFTDataContainer;


  class Station {

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

  public:
    Station(const Station& station);
    Station& operator=(const Station& station);

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

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

    int GetId() const { return fId; }

    bool HasChannel(const int pmtId) const;

    Channel& GetChannel(const int pmtId) { return OFFLINE_CAST_CONST_METHOD(GetChannel(pmtId)); }
    const Channel& GetChannel(const int pmtId) const;

    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 ChannelsSize() const { return fChannels.size(); }

    StationSimData& GetSimData() { return OFFLINE_CAST_CONST_METHOD(GetSimData()); }
    const StationSimData& GetSimData() const;
    void MakeSimData();
    bool HasSimData() const { return bool(fSimData); }

    StationRecData& GetRecData() { return OFFLINE_CAST_CONST_METHOD(GetRecData()); }
    const StationRecData& GetRecData() const;
    void MakeRecData();
    bool HasRecData() const { return bool(fRecData); }

    StationTriggerData& GetTriggerData() { return OFFLINE_CAST_CONST_METHOD(GetTriggerData()); }
    const StationTriggerData& GetTriggerData() const;
    void MakeTriggerData();
    bool HasTriggerData() const { return bool(fTriggerData); }

    StationGPSData& GetGPSData() { return OFFLINE_CAST_CONST_METHOD(GetGPSData()); }
    const StationGPSData& GetGPSData() const;
    void MakeGPSData();
    bool HasGPSData() const { return bool(fGPSData); }

    StationHeader& GetStationHeader() { return OFFLINE_CAST_CONST_METHOD(GetStationHeader()); }
    const StationHeader& GetStationHeader() const;
    void MakeStationHeader();
    bool HasStationHeader() const { return bool(fStationHeader); }

    utl::TimeStamp GetRawTraceStartTime() const { return fRawTraceStartTime; }


    void
    SetRawTraceStartTime(const utl::TimeStamp& time)
    {
      if (!fRawTraceStartTimeLocked)
        fRawTraceStartTime = time;
      else {
        const auto err =
          "fRawTraceStartTime has already been locked in RdEventInitializer! Change is no longer allowed.";
        ERROR(err);
        throw utl::InitSequenceException(err);
      }
    }

    bool GetRawTraceStartTimeLocked() const { return fRawTraceStartTimeLocked; }

    void SetRawTraceStartTimeLocked(const bool lock = true) { fRawTraceStartTimeLocked = lock; }

    unsigned int GetNyquistZone() const { return fFFTDataContainer->GetNyquistZone(); }

    void SetNyquistZone(const unsigned int zone) { fFFTDataContainer->SetNyquistZone(zone); }

    double GetFrequencyOfBin(const StationFrequencySpectrum::SizeType bin) const
    { return fFFTDataContainer->GetFrequencyOfBin(bin); }

    double GetMinimumFrequency() const
    { return std::min(GetFrequencyOfBin(0), GetFrequencyOfBin(fFFTDataContainer->GetConstFrequencySpectrum().GetSize() - 1)); }

    double GetMaximumFrequency() const
    { return std::max(GetFrequencyOfBin(0), GetFrequencyOfBin(fFFTDataContainer->GetConstFrequencySpectrum().GetSize() - 1)); }

    StationTimeSeries& GetStationTimeSeries() { return fFFTDataContainer->GetTimeSeries(); }
    const StationTimeSeries& GetStationTimeSeries() const { return fFFTDataContainer->GetConstTimeSeries(); }

    StationFrequencySpectrum& GetStationFrequencySpectrum() { return fFFTDataContainer->GetFrequencySpectrum(); }
    const StationFrequencySpectrum& GetStationFrequencySpectrum() const
    { return fFFTDataContainer->GetConstFrequencySpectrum(); }

    const StationFFTDataContainer& GetFFTDataContainer() const { return *fFFTDataContainer; }
    StationFFTDataContainer& GetFFTDataContainer() { return *fFFTDataContainer; }

    /*
      Stations can have one of the following ReconstructionStatus:
       - eExcluded: Station is for what ever reason excluded. It will not longer be considered
         in the reconstruction. But it will be written into the ADST files. Check reasons in
         revt::StationConstants::ExcludedReason.
       - eRejected: Station operated normally. Pulse is fully reconstructed. However for what
         ever reason the pulse is rejected for any shower reconstruction. For example due to the
         contamination with noise. Check revt::StationConstants::RejectionStatus.
       - eNoSignal: Station is found to not have a significant signal (is a CandidateStation)
       - eSignal: Station is found to have a signal (is a CandidateStation)
      Further information see
       - wiki page for the Feb 2019 Radio Offline Workshop:
         https://www.auger.unam.mx/AugerWiki/Event_reconstruction_and_Analysis_Workshop_February_2019#preview
       - the GitLab-MR: https://gitlab.com/auger-observatory/offline/offline/-/merge_requests/6/
    */
    void SetSignal() { fReconstructionStatus = eHasSignal; }
    bool HasSignal() const { return fReconstructionStatus == eHasSignal; }

    void SetNoSignal() { fReconstructionStatus = eHasNoSignal; }
    bool HasNoSignal() const { return fReconstructionStatus == eHasNoSignal; }

    bool IsExcluded() const { return fReconstructionStatus == eExcluded; }
    void SetExcludedReason(const ExcludedReason reason);
    ExcludedReason GetExcludedReason() const { return fExcludedReason; }

    bool IsCandidate() const { return fReconstructionStatus == eHasNoSignal || fReconstructionStatus == eHasSignal; }

    void SetRejectedReason(const unsigned long long int reason);
    bool IsRejected() const { return fReconstructionStatus == eRejected; }
    bool HasRejectedReason(const unsigned long long int reason) const { return fRejectedReason & reason; }
    unsigned long long int GetRejectedReason() const { return fRejectedReason; }
    void ClearRejectedReason() { fRejectedReason = eNoRejection; }

    ReconstructionStatus GetReconstructionStatus() const { return fReconstructionStatus; }
    void SetReconstructionStatus(const ReconstructionStatus s) { fReconstructionStatus = s; }

    void SetSaturated() { fIsSaturated = true; }
    void SetNotSaturated() { fIsSaturated = false; }
    bool IsSaturated() const { return fIsSaturated; }

    void SetHWTemperature(const double temp) { fHWTemperature = temp; }
    double GetHWTemperature() const { return fHWTemperature; }
    void SetHWTemperatureInt(const double temp) { fHWTemperatureInt = temp; }
    double GetHWTemperatureInt() const { return fHWTemperatureInt; }
    void SetHWTemperatureExt(const double temp) { fHWTemperatureExt = temp; }
    double GetHWTemperatureExt()const  { return fHWTemperatureExt; }

  private:
    Station(const int stationId);
    ~Station();

    int fId = 0;
    std::vector<Channel*> fChannels;
    utl::ShadowPtr<StationSimData> fSimData;
    utl::ShadowPtr<StationRecData> fRecData;
    utl::ShadowPtr<StationTriggerData> fTriggerData;
    utl::ShadowPtr<StationGPSData> fGPSData;
    utl::ShadowPtr<StationHeader> fStationHeader;
    utl::TimeStamp fRawTraceStartTime;
    bool fRawTraceStartTimeLocked = false;
    utl::InitializedShadowPtr<StationFFTDataContainer> fFFTDataContainer;
    ReconstructionStatus fReconstructionStatus = eHasNoSignal;
    ExcludedReason fExcludedReason = eNotExcluded;
    bool fIsSaturated = false;
    unsigned long long int fRejectedReason = eNoRejection;
    double fHWTemperature = 0;
    double fHWTemperatureInt = 0;
    double fHWTemperatureExt = 0;

    friend class revt::REvent;
  };


  struct StationFilter {
    bool operator()(const Station& station) const
    { return !station.IsExcluded(); }
  };


  struct SignalStationFilter {
    bool operator()(const Station& station) const
    { return station.HasSignal(); }
  };


  struct CandidateStationFilter {
    bool operator()(const Station& station) const
    { return station.IsCandidate(); }
  };


  struct NoSignalStationFilter {
    bool operator()(const Station& station) const
    { return station.HasNoSignal(); }
  };


  class RejectedStationFilter {
  public:
    RejectedStationFilter(const int statusMask) : fStatusMask(statusMask) { }

    bool operator()(const Station& station) const
    { return station.GetRejectedReason() & fStatusMask; }

  private:
    int fStatusMask;
  };

}


#endif