RdTimeJitterAdder.cc

Go to the documentation of this file.

#include "RdTimeJitterAdder.h"

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

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

#include <det/Detector.h>
#include <rdet/RDetector.h>
#include <sdet/SDetector.h>

#include <sevt/SEvent.h>
#include <sevt/Station.h>
#include <sevt/StationSimData.h>

#include <utl/AugerUnits.h>
#include <utl/Branch.h>
#include <utl/RandomEngine.h>

#include <CLHEP/Random/RandGauss.h>

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

using CLHEP::RandGauss;


namespace RdTimeJitterAdder {

  VModule::ResultFlag
  RdTimeJitterAdder::Init()
  {
    const Branch topBranch = CentralConfig::GetInstance()->GetTopBranch("RdTimeJitterAdder");
    topBranch.GetChild("sigma").GetData(fSigma);

    ostringstream info;
    info << "\n\t RdTimeJitterAdder is set up with sigma of " << fSigma / ns << " ns.\n";
    INFO(info);

    fRandomEngine = &RandomEngineRegistry::GetInstance().Get(RandomEngineRegistry::eDetector).GetEngine();

    return eSuccess;
  }


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

    REvent& rEvent = event.GetREvent();

    //Loop over all stations and add time jiters
    for (auto& station : rEvent.StationsRange()) {

      if (!station.HasRecData()) {
        ostringstream error;
        error << "Station " << station.GetId() << " does not have rec data.";
        ERROR(error);
      }
      StationRecData& sRec = station.GetRecData();

      if (!sRec.HasParameter(eTraceStartTime)) {
        ostringstream error;
        error << "Station " << station.GetId() << " does not have Parameter eTraceStartTime set!";
        ERROR(error);
        return eFailure;
      }

      /* For RD stations we have to use the same time jitter simulated for the
         other SD detectors (WCD, SSD). Hence if the station id indicated that
         it is a RD station, a corresponding SEvent station is present, and the
         SEvent station has SimData (in which the time jitter is stored), use
         the SEvent station time jitter. If that is not the case, draw a time
         jitter here.
      */
      const int stationId = station.GetId();
      const int rdSdStationIdLink = det::Detector::GetInstance().GetRDetector().GetRdSdStationIdLink();

      if (stationId > rdSdStationIdLink) {  // is a RD station
        if (event.HasSEvent()) {
          sevt::SEvent& sEvent = event.GetSEvent();

          if (sEvent.HasStation(stationId - rdSdStationIdLink)) {
            const sevt::Station& sStation = sEvent.GetStation(stationId - rdSdStationIdLink);

            if (sStation.HasSimData()) {
              const double traceStartTime = sRec.GetParameter(eTraceStartTime);
              const double timeJitter = sStation.GetSimData().GetAbsoluteTimeOffset();
              const double timingUncertainty =
                det::Detector::GetInstance().GetSDetector().GetStation(stationId - rdSdStationIdLink).GetTimingUncertainty();

              // keep parameter open, might need to be overwritten
              sRec.SetParameter(eTraceStartTime, traceStartTime + timeJitter, false);
              sRec.SetParameterError(eTraceStartTime, timingUncertainty, false);

              continue; // time jitter applied, continue with next station
              // if no time jitter from SD could be applied treat RD station like an AERA station
            }
          }
        }
      }

      // in case fSigma is 0, no time jitter is drawn and only the uncertainty is set to 0.
      if (fSigma > 0) {
        const double mean = 0;
        const double traceStartTime = sRec.GetParameter(eTraceStartTime);
        const double jitter = RandGauss::shoot(fRandomEngine, mean, fSigma);

        // keep parameters open because it might be overwritten by other modules
        sRec.SetParameter(eTraceStartTime, traceStartTime + jitter, false);
        sRec.SetParameterError(eTraceStartTime, fSigma, false);
      } else {
        // keep parameter open because it might be overwritten by other modules
        sRec.SetParameterError(eTraceStartTime, 0 * utl::ns, false);
      }
    }

    return eSuccess;
  }


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

}