RdChannelADCToVoltageConverter.cc

Go to the documentation of this file.

#include "RdChannelADCToVoltageConverter.h"

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

#include <utl/config.h>
#include <utl/AugerUnits.h>
#include <utl/ErrorLogger.h>
#include <utl/Reader.h>
#include <utl/TraceAlgorithm.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>

#include <string>

using namespace revt;
using namespace fwk;
using namespace utl;
using std::ostringstream;


namespace RdChannelADCToVoltageConverter {


  VModule::ResultFlag
  RdChannelADCToVoltageConverter::Init()
  {
    Branch topBranch =
      CentralConfig::GetInstance()->GetTopBranch("RdChannelADCToVoltageConverter");
    topBranch.GetChild("InfoLevel").GetData(fInfoLevel);

    fFailOnWrongADCFrequency =
      topBranch.GetChild("FailOnWrongADCFrequency").Get<std::string>() ==  "yes";

    return eSuccess;
  }


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

    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()) {

        if (!channel.IsActive())
          continue;

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

        // 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);
        const double traceBinning = adcTrace.GetBinning();
        const double traceMax = TraceAlgorithm::Max(adcTrace, 0, adcTrace.GetSize() - 1);
        const double traceMin = TraceAlgorithm::Min(adcTrace, 0, adcTrace.GetSize() - 1);

        if (!CloseTo(1.0 / traceBinning, samplingFrequency, 1e-6)) {
          ostringstream info;
          info << "ADC Sampling Frequency of station " << station.GetId()
               << ", Channel " << channel.GetId()
               << " according to detector config is "
               << samplingFrequency / (mega * hertz)
               << " MHz and does not match sampling frequency of data, which is "
               << 1.0 / traceBinning / (mega * hertz) << " MHz.";

          if (fFailOnWrongADCFrequency) {
            info << "Aborting.";
            ERROR(info);
            return eFailure;
          } else {
            info << "Excluding station.";
            ERROR(info);
            station.SetExcludedReason(revt::eHardwareMismatch);
            continue;
          }
        }

        // illegal entries
        if ((traceMin < minVoltage / voltagePerCount) || (traceMax > maxVoltage / voltagePerCount - 1)) {
          ostringstream info;
          info << "ADC trace of Channel " << channel.GetId()
               << ", Station "  << station.GetId() << " has illegal entries.\n"
               << "Allowed trace minimum is: "  << minVoltage / voltagePerCount
               << " and current trace minimum: " << traceMin << ".\n"
               << "Allowed trace maximum is: " << maxVoltage / voltagePerCount - 1
               << " and current trace maximum: " << traceMax <<".\nAborting ...";
          ERROR(info);

          // let the pipeline fail. This should not be happening and thus not glossed over
          return eFailure;
        }

        // saturations
        if ((traceMin == minVoltage / voltagePerCount) || (traceMax == minVoltage / voltagePerCount - 1)) {
          ostringstream info;
          info << "ADC trace of Channel " << channel.GetId()
               << ", Station "  << station.GetId() << " has saturated samples!";
          INFOIntermediate(info);

          channel.SetSaturated();
          fNumberOfSaturatedChannels++;
        }

        // do the conversion from ADC counts to voltage
        revt::ChannelTimeSeries& trace = channel.GetChannelTimeSeries();
        trace.Clear();
        trace.SetBinning(adcTrace.GetBinning());
        trace = minVoltage + adcTrace * voltagePerCount;

        if(fInfoLevel >= eInfoDebug) {
          ostringstream info;
          info << "Station " << station.GetId() << " Channel " << channel.GetId()
               << " has minVoltage = " << minVoltage << " and voltageperCount = "
               << voltagePerCount;
          INFO(info);
        }
      }
    }

    return eSuccess;
  }


  VModule::ResultFlag
  RdChannelADCToVoltageConverter::Finish()
  {
    ostringstream info;
    info << "There were " << fNumberOfSaturatedChannels << " saturated channels!";
    INFO(info);

    return eSuccess;
  }


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

}