RdStationTimingCalibrator.cc

Go to the documentation of this file.

#include "RdStationTimingCalibrator.h"

#include <fwk/CentralConfig.h>
#include <utl/ReadStream.h>
#include <utl/AugerUnits.h>

#include <evt/Event.h>
#include <revt/REvent.h>
#include <revt/StationRecData.h>

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

#include <string>
#include <vector>


using namespace evt;
using namespace revt;
using namespace std;
using namespace utl;
using namespace fwk;


namespace RdStationTimingCalibratorOG {


  struct OffsetEntry {
    unsigned int stationId;
    double offset;
    double uncertainty;
  };


  inline
  istream&
  operator>>(istream& is, OffsetEntry& entry)
  {
    return is >> entry.stationId >> ws >> entry.offset >> ws >> entry.uncertainty;
  }


  VModule::ResultFlag
  RdStationTimingCalibrator::Init()
  {
    // trigger detector update to read standard station positions
    Branch topB = CentralConfig::GetInstance()->GetTopBranch("RdStationTimingCalibrator");

    topB.GetChild("TimingOffset_Butterfly_DE").GetData(fTimingOffset_Butterfly_DE);
    topB.GetChild("TimingOffset_Butterfly_NL").GetData(fTimingOffset_Butterfly_NL);
    topB.GetChild("TimingOffset_LPDA_DE").GetData(fTimingOffset_LPDA_DE);
    topB.GetChild("TimingOffset_LPDA_NL").GetData(fTimingOffset_LPDA_NL);
    topB.GetChild("TimingOffset_RD").GetData(fTimingOffset_RD);

    topB.GetChild("TimingUncertainty_Butterfly_DE").GetData(fTimingUncertainty_Butterfly_DE);
    topB.GetChild("TimingUncertainty_Butterfly_NL").GetData(fTimingUncertainty_Butterfly_NL);
    topB.GetChild("TimingUncertainty_LPDA_DE").GetData(fTimingUncertainty_LPDA_DE);
    topB.GetChild("TimingUncertainty_LPDA_NL").GetData(fTimingUncertainty_LPDA_NL);
    topB.GetChild("TimingUncertainty_RD").GetData(fTimingUncertainty_RD);

    const string rdStationTimeOffsetsFile =
      topB.GetChild("RdStationTimeOffsetsFile").Get<string>();

    ifstream posFile(rdStationTimeOffsetsFile.c_str());
    if (!posFile.is_open()) {
      ostringstream err;
      err << "Cannot open time offsets file '" << rdStationTimeOffsetsFile << "'!";
      ERROR(err);
      return eFailure;
    }

    vector<OffsetEntry> offsets;
    ReadStream(posFile).GetLines(offsets);

    fOffsets.clear();

    for (const auto& entry : offsets) {
      const unsigned int sId = entry.stationId;

      try {
        // check for double entries in GPS positions correction file
        if (fOffsets.find(sId) != fOffsets.end()) {
          ostringstream err;
          err << "Duplicate entry for station id " << sId << " found in the offsets file!";
          ERROR(err);
          return eFailure;
        }

        // store offset
        fOffsets.emplace(entry.stationId, make_pair(entry.offset * ns, entry.uncertainty * ns));

      } catch (NonExistentComponentException&) {
        ostringstream warn;
        warn << "Station id " << sId << " has a time offset in the corrections file but is not found in the RDetector!";
        WARNING(warn);
      }
    }

    return eSuccess;
  }


  VModule::ResultFlag
  RdStationTimingCalibrator::Run(Event& event)
  {
    if (!event.HasREvent())
      return eSuccess;

    REvent& rEvent = event.GetREvent();

    for (auto& station : rEvent.StationsRange()) {

      if (!station.HasRecData())
        continue;

      StationRecData& recData = station.GetRecData();

      if (!recData.HasParameter(eTraceStartTime)) {
        ostringstream err;
        err << "Trying to correct trace start time for " <<
               "station id " << station.GetId() << ", but no trace start time available in ParameterStorage!";
        ERROR(err);
        return eFailure;
      }

      const TimeInterval oldTime = recData.GetParameter(eTraceStartTime);
      const auto& offsetIt = fOffsets.find(station.GetId()); // search for correction value for individual station

      const rdet::RDetector& rDetector = det::Detector::GetInstance().GetRDetector();
      const rdet::Channel& detChannel = rDetector.GetStation(station.GetId()).GetChannel(1);
      const string antennaTypeName = detChannel.GetAntennaTypeName();
      const int bitDepth = detChannel.GetBitDepth();

      double stationOffset = 0;
      double stationUncertainty = 0;

      if (offsetIt == fOffsets.end()) { // no correction value found for station. use hardware default.
        if (antennaTypeName.find("Butterfly") != string::npos && bitDepth == 12){
           stationOffset = fTimingOffset_Butterfly_DE;
           stationUncertainty = fTimingUncertainty_Butterfly_DE;
        } else if (antennaTypeName.find("Butterfly") != string::npos && bitDepth == 14){
           stationOffset = fTimingOffset_Butterfly_NL;
           stationUncertainty = fTimingUncertainty_Butterfly_NL;
        } else if (antennaTypeName.find("SmallBlackSpider") != string::npos && bitDepth == 12){
           stationOffset = fTimingOffset_LPDA_DE;
           stationUncertainty = fTimingUncertainty_LPDA_DE;
        } else if (antennaTypeName.find("SmallBlackSpider") != string::npos && bitDepth == 14){
           stationOffset = fTimingOffset_LPDA_NL;
           stationUncertainty = fTimingUncertainty_LPDA_NL;
        } else if (station.GetId() > rDetector.GetRdSdStationIdLink()) {
           stationOffset = fTimingOffset_RD;
           stationUncertainty = fTimingUncertainty_RD;
        } else {
          // only release warining if station is candiate, i.e. if not rejected nor excluded
          if (station.IsCandidate()) {
            // if also not in hardware lists there is no defined correction value available.
            // no offset will be applied and a warning is trown.
            ostringstream warning;
            warning << "No correction value found for station id=" << station.GetId()
                    << " and no correction value found for hardware type (" << antennaTypeName << "," << bitDepth << " bits)"
                    << ". This might cause inconsistent analysis results!";
            WARNING(warning);
          }
          continue;
        }
      } else {
        stationOffset = offsetIt->second.first;
        stationUncertainty = offsetIt->second.second;
      }

      const TimeInterval& offset = stationOffset;

      // set corrected start time, keep parameter open
      recData.SetParameter(eTraceStartTime, oldTime + offset, false);

      // store value that has been added to the trace start time
      recData.SetParameter(eTraceStartTimeCorrectionByTimeCalibration, offset);

      if (recData.HasParameterError(eTraceStartTime)) {
        /* If an uncertainty has already been set by the RdChannelBeaconTimingCalibrator (runs before this module).
           Keep the uncertainty, not override. Only set (default) uncertainty if not set yet. No other module
           (than RdChannelBeaconTimingCalibrator) should set it. Once the ModuleSequence is adjusted such that the this module
           can run before the RdChannelBeaconTimingCalibrator. This comment can be deleted and the ERROR below can be activated. */

        //ERROR("revt::StationRecData has already ParameterError for eTraceStartTime but it should not. Check whats going on.");
      } else {
        recData.SetParameterError(eTraceStartTime, stationUncertainty, false); // keep parameter open
      }

      // also change relative position of signal search window accordingly
      recData.SetParameter(eSignalSearchWindowStart, recData.GetParameter(eSignalSearchWindowStart) - offset, false);
      recData.SetParameter(eSignalSearchWindowStop, recData.GetParameter(eSignalSearchWindowStop) - offset, false);
    }

    return eSuccess;
  }


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

}