REvent.h

Go to the documentation of this file.

#ifndef _revt_REvent_h_
#define _revt_REvent_h_

#include <revt/Station.h>
#include <revt/Header.h>

#include <utl/LameShadowPtr.h>
#include <utl/IteratorRange.h>
#include <utl/ClassHelpers.h>

#include <boost/iterator/indirect_iterator.hpp>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/iterator/filter_iterator.hpp>

#include <vector>
#include <map>
#include <string>
#include <algorithm>


namespace evt {
  class Event;
}

namespace revt {

  class EventTrigger;


  class REvent {

  private:
    typedef std::map<int, Station*> InternalStationCollection;
    typedef InternalStationCollection::iterator InternalStationIterator;
    typedef InternalStationCollection::const_iterator InternalConstStationIterator;

    /*struct ConstInternalStationFunctor { //should not be needed
      const revt::Station&
      operator()(const InternalStationCollection::value_type& pair) const
      { return *pair.second; }
    };*/

    struct InternalStationFunctor {
      revt::Station& operator()(const InternalStationCollection::value_type& pair) const
      { return *pair.second; }
    };

  public:
    enum RejectionStatus {
      eEventNoRejection                 = 0,
      eEventManuallyRejected            = (1 << 0),

      // Set by Offline Modules
      e2DLDFsigmaatlimit                = (1 << 1),

      // 2DLDFFit -> Varying the measured values and refitting the 2LDF 1000 times, shape of distribution used as quality criteria
      e2DLDFvariationfails              = (1 << 2),   // 2DLDFFitter not enough successful reconstructions varying the measruments
      e2DLDFmeanAdistoutside            = (1 << 3),   // difference between mean of A-distribution and A too big
      e2DLDFmeanSigmadistoutside        = (1 << 4),   // difference between mean of Sigma-distribution and Sigma too big
      e2DLDFasymmetryAdist              = (1 << 5),   // A-distribution too asymmetric
      e2DLDFasymmetrySigmadist          = (1 << 6),   // Sigma-distribution too asymmetric
      e2DLDFFitfailed                   = (1 << 7),   // no successful 2DLDF fit

      // Thunderstorm rejection - set by external code in tools dir
      eCRSNoData                        = (1 << 8),
      eCRSTsConditions                  = (1 << 9),
      eAERAWSNoData                     = (1 << 10),
      eAERAWSTsConditions               = (1 << 11),

      eNumStationRejectionStatusBits      = 12
    };

    REvent(const REvent& re) { *this = re; }
    REvent& operator=(const REvent& rEvent);

    typedef boost::transform_iterator<
      InternalStationFunctor, InternalConstStationIterator, const revt::Station&
    > ConstAllStationIterator;
    typedef boost::transform_iterator<
      InternalStationFunctor, InternalStationIterator, revt::Station&
    > AllStationIterator;

    AllStationIterator AllStationsBegin()
    { return AllStationIterator(fStations.begin()); }
    AllStationIterator AllStationsEnd()
    { return AllStationIterator(fStations.end()); }

    ConstAllStationIterator AllStationsBegin() const
    { return ConstAllStationIterator(fStations.begin()); }
    ConstAllStationIterator AllStationsEnd() const
    { return ConstAllStationIterator(fStations.end()); }

    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(AllStationIterator, ConstAllStationIterator, AllStations)

    
    typedef boost::filter_iterator<SignalStationFilter, AllStationIterator> SignalStationIterator;
    typedef boost::filter_iterator<SignalStationFilter, ConstAllStationIterator> ConstSignalStationIterator;

    SignalStationIterator SignalStationsBegin()
    { return SignalStationIterator(AllStationsBegin(), AllStationsEnd()); }
    SignalStationIterator SignalStationsEnd()
    { return SignalStationIterator(AllStationsEnd(), AllStationsEnd()); }

    ConstSignalStationIterator SignalStationsBegin() const
    { return ConstSignalStationIterator(AllStationsBegin(), AllStationsEnd()); }
    ConstSignalStationIterator SignalStationsEnd() const
    { return ConstSignalStationIterator(AllStationsEnd(), AllStationsEnd()); }

    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(SignalStationIterator, ConstSignalStationIterator, SignalStations)

    
    typedef boost::filter_iterator<StationFilter, AllStationIterator> StationIterator;
    typedef boost::filter_iterator<StationFilter, ConstAllStationIterator> ConstStationIterator;

    StationIterator StationsBegin()
    { return StationIterator(AllStationsBegin(), AllStationsEnd()); }
    StationIterator StationsEnd()
    { return StationIterator(AllStationsEnd(), AllStationsEnd()); }

    ConstStationIterator StationsBegin() const
    { return ConstStationIterator(AllStationsBegin(), AllStationsEnd()); }
    ConstStationIterator StationsEnd() const
    { return ConstStationIterator(AllStationsEnd(), AllStationsEnd()); }

    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(StationIterator, ConstStationIterator, Stations)

    
    typedef boost::filter_iterator<CandidateStationFilter, AllStationIterator> CandidateStationIterator;
    typedef boost::filter_iterator<CandidateStationFilter, ConstAllStationIterator> ConstCandidateStationIterator;

    CandidateStationIterator CandidateStationsBegin()
    { return CandidateStationIterator(AllStationsBegin(), AllStationsEnd()); }
    CandidateStationIterator CandidateStationsEnd()
    { return CandidateStationIterator(AllStationsEnd(), AllStationsEnd()); }

    ConstCandidateStationIterator CandidateStationsBegin() const
    { return ConstCandidateStationIterator(AllStationsBegin(), AllStationsEnd()); }
    ConstCandidateStationIterator CandidateStationsEnd() const
    { return ConstCandidateStationIterator(AllStationsEnd(), AllStationsEnd()); }

    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(CandidateStationIterator, ConstCandidateStationIterator, CandidateStations)

    
    typedef boost::filter_iterator<NoSignalStationFilter, AllStationIterator> NoSignalStationIterator;
    typedef boost::filter_iterator<NoSignalStationFilter, ConstAllStationIterator> ConstNoSignalStationIterator;

    NoSignalStationIterator NoSignalStationsBegin()
    { return NoSignalStationIterator(AllStationsBegin(), AllStationsEnd()); }
    NoSignalStationIterator NoSignalStationsEnd()
    { return NoSignalStationIterator(AllStationsEnd(), AllStationsEnd()); }

    ConstNoSignalStationIterator NoSignalStationsBegin() const
    { return ConstNoSignalStationIterator(AllStationsBegin(), AllStationsEnd()); }
    ConstNoSignalStationIterator NoSignalStationsEnd() const
    { return ConstNoSignalStationIterator(AllStationsEnd(), AllStationsEnd()); }

    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(NoSignalStationIterator, ConstNoSignalStationIterator, NoSignalStations)

    
    typedef boost::filter_iterator<RejectedStationFilter, AllStationIterator> RejectedStationIterator;
    typedef boost::filter_iterator<RejectedStationFilter, ConstAllStationIterator> ConstRejectedStationIterator;

    // DV: maybe in the future the rejectionMask should be replaced with an expression template
    RejectedStationIterator RejectedStationsBegin(const int rejectionMask = ~0)
    { return RejectedStationIterator(RejectedStationFilter(rejectionMask), AllStationsBegin(), AllStationsEnd()); }
    RejectedStationIterator RejectedStationsEnd(const int rejectionMask = ~0)
    { return RejectedStationIterator(RejectedStationFilter(rejectionMask), AllStationsEnd(), AllStationsEnd()); }

    ConstRejectedStationIterator RejectedStationsBegin(const int rejectionMask = ~0) const
    { return ConstRejectedStationIterator(RejectedStationFilter(rejectionMask), AllStationsBegin(), AllStationsEnd()); }
    ConstRejectedStationIterator RejectedStationsEnd(const int rejectionMask = ~0) const
    { return ConstRejectedStationIterator(RejectedStationFilter(rejectionMask), AllStationsEnd(), AllStationsEnd()); }

    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(RejectedStationIterator, ConstRejectedStationIterator, RejectedStations)

    
    Station& GetStation(const int stationId) { return OFFLINE_CAST_CONST_METHOD(GetStation(stationId)); }
    const Station& GetStation(const int stationId) const;

    Station& GetStationByName(const std::string& name) { return OFFLINE_CAST_CONST_METHOD(GetStationByName(name)); }
    const Station& GetStationByName(const std::string& name) const;

    void MakeStation(const int stationId);
    void MakeStation(const std::string& stationName);

    bool HasStation(const int stationId) const;
    bool HasStation(const std::string& name) const;

    int GetNumberOfStations() const { return fStations.size(); }

    int GetNumberOfSignalStations() const
    { return std::distance(SignalStationsBegin(), SignalStationsEnd()); }


    AllStationIterator RemoveStation(const AllStationIterator it);

    // RD Event Central Trigger Information

    EventTrigger& GetTrigger() { return *fTrigger; }
    const EventTrigger& GetTrigger() const { return *fTrigger; }

    void MakeTrigger();

    bool HasTrigger() const { return bool(fTrigger); }

    Header& GetHeader() { return fHeader; }
    const Header& GetHeader() const { return fHeader; }

    bool IsRejected() { return fRejectionStatus == eEventNoRejection; }
    void SetRejected(const unsigned long long int reason) { fRejectionStatus |= reason; }
    unsigned long long int GetRejectionStatus() const { return fRejectionStatus; }
    void ClearRejectionStatus() { fRejectionStatus = eEventNoRejection; }


    template<class OrderingCriterion>
    void SortStations(const OrderingCriterion ord)
    { std::sort(fStations.begin(), fStations.end(), ord); }

    const std::string& GetAERARootIoSourceFileName() const { return fAERARootIoSourceFileName; }
    void SetAERARootIoSourceFileName(const std::string& parFileName) { fAERARootIoSourceFileName = parFileName; }

    double GetAERARootIoEventId() const { return fAERARootIoEventId; }
    void SetAERARootIoEventId(const double parEventId) { fAERARootIoEventId = parEventId; }

    bool GetChannelResponseApplied() const { return fChannelResponseApplied; }
    void SetChannelResponseApplied(const bool parFlag) { fChannelResponseApplied = parFlag; }

  private:
    REvent() = default;
    ~REvent();

    InternalStationCollection fStations;
    utl::LameShadowPtr<EventTrigger> fTrigger;
    Header fHeader;

    // metadata for events read in from AERARootIo files to enable event extraction.
    // this is a quick'n'dirty solution, should rather use static member in RadioFileAERARoot
    std::string fAERARootIoSourceFileName;
    double fAERARootIoEventId = -1;

    // flag for RdChannelResponseIncorporator to keep track if it has already been called
    bool fChannelResponseApplied = false;

    unsigned long long int fRejectionStatus = 0;

    friend class evt::Event;
    friend class utl::LameShadowPtr<REvent>;

  };

}


#endif