SEvent/Station.h

Go to the documentation of this file.

#ifndef _sevt_Station_h_
#define _sevt_Station_h_

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

#include <sevt/Scintillator.h>
#include <sevt/StationConstants.h>
#include <sevt/SignalSegment.h>
#include <sevt/StationSimData.h>
#include <sevt/StationRecData.h>
#include <sevt/StationTriggerData.h>
#include <sevt/StationCalibData.h>
#include <sevt/StationGPSData.h>
#include <sevt/PMT.h>
#include <sevt/SmallPMTData.h>

#include <sdet/PMTConstants.h>

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


namespace sevt {

  class SEvent;


  class Station {

  private:
    typedef std::vector<PMT*>::iterator InternalPMTPtrIterator;
    typedef std::vector<PMT*>::const_iterator InternalConstPMTPtrIterator;

    typedef boost::indirect_iterator<InternalPMTPtrIterator, PMT&> InternalPMTIterator;

    typedef boost::indirect_iterator<InternalConstPMTPtrIterator, const PMT&> InternalConstPMTIterator;

  public:
    Station(const Station& station) { *this = station; }
    Station& operator=(const Station& station);


    typedef utl::MultiTraceD::Iterator VEMTraceIterator;
    typedef utl::MultiTraceD::ConstIterator ConstVEMTraceIterator;

    int GetId() const { return fId; }


    bool HasPMT(const unsigned int pmtId) const;

    void MakePMT(const unsigned int pmtId, const int stationId,
                 const sdet::PMTConstants::PMTType type = sdet::PMTConstants::eWaterCherenkovLarge);

    PMT& GetPMT(const unsigned int pmtId) { return OFFLINE_CAST_CONST_METHOD(GetPMT(pmtId)); }
    const PMT& GetPMT(const unsigned int pmtId) const;

    PMT& GetScintillatorPMT() { return OFFLINE_CAST_CONST_METHOD(GetScintillatorPMT()); }
    const PMT& GetScintillatorPMT() const;

    PMT& GetSmallPMT() { return OFFLINE_CAST_CONST_METHOD(GetSmallPMT()); }
    const PMT& GetSmallPMT() const;

    unsigned int GetNPMTs(const sdet::PMTConstants::PMTType type = sdet::PMTConstants::eAnyType) const;

    typedef boost::filter_iterator<PMTFilter, InternalPMTIterator> PMTIterator;

    typedef boost::filter_iterator<PMTFilter, InternalConstPMTIterator> ConstPMTIterator;

    PMTIterator PMTsBegin(const sdet::PMTConstants::PMTType type = sdet::PMTConstants::eWaterCherenkovLarge)
    { return PMTIterator(PMTFilter(type), fPMTs.begin(), fPMTs.end()); }

    PMTIterator PMTsEnd(const sdet::PMTConstants::PMTType type = sdet::PMTConstants::eWaterCherenkovLarge)
    { return PMTIterator(PMTFilter(type), fPMTs.end(), fPMTs.end()); }

    ConstPMTIterator PMTsBegin(const sdet::PMTConstants::PMTType type = sdet::PMTConstants::eWaterCherenkovLarge) const
    { return ConstPMTIterator(PMTFilter(type), fPMTs.begin(), fPMTs.end()); }

    ConstPMTIterator PMTsEnd(const sdet::PMTConstants::PMTType type = sdet::PMTConstants::eWaterCherenkovLarge) const
    { return ConstPMTIterator(PMTFilter(type), fPMTs.end(), fPMTs.end()); }

    OFFLINE_MAKE_BOTH_ITERATOR_RANGES_ARG(PMTIterator, ConstPMTIterator, PMTs, const sdet::PMTConstants::PMTType arg = sdet::PMTConstants::eWaterCherenkovLarge)



    utl::TimeStamp GetTraceStartTime() const { return fTraceStartTime; }


    void SetTraceStartTime(const utl::TimeStamp& Time) { fTraceStartTime = Time; }

    utl::TraceD& GetVEMTrace(const StationConstants::SignalComponent source = StationConstants::eTotal)
    { return fTrace.GetTrace(source); }
    const utl::TraceD& GetVEMTrace(const StationConstants::SignalComponent source = StationConstants::eTotal) const
    { return fTrace.GetTrace(source); }
    void MakeVEMTrace(const StationConstants::SignalComponent source = StationConstants::eTotal);
    bool HasVEMTrace(const StationConstants::SignalComponent source = StationConstants::eTotal) const
    { return fTrace.HasLabel(source); }

    VEMTraceIterator VEMTracesBegin() { return fTrace.Begin(); }
    ConstVEMTraceIterator VEMTracesBegin() const { return fTrace.Begin(); }
    VEMTraceIterator VEMTracesEnd() { return fTrace.End(); }
    ConstVEMTraceIterator VEMTracesEnd() const { return fTrace.End(); }


    sevt::StationSimData& GetSimData() { return *fSimData; }
    const sevt::StationSimData& GetSimData() const { return *fSimData; }
    void MakeSimData();
    bool HasSimData() const { return bool(fSimData); }

    sevt::StationRecData& GetRecData() { return *fRecData; }
    const sevt::StationRecData& GetRecData() const { return *fRecData; }
    void MakeRecData();
    bool HasRecData() const { return bool(fRecData); }

    sevt::StationTriggerData& GetTriggerData() { return *fTriggerData; }
    const sevt::StationTriggerData& GetTriggerData() const { return *fTriggerData; }
    void MakeTriggerData();
    bool HasTriggerData() const { return bool(fTriggerData); }

    sevt::StationCalibData& GetCalibData() { return *fCalibData; }
    const sevt::StationCalibData& GetCalibData() const { return *fCalibData; }
    void MakeCalibData();
    bool HasCalibData() const { return bool(fCalibData); }

    sevt::StationGPSData& GetGPSData() { return *fGPSData; }
    const sevt::StationGPSData& GetGPSData() const { return *fGPSData; }
    void MakeGPSData();
    bool HasGPSData() const { return bool(fGPSData); }


    bool IsCandidate() const { return fReconstructionStatus == StationConstants::eCandidate; }
    bool IsRejected() const { return fReconstructionStatus == StationConstants::eRejected; }
    bool IsSilent() const { return fReconstructionStatus == StationConstants::eSilent; }

    void SetCandidate();
    void SetRejected(const int reason);
    void SetSilent();

    int GetRejectionStatus() const { return fRejectionStatus; }
    //void ClearRejectionStatus() { fRejectionStatus = StationConstants::eNoRejection; }

    // T2Life functions
    int GetT2Life() const { return fT2Life; }
    void SetT2Life(const int t) { fT2Life = t; }

    bool IsT2Life() const { return fT2Life > 0; }
    bool IsT2Life120() const { return fT2Life == 2; }

    // BottomUp delay functions
    double GetBottomUpResidual() const { return fBottomUpResidual; }
    void SetBottomUpResidual(const double d) { fBottomUpResidual = d; }

    bool IsLowGainSaturation() const { return fSaturation[sdet::PMTConstants::eLowGain]; }
    bool IsHighGainSaturation() const { return fSaturation[sdet::PMTConstants::eHighGain]; }
    bool IsSmallPMTSaturation() const { return fSmallPMTSaturation; }

    void SetLowGainSaturation(const bool sat = true) { fSaturation[sdet::PMTConstants::eLowGain] = sat; }
    void SetHighGainSaturation(const bool sat = true) { fSaturation[sdet::PMTConstants::eHighGain] = sat; }
    void SetSmallPMTSaturation(const bool sat = true) { fSmallPMTSaturation = sat; }

    SignalSegmentCollection& GetSignals() { return fSignals; }
    const SignalSegmentCollection& GetSignals() const { return fSignals; }

    bool IsUUB() const;

    bool IsCyclone() const { return fIsCyclone; }
    void SetIsCyclone(const bool cy = true) { fIsCyclone = cy; }

    Scintillator& GetScintillator() { return *fScintillator; }
    const Scintillator& GetScintillator() const { return *fScintillator; }
    bool HasScintillator() const { return bool(fScintillator); }

    SmallPMTData& GetSmallPMTData() { return *fSmallPMTData; }
    const SmallPMTData& GetSmallPMTData() const { return *fSmallPMTData; }
    bool HasSmallPMTData() const { return bool(fSmallPMTData); }

    /* Add particle is located in the Station and not StationSimData
       as it is necessary for particle counting in the WCD and Scintillator
       to access the IsHit functions for both. The particle list is
       only stored in StationSimData and is not accessible via the Scintillator
       or ScintillatorSimData */
    void AddParticle(const utl::Particle& particle);

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

    int fId = 0;
    std::vector<PMT*> fPMTs;
    utl::ShadowPtr<StationSimData> fSimData;
    utl::ShadowPtr<StationRecData> fRecData;
    utl::ShadowPtr<StationCalibData> fCalibData;
    utl::ShadowPtr<StationTriggerData> fTriggerData;
    utl::ShadowPtr<StationGPSData> fGPSData;
    utl::TimeStamp fTraceStartTime;
    utl::MultiTraceD fTrace;
    StationConstants::ReconstructionStatus fReconstructionStatus = StationConstants::eCandidate;
    bool fSaturation[sdet::PMTConstants::eNumberOfGains] = { false };
    bool fSmallPMTSaturation = false;
    int fRejectionStatus = StationConstants::eNoRejection;

    // T2Life
    // 0: not active acc. to T2Life
    // 1: T2
    // 2: T2-120
    int fT2Life = 2;

    double fBottomUpResidual = 0;

    SignalSegmentCollection fSignals;

    utl::ShadowPtr<Scintillator> fScintillator;
    utl::ShadowPtr<SmallPMTData> fSmallPMTData;

    bool fIsUUB = false;
    bool fIsCyclone = false;

    friend class sevt::SEvent;

  };


  class CandidateStationFilter {
  public:
    bool operator()(const Station& station)
    { return station.IsCandidate(); }
  };


  class SilentStationFilter {
  public:
    bool operator()(const Station& station)
    { return station.IsSilent(); }
  };


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

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

  private:
    int fStatusMask = 0;
  };

}


#endif