RdChannelNoisePowerAnalyser.h

Go to the documentation of this file.

#ifndef _RdChannelNoisePowerAnalyser_h_
#define _RdChannelNoisePowerAnalyser_h_

#include <string>
#include <revt/Station.h>
#include <utl/UTCDateTime.h>

#include <fwk/VModule.h>

#include "TProfile.h"
#include "TProfile2D.h"
#include "TFile.h"
#include "TH2D.h"
#include "THnSparse.h"

// you should assign your module to a namespace

namespace RdChannelNoisePowerAnalyser {

struct NoisePulseData {
  std::vector<double> SNRs;
  std::vector<int> GPSsecods;
  long unsigned int numberOfPulses; // the number of traces that had a pulse above noise threshold
  long unsigned int numberOfTraces; // the number of traces that has been read in
  double totalSignalSerachWindow;   // the sum of the signal search window of all condidered traces

  NoisePulseData() :
    numberOfPulses(0),
    numberOfTraces(0),
    totalSignalSerachWindow(0.)
  {}
};

typedef boost::tuple<int, int, int> Key;
typedef boost::tuple<int, int, int, int> KeyYearMonth;

enum InfoLevel {
   eNone = 0, eFinal = 1, eIntermediate = 2, eObscure = 3, eDebug = 4
 };

class RdChannelNoisePowerAnalyser : public fwk::VModule {

public:
  enum Month {
    eJan = 1,
    eFeb = 2,
    eMar = 3,
    eApr = 4,
    eMay = 5,
    eJun = 6,
    eJul = 7,
    eAug = 8,
    eSep = 9,
    eOct = 10,
    eNov = 11,
    eDec = 12
  };
  // If you define a constructor, you MUST provide an implementation
  // for it, otherwise the REGISTER_MODULE macro will not register
  // your module. (Here, implementation is in RdChannelNoisePowerAnalyser.cc)
  RdChannelNoisePowerAnalyser();
  //virtual ~RdChannelNoisePowerAnalyser();

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

private:

  static bool IsLeapYear(const int year)
  { return (!(year%4) && (year%100)) || !(year%400); }

  static
  int
  NumberOfDaysInMonth(const int year, const int month)
  {
    switch (month) {
    case eJan:
    case eMar:
    case eMay:
    case eJul:
    case eAug:
    case eOct:
    case eDec:
      return 31;
    case eFeb:
      return IsLeapYear(year) ? 29 : 28;
    case eApr:
    case eJun:
    case eSep:
    case eNov:
      return 30;
    default:
      return 0;
    }
  }

  double FindPulse(revt::Station& station);
  double GPSSecToLSTHourAuger(const unsigned long gps);

  int fInfoLevel;
  bool fUnbinnedASCIIOutput;
  double fFrequencyBinWidth;
  double fMinFrequency;
  double fMaxFrequency;

  std::string fOutputPath;
  std::string fOutputFilename;
  int fMinimumStationId;
  int fMaximumStationId;
  const int fMinimumChannelId;
  const int fMaximumChannelId;

  const double fLocalSiderealDay;
  const int fNumberOfBinsPerDay;
  int fNFrequencyBins;

  const utl::UTCDateTime fReferenceTime;

  std::vector<double> fFrequencies;

  TFile *fRootOut;
//  std::map<Key, TProfile* > fProfileAmplitudeMap;
//  std::map<Key, TProfile* > fProfilePowerMap;
  std::map<Key, THnSparseF*> fHistogramPowerMap;
  std::map<Key, THnSparseF*> fHistogramPowerMapLinear;

  std::map<KeyYearMonth, TProfile2D*> fDynamicPowerSpectrum;
  int fCurrentMonth;

  std::ofstream fOfs;
  std::ofstream fOfs_freqs;

  // The REGISTER_MODULE macro makes the framework aware of your module.
  // You need to put this macro at the very end of your module class definition.
  // Give your module a name (first argument) and specify its
  // class name (second argument).  In the ModuleSequenceExample.xml file,
  // you can see this module being refered to by the name we give it here.

  REGISTER_MODULE("RdChannelNoisePowerAnalyser", RdChannelNoisePowerAnalyser);

};

}

#endif

// Configure (x)emacs for this file ...
// Local Variables:
// mode:c++
// compile-command: "make -k"
// End: