RdChannelAmplitudeCalibrator.cc

Go to the documentation of this file.

#include "RdChannelAmplitudeCalibrator.h"

#include <fwk/CentralConfig.h>
#include <fwk/VModule.h>

#include <utl/ErrorLogger.h>
#include <utl/Reader.h>
#include <utl/config.h>
#include <utl/TraceAlgorithm.h>
#include <utl/AugerUnits.h>
#include <utl/TabulatedFunctionComplexLgAmpPhase.h>

#include <evt/Event.h>
#include <revt/Header.h>
#include <revt/REvent.h>
#include <revt/Station.h>
#include <revt/Channel.h>

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

#define OUT(x) if ((x) <= fInfoLevel) cerr << "  "

using namespace utl;
using namespace fwk;
using namespace std;
using namespace revt;
using namespace boost;


namespace RdChannelAmplitudeCalibrator {

  RdChannelAmplitudeCalibrator::RdChannelAmplitudeCalibrator() :
    fInfoLevel(0)
  { }


  RdChannelAmplitudeCalibrator::~RdChannelAmplitudeCalibrator()
  { }

  VModule::ResultFlag
  RdChannelAmplitudeCalibrator::Init()
  {
    // Initialize your module here. This method
    // is called once at the beginning of the run.
    // The eSuccess flag indicates the method ended
    // successfully.  For other possible return types,
    // see the VModule documentation.

    OUT(eFinal)<<"RdChannelAmplitudeCalibrator::Init()"<< endl;

    // Read in the configurations of the xml file
    Branch topBranch =
      CentralConfig::GetInstance()->GetTopBranch("RdChannelAmplitudeCalibrator");
    topBranch.GetChild("InfoLevel").GetData(fInfoLevel);
    return eSuccess;
  }


  VModule::ResultFlag
  RdChannelAmplitudeCalibrator::Run(evt::Event& event)
  {
    // Check if there are events at all
    if(!event.HasREvent()) {
      if(fInfoLevel > eNone) {
        WARNING("No radio event found!");
      }
      return eContinueLoop;
    }

    det::Detector& thedet = det::Detector::GetInstance();
    REvent& rEvent = event.GetREvent();

    // loop through stations and for every station through every channel
    for (REvent::StationIterator sIt = rEvent.StationsBegin();
         sIt != rEvent.StationsEnd(); ++sIt) {
      Station& station = *sIt;

      ostringstream message;

      for (Station::ChannelIterator cIt = station.ChannelsBegin();
           cIt != station.ChannelsEnd(); ++cIt) {

        Channel& channel = *cIt;
        if (!channel.IsActive()) 
          continue;

        const rdet::Channel& channeldet = thedet.GetRDetector().GetStation(station.GetId()).GetChannel(channel.GetId());
        const TabulatedFunction& channelcalibration = channeldet.GetCalibrationFunction();
        
        // fixme TH: application of calibration function deactivated until rdet::Channel::GetCalibrationFunction() has been implemented
        // check if there is actually a valid calibration function and skip channel if not
        //      if (channelcalibration.GetNPoints()<2)
          continue;

        message.str("");
        message << "Applying calibration to channel "<< channel.GetId() << " of station " << station.GetId();
        OUT(eObscure) << message.str() << endl;
        
        ApplyResponse(channel, channelcalibration);
      }
    }

    return eSuccess;
  }


  VModule::ResultFlag
  RdChannelAmplitudeCalibrator::Finish()
  {
    // Put any termination or cleanup code here.
    // This method is called once at the end of the run.

    OUT(eFinal) << "RdChannelAmplitudeCalibrator::Finish()"<<endl;

    return eSuccess;
  }

  void
  RdChannelAmplitudeCalibrator::ApplyResponse(Channel& channel, const TabulatedFunction& response) const
  {
    ChannelFrequencySpectrum& channelspectrum = channel.GetChannelFrequencySpectrum();
    for (ChannelFrequencySpectrum::SizeType i = 0; i < channelspectrum.GetSize(); ++i) {
      const double freq = channel.GetFrequencyOfBin(i);

      if ( (freq>=response.XFront()) && (freq<=response.XBack()) ) {
        channelspectrum[i] *= response.Y(freq);
      }
    }
  }

}