RdChannelVoltageToADCConverter.cc

Go to the documentation of this file.

#include "RdChannelVoltageToADCConverter.h"

#include <fwk/CentralConfig.h>

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

#include <evt/Event.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>


using namespace revt;
using namespace fwk;
using namespace utl;


namespace RdChannelVoltageToADCConverter {

  VModule::ResultFlag
  RdChannelVoltageToADCConverter::Init()
  {
    return eSuccess;
  }


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

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

    // loop through stations and for every station through every channel
    for (auto& station : rEvent.StationsRange()) {
      for (auto& channel : station.ChannelsRange()) {

        const rdet::Channel& channelDet =
          detector.GetRDetector().GetStation(station.GetId()).GetChannel(channel.GetId());

        // get channel information from detector
        const double bitDepth = channelDet.GetBitDepth();
        const double samplingFrequency = channelDet.GetSamplingFrequency();
        const double minVoltage = channelDet.GetMinVoltage();
        const double maxVoltage = channelDet.GetMaxVoltage();
        const double voltagePerCount = (maxVoltage - minVoltage) / pow(2, bitDepth);

         // assume that the pedestal of the ADC corresponds to the middle of its voltage range
        const double voltagePedestal = 0.5 * (minVoltage + maxVoltage);

        const ChannelTimeSeries& trace = channel.GetChannelTimeSeries();
        const double traceBinning = trace.GetBinning();

        if (!CloseTo(1.0 / traceBinning, samplingFrequency, 1e-5)) {
          std::ostringstream warning;
          warning << "\n\tVoltage Sampling Frequency of "
                  << samplingFrequency / (mega * hertz)
                  << " MHz does not match sampling frequency of data, which is "
                  << 1.0 / traceBinning / (mega * hertz)
                  << " MHz. Aborting ...";
          WARNING(warning);
          return eFailure;
        }

        // do the conversion for the full trace, this implies that the simulated data have no DC offset,
        // which is fulfilled if the detector response has been applied already
        ChannelADCTimeSeries& adcTrace = channel.GetChannelADCTimeSeries();
        adcTrace.Clear();
        adcTrace.SetBinning(traceBinning);

        for (const auto& entry : trace) {
          int adcCount = floor((entry + voltagePedestal - minVoltage) / voltagePerCount);
          adcCount += int(minVoltage / voltagePerCount);

          // check for under- and overflows of the ADC
          if (adcCount < (minVoltage / voltagePerCount))
            adcCount = minVoltage / voltagePerCount;

          if (adcCount > maxVoltage / voltagePerCount -1)
            adcCount = maxVoltage / voltagePerCount - 1;

          // add count to trace
          adcTrace.PushBack(adcCount);
        }
      }
    }

    return eSuccess;
  }


  VModule::ResultFlag
  RdChannelVoltageToADCConverter::Finish()
  {
    return eSuccess;
  }


  bool
  RdChannelVoltageToADCConverter::CloseTo(const double a, const double b, const double tolerance)
  {
    return fabs(a - b) < tolerance;
  }


}