FdEyeMerger.cc

Go to the documentation of this file.

#include <fwk/VModule.h>
#include <utl/ErrorLogger.h>

#include <det/Detector.h>
#include <fdet/FDetector.h>
#include <fdet/FDetComponentSelector.h>
#include <fdet/Eye.h>
#include <fdet/Telescope.h>
#include <evt/Event.h>
#include <fevt/FEvent.h>
#include <fevt/Eye.h>
#include <fevt/Telescope.h>
#include <fevt/EyeHeader.h>
#include <fevt/EyeTriggerData.h>

#include "FdEyeMerger.h"

#include <sstream>

using namespace std;
using namespace fwk;
using namespace utl;
using namespace evt;
using namespace det;
using namespace fdet;
using namespace fevt;
using namespace FdEyeMergerKG;


// helper function (physical eyeId, physical telId) --> (virtual telId)
unsigned int
GetVirtualTelescopeId(const unsigned int virtualEyeId,
                      const unsigned int eyeId, const unsigned int telId)
{
  const FDetector& fdDet = det::Detector::GetInstance().GetFDetector();
  const fdet::Eye& eye = fdDet.GetEye(virtualEyeId);
  if (!eye.IsVirtual())
    throw NonExistentComponentException("eye is not virtual");

  for (fdet::Eye::TelescopeIterator telIter = eye.TelescopesBegin();
       telIter != eye.TelescopesEnd(); ++telIter) {
    if (telIter->GetParentPhysicalEyeId() == eyeId &&
        telIter->GetParentPhysicalId() == telId)
      return telIter->GetId();
  }

  throw NonExistentComponentException("could not find telescope id");
  return 0;
}


VModule::ResultFlag
FdEyeMerger::Init()
{
  const fdet::FDetector& fdDet = det::Detector::GetInstance().GetFDetector();

  for (FDetector::EyeIterator eIt = fdDet.EyesBegin(FDetComponentSelector::eVirtual),
       end = fdDet.EyesEnd(FDetComponentSelector::eVirtual); eIt != end; ++eIt) {
    const fdet::Eye& eye = *eIt;
    const int id = eye.GetId();

    if (!fEyeMergeMap[id].empty()) {
      ostringstream errMsg;
      errMsg << "multiple occurrance of mergedEye with id " << id << " --> ignored!";
      ERROR(errMsg);
      continue;
    }

    const EyeIds eyesInDetector = eye.GetParticipatingEyeIds();
    if (eyesInDetector.empty()) {
      ostringstream errMsg;
      errMsg << "empty set of participating eyes for virtual eye with id=" << id
             << " --> ignored!";
      ERROR(errMsg);
      continue;
    }

    fEyeMergeMap[id] = eyesInDetector;
  } // end foreach virtual eye

  ostringstream info;
  info << " Version: " << GetVersionInfo(VModule::eRevisionNumber) << "\n";
  for (EyeMapIterator eyeMapIter = fEyeMergeMap.begin();
        eyeMapIter != fEyeMergeMap.end(); ++eyeMapIter) {
    info << "\t merge eye (";
    for (EyeIdsIterator eyeIter = eyeMapIter->second.begin();
          eyeIter != eyeMapIter->second.end(); ++eyeIter) {
      if (eyeIter != eyeMapIter->second.begin())
        info << ", ";
      info << *eyeIter;
    }
    info << ") -->" << eyeMapIter->first << "\n";
  }
  INFO(info);

  return eSuccess;
}


VModule::ResultFlag
FdEyeMerger::Run(evt::Event& event)
{
  if (!event.HasFEvent())
    return eSuccess;

  const FEvent& fdEvent = event.GetFEvent();

  for (EyeMapIterator eyeMapIter = fEyeMergeMap.begin();
       eyeMapIter != fEyeMergeMap.end(); ++eyeMapIter) {

    const int mergedEye = eyeMapIter->first;
    if (fdEvent.HasEye(mergedEye)) {
      ostringstream errMsg;
      errMsg << "attempt to merge into existing eye " << mergedEye
             << " --> ignored!";
      ERROR(errMsg);
      continue;
    }

    EyeIds eyesInEvent;
    for (EyeIdsIterator iter = eyeMapIter->second.begin();
         iter != eyeMapIter->second.end(); ++iter)
      if (fdEvent.HasEye(*iter))
        eyesInEvent.insert(*iter);

    if (!eyesInEvent.empty())
      MergeEyes(event, mergedEye, eyesInEvent, eyeMapIter->second);
  }

  return eSuccess;
}


void
FdEyeMerger::MergeEyes(evt::Event& event,
                       const int destinationEye,
                       const set<unsigned int>& eyesInEvent,
                       const set<unsigned int>& eyesInDetector)
{
  fevt::FEvent& fdEvent = event.GetFEvent();

  TimeStamp firstTriggerTime;
  unsigned int firstEyeId = 0;
  for (EyeIdsIterator eyeIdIter = eyesInEvent.begin();
       eyeIdIter != eyesInEvent.end(); ++eyeIdIter) {
    const fevt::EyeHeader& thisEyeHeader = fdEvent.GetEye(*eyeIdIter).GetHeader();
    if (!firstTriggerTime || thisEyeHeader.GetTimeStamp() < firstTriggerTime) {
      firstTriggerTime = thisEyeHeader.GetTimeStamp();
      firstEyeId = *eyeIdIter;
    }
  }
  const fevt::Eye& firstEye = fdEvent.GetEye(firstEyeId);

  fdEvent.MakeEye(destinationEye);
  fevt::Eye& mergedEye = fdEvent.GetEye(destinationEye);
  mergedEye.MakeHeader();
  mergedEye.MakeTriggerData();

  fevt::EyeHeader& mergedEyeHeader = mergedEye.GetHeader();
  mergedEyeHeader = firstEye.GetHeader();

  fevt::EyeTriggerData& mergedEyeTrigger = mergedEye.GetTriggerData();
  mergedEyeTrigger = firstEye.GetTriggerData();

  for (EyeIdsIterator eyeIdIter = eyesInDetector.begin();
       eyeIdIter != eyesInDetector.end(); ++eyeIdIter) {

    const EyeIdsIterator eyesInDetIter = eyesInEvent.find(*eyeIdIter);

    if (eyesInDetIter != eyesInEvent.end()) {

      const fevt::Eye& thisEye = fdEvent.GetEye(*eyesInDetIter);

      const TimeInterval timeOffset =
        thisEye.GetHeader().GetTimeStamp() - firstTriggerTime;

      for (fevt::Eye::ConstTelescopeIterator telIter = thisEye.TelescopesBegin(ComponentSelector::eInDAQ);
           telIter != thisEye.TelescopesEnd(ComponentSelector::eInDAQ); ++telIter) {
        const int telId = GetVirtualTelescopeId(destinationEye, thisEye.GetId(), telIter->GetId());
        mergedEye.MakeTelescope(telId);
        const unsigned int originalTimeOffset = telIter->GetTimeOffset();
        fevt::Telescope& thisTel = mergedEye.GetTelescope(telId);
        thisTel.Assign(*telIter);
        if (thisTel.GetStatus() >= ComponentSelector::eHasData)
          thisTel.SetTimeOffset(int(originalTimeOffset + timeOffset.GetInterval()));
      }
    } else {
      // use uptime to evaluate mirrors in DAQ for eyes without trigger
      const FDetector& fdDet = det::Detector::GetInstance().GetFDetector();
      const fdet::Eye& thisEye = fdDet.GetEye(*eyeIdIter);
      for (fdet::Eye::TelescopeIterator telIter = thisEye.TelescopesBegin();
           telIter != thisEye.TelescopesEnd(); ++telIter) {
        if (telIter->GetUpTimeFraction() > 0) {
          const int telId = GetVirtualTelescopeId(destinationEye, thisEye.GetId(), telIter->GetId());
          mergedEye.MakeTelescope(telId, fevt::ComponentSelector::eInDAQ);
        }
      }
    }
  }
}


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