TriggerTimeCorrection.cc

Go to the documentation of this file.

#include "TriggerTimeCorrection.h"

#include <evt/Event.h>
#include <sevt/SEvent.h>
#include <sevt/EventTrigger.h>

#include <det/VManager.h>

#include <fwk/LocalCoordinateSystem.h>
#include <fwk/CentralConfig.h>
#include <utl/Is.h>

#include <boost/assign.hpp>
#include <algorithm>

using namespace evt;
using namespace sevt;

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


namespace TriggerTimeCorrection {

  const TriggerTimeCorrection::TriggerSoftware TriggerTimeCorrection::fgFirstSoftware("251003", TimeStamp());


  VModule::ResultFlag
  TriggerTimeCorrection::Init()
  {
    INFO("TriggerTimeCorrection::Init()");
    auto topB = CentralConfig::GetInstance()->GetTopBranch("TriggerTimeCorrection");

    fTriggerMap.clear();

    for (auto b = topB.GetFirstChild(); b; b = b.GetNextSibling()) {

      const unsigned int stationId =
        det::VManager::FindComponent<size_t>("stationId", b.GetAttributes());

      if (Is(stationId).In(fTriggerMap)) {
        ERROR("Duplicate station entries!");
        return eFailure;
      }

      vector<TriggerSoftware> trigger(1, fgFirstSoftware);

      for (auto c = b.GetFirstChild(); c; c = c.GetNextSibling()) {
        const auto& softName = det::VManager::FindComponent<string>("name", c.GetAttributes());
        const auto installationTime = c.Get<TimeStamp>();
        trigger.emplace_back(softName, installationTime);
      }

      sort(trigger.begin(), trigger.end());

      fTriggerMap.insert(make_pair(stationId, trigger));
    }

    return eSuccess;
  }


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

    auto& sEvent = event.GetSEvent();
    const auto& eventTime = sEvent.GetTrigger().GetTime();

    ostringstream stationOutput;

    for (auto& s : sEvent.StationsRange()) {
      if (!s.HasTriggerData())
        continue;
      const auto& triggerSoft = GetTriggerSoftware(s.GetId(), eventTime);
      const auto& version = triggerSoft.fVersion;
      const auto timeOffset = GetTimeOffset(version);

      auto& trigData = s.GetTriggerData();
      trigData.SetPLDTimeOffset(timeOffset);
      trigData.SetPLDVersion(version);

      if (timeOffset.GetInterval() > numeric_limits<double>::min())
        stationOutput << " (id=" << s.GetId() << ", "
                         "PLD='" << version << "', "
                         "offset=" << timeOffset/ns << "ns)";
    }

    const auto stationList = stationOutput.str();
    if (!stationList.empty()) {
      ostringstream info;
      info << "for event at time " << eventTime << " the following corrections "
              "were applied to stations:" << stationList;
      INFO(info);
    }

    return eSuccess;
  }


  const TriggerTimeCorrection::TriggerSoftware&
  TriggerTimeCorrection::GetTriggerSoftware(const unsigned int stId,
                                            const TimeStamp& time)
    const
  {
    const auto mapIter = fTriggerMap.find(stId);
    if (mapIter == fTriggerMap.end())
      return fgFirstSoftware;

    const auto& trigger = mapIter->second;

    for (size_t i = 1, n = trigger.size(); i < n; ++i) {
      const auto& curr = trigger[i];
      const auto& prev = trigger[i-1];
      if (prev.fInstallationTime < time && time < curr.fInstallationTime)
        return prev;
    }

    return trigger.empty() ? fgFirstSoftware : trigger.back();
  }


  TimeInterval
  TriggerTimeCorrection::GetTimeOffset(const string& triggerName)
    const
  {
    typedef map<string, TimeInterval> OffsetMap;
    static const OffsetMap offsets({
      { "160703", 0 },
      { "251003", 0 },
      { "140205", 0 },
      { "060405", 0 },
      { "030805", 0 },
      { "250210", 0 },
      { "071110", 0 },
      { "211110", 75*ns },
      { "270211", 100*ns },
      { "190511", 100*ns },
      { "020811", 100*ns },
      { "171011", 100*ns },
      { "191011", 100*ns },
      { "121211", 100*ns },
      { "200112", 100*ns },
      { "220512", 100*ns },
      { "230512", 100*ns },
      { "270612", 100*ns }
    });

    const auto it = offsets.find(triggerName);
    if (it != offsets.end())
      return it->second;

    ostringstream err;
    err << "Unknown PLD version " << triggerName;
    ERROR(err);
    throw InvalidConfigurationException(err.str());

    return TimeInterval();
  }

}