EventChecker.cc

Go to the documentation of this file.

#include "EventChecker.h"

#include <fwk/CentralConfig.h>

#include <det/Detector.h>

#include <fdet/FDetector.h>
#include <fdet/Eye.h>

#include <sdet/SDetector.h>
#include <sdet/Station.h>

#include <evt/Header.h>
#include <evt/Event.h>

#include <sevt/SEvent.h>
#include <sevt/Header.h>
#include <sevt/EventTrigger.h>

#include <mdet/MDetector.h>
#include <mdet/Counter.h>
#include <mevt/MEvent.h>
#include <mevt/Header.h>


#include <fevt/FEvent.h>
#include <fevt/Eye.h>
#include <fevt/EyeHeader.h>
#include <fevt/FdComponentSelector.h>

#include <utl/ErrorLogger.h>
#include <utl/Reader.h>
#include <utl/TimeStamp.h>
#include <utl/TabularStream.h>

#include <cstddef>
#include <cstdio>
#include <sstream>

using namespace EventCheckerOG;
using namespace fwk;
using sdet::SDetector;
using namespace evt;
using sevt::SEvent;
using namespace utl;
using namespace std;


VModule::ResultFlag
EventChecker::Init()
{
  Branch topBranch = CentralConfig::GetInstance()->GetTopBranch("EventChecker");

  topBranch.GetChild("SkipTimeZeroEvents").GetData(fSkipTimeZeroEvents);

  // whether FD is configured
  fHaveFDetectorConfig = (
    det::Detector::GetInstance().GetFDetector().EyesBegin() !=
    det::Detector::GetInstance().GetFDetector().EyesEnd()
  );

  if (fHaveFDetectorConfig)
    INFO("FDetector configuration available");
  else
    INFO("FDetector configuration not available, related check disabled");

  return eSuccess;
}


VModule::ResultFlag
EventChecker::Run(evt::Event& event)
{
  ++fNEventsProcessed;

  const auto& time = event.GetHeader().GetTime();

  if (fSkipTimeZeroEvents && !time) {
    WARNING("Skipping event with zero time.");
    ++fNEventsWithZeroTime;
    return eContinueLoop;
  }

  // Check the SDetector definition
  if (event.HasSEvent()) {
    const auto& sEvent = event.GetSEvent();
    for (const auto& station : sEvent.StationsRange()) {
      try {
        det::Detector::GetInstance().GetSDetector().GetStation(station);
      } catch (utl::NonExistentComponentException&) {
        WARNING("Skipping event with SDetector mismatch.");
        ++fNEventsWithMissingStations;
        return eContinueLoop;
      }
    }
  }

  // Check the FDetector definition
  if (event.HasFEvent() && fHaveFDetectorConfig) {
    const auto& fEvent = event.GetFEvent();
    for (fevt::FEvent::ConstEyeIterator eIt = fEvent.EyesBegin(fevt::ComponentSelector::eHasData),
         end = fEvent.EyesEnd(fevt::ComponentSelector::eHasData); eIt != end; ++eIt) {
      try {
        det::Detector::GetInstance().GetFDetector().GetEye(*eIt);
        for (fevt::Eye::ConstTelescopeIterator tIt = eIt->TelescopesBegin(fevt::ComponentSelector::eHasData),
             end = eIt->TelescopesEnd(fevt::ComponentSelector::eHasData); tIt != end; ++tIt) {
          det::Detector::GetInstance().GetFDetector().GetTelescope(*tIt);
        }
      } catch (utl::NonExistentComponentException&) {
        WARNING("Skipping event with FDetector mismatch.");
        ++fNEventsWithMissingEyes;
        return eContinueLoop;
      }
    }
  }

  // Check the MDetector definition
  if (event.HasMEvent()) {
    const auto& mEvent = event.GetMEvent();
    for (mevt::MEvent::CounterConstIterator cIt  = mEvent.CountersBegin(),
         end = mEvent.CountersEnd(); cIt != end; ++cIt) {
      try {
        det::Detector::GetInstance().GetMDetector().GetCounter(cIt->GetId());
      } catch (utl::NonExistentComponentException&) {
        WARNING("Skipping event with MDetector mismatch.");
        ++fNEventsWithMissingCounters;
        return eContinueLoop;
      }
    }
  }

  ++fNEventsAccepted;

  return eSuccess;
}


VModule::ResultFlag
EventChecker::Finish()
{
  if (fNEventsProcessed) {

    const int nDiscarded = fNEventsProcessed - fNEventsAccepted;

    TabularStream tab("r  r  .");

    tab << endc << 'N' << endc << '%' << endr
        << "Events processed:" << endc << fNEventsProcessed << endc << 100 << endr
        << "Events skiped:" << endc << nDiscarded << endc << int(nDiscarded*1000./fNEventsProcessed)/10. << endr
        << "1980 (time-zero):" << endc << fNEventsWithZeroTime << endc << int(fNEventsWithZeroTime*1000./fNEventsProcessed)/10. << endr
        << "SD station err:" << endc << fNEventsWithMissingStations << endc << int(fNEventsWithMissingStations*1000./fNEventsProcessed)/10. << endr
        << "FD eye err:" << endc << fNEventsWithMissingEyes << endc << int(fNEventsWithMissingEyes*1000./fNEventsProcessed)/10.
        << endr << "MD counter err:" << endc << fNEventsWithMissingCounters << endc << int(fNEventsWithMissingCounters*1000./fNEventsProcessed)/10.
        ;
    ostringstream info;
    info << '\n' << tab;
    INFO(info);

  } else {
    INFO("No events processed.");
  }

  return eSuccess;
}