RdVirtualStationNoiseImporter.h

Go to the documentation of this file.

#ifndef _RdVirtualStationNoiseImporter_RdVirtualStationNoiseImporter_h_
#define _RdVirtualStationNoiseImporter_RdVirtualStationNoiseImporter_h_

#include <fwk/VModule.h>

#include <revt/Channel.h>
#include <revt/Station.h>
#include <rdet/Station.h>

#include <utl/RandomEngine.h>
#include <utl/TimeStamp.h>
#include <utl/UTCDateTime.h>
#include <utl/AugerUnits.h>

#include <RadioFileIO.h>

#include <string>

namespace evt {
  class Event;
}

namespace revt {
  class Channel;
}

namespace RdVirtualStationNoiseImporter {

  class RdVirtualStationNoiseImporter : public fwk::VModule {

  public:
    fwk::VModule::ResultFlag Init() override;
    fwk::VModule::ResultFlag Run(evt::Event& event) override;
    fwk::VModule::ResultFlag Finish() override;

  private:
    // switches controlling noise file selection
    std::string fNoiseFileSelection;
    std::string fNoiseFilePath;
    bool fExpectSubDirectories = false;
    std::string fFilenamePrefix;
    std::string fFilenameSuffix;
    std::string fTimeIntervalInFile;
    bool fTraceShifting = true;
    bool fReplaceDataWithNoise = false;
    std::vector<int> fStationIDList;
    utl::TimeStamp fRandomNoiseTimeIntervalStart;
    utl::TimeStamp fRandomNoiseTimeIntervalStop;

    // switches controlling the reading of noise from a selected file
    std::string fEvtSelInNoiseFile;
    //int fNoiseEvtNr = -1; // unused. LN.
    unsigned int fNumberOfRejectedStationsWithoutNoise = 0;
    bool fCheckTimeWindow = false;
    double fMaxTimeDifference = 10 * utl::minute;
    double fGainFactor = 0;

    utl::RandomEngine::RandomEngineType* fRandomEngine = nullptr;

    // bool IsCompatible(const revt::Station& testStation, const rdet::Station& replacementStation);
    void RemovePedestal(revt::ChannelADCTimeSeries& timeSeries);
    void RemovePedestal(std::vector<int>& timeSeries);
    bool GetNoiseFileNameAtTime(const utl::UTCDateTime& dateTime, const utl::UTCDateTime& startingDay,
                                std::string& NoiseImportfilename);
    std::vector<int> EventHasStations(std::vector<int> stationID, AERAevent* const aeraevent,
                                      const rdet::RDetector& rDetector);

    // following is taken from RdStationRejector
    typedef std::multimap<utl::TimeStamp, std::pair<utl::TimeStamp, size_t> > ParentMap;

    class TimeRangeMap : public ParentMap {
    public:
      typedef std::vector<size_t> IdCollection;

      IdCollection
      GetBadStations(const utl::TimeStamp& time)
        const
      {
        ParentMap::const_iterator it = upper_bound(time);  // first key larger than time

        if (it == begin())
          return IdCollection();

        IdCollection ids;
        do {
          --it;
          if (it->first <= time && time <= it->second.first)
            ids.push_back(it->second.second);
        } while (it != begin());
        return ids;
      }
    };

    TimeRangeMap fRejectMap;


    REGISTER_MODULE("RdVirtualStationNoiseImporter", RdVirtualStationNoiseImporter);

  };

}


#endif