RdChannelSelector.cc

Go to the documentation of this file.

#include "RdChannelSelector.h"

#include <fwk/CentralConfig.h>

#include <utl/ErrorLogger.h>
#include <utl/Reader.h>
#include <utl/config.h>

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

#include <det/Detector.h>
#include <rdet/Channel.h>


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


namespace RdChannelSelector {

  VModule::ResultFlag
  RdChannelSelector::Init()
  {
    // Read in the configurations of the xml file
    Branch topBranch = CentralConfig::GetInstance()->GetTopBranch("RdChannelSelector");
    topBranch.GetChild("InfoLevel").GetData(fInfoLevel);
    topBranch.GetChild("UseLowGainIfHighGainIsSaturated").GetData(fUseLowGainIfHighGainIsSaturated);

    if(!fUseLowGainIfHighGainIsSaturated) {
      ostringstream info;
      info << "RdChannelSelector set up to replace saturated high gain channels.";
      INFO(info);
    }

    return eSuccess;
  }


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

    ostringstream info;

    REvent& rEvent = event.GetREvent();
    const rdet::RDetector& rDetector = det::Detector::GetInstance().GetRDetector();

    const double tolerance = 1e-3;

    for (auto& station : rEvent.StationsRange()) {
      unsigned int activeChannels = 0;

      for (auto& channel : station.ChannelsRange()) {
        const auto& detChannel = rDetector.GetStation(station.GetId()).GetChannel(channel.GetId());
        const string channelType = detChannel.GetChannelType();

        info.str("");
        info << "station " << station.GetId() << " channel " << channel.GetId() << " has type "
             << channelType << " and is active? " << channel.IsActive();
        INFODebug(info);

        if (!channel.IsActive())
          continue;

        /* At EventIO level we do not know that a channel is empty. So we get this information
           here from the database and set emtpy channels as not active */
        if (channelType == "Empty") {
          info.str("");
          info << "station " << station.GetId() << " Channel " << channel.GetId()
               << " has type Empty but is active. Set to not active.";
          INFOIntermediate(info);

          channel.SetNotActive();
          continue;
        }

        /* Filtered channels are used by NL stations for triggering and are not used in
           standard reconstructions */
        if (channelType == "FilteredHighGain" || channelType == "FilteredLowGain") {
          info.str("");
          info << "station " << station.GetId() << " Channel " << channel.GetId()
               << " has type " << channelType << " but is active. Set to not active.";
          INFOIntermediate(info);

          channel.SetNotActive();
          continue;
        }

        /* Loop over high gain channels and check if the high gain or a corresponding
           low gain channel should be used if it exists */
        if (channelType == "AntennaHighGain") {
            activeChannels++;

          // is there a corresponding low gain channel?
          const auto& lowGainChannel = GetLowGainChannel(station, rDetector, detChannel, tolerance);
          const bool hasLowGainChannel = lowGainChannel.is_initialized();

          // when to use low gain channel
          if (fUseLowGainIfHighGainIsSaturated &&
              channel.IsSaturated() && hasLowGainChannel) {
            channel.SetNotActive();

            info.str("");
            info << "Saturated high gain channel " << channel.GetId() << " of station " << station.GetId()
                 << " deactivated. Use low gain channel " << lowGainChannel->GetId() << " instead.";
            INFOIntermediate(info);
            continue;
          }

          // use high gain channel
          if (hasLowGainChannel)
            lowGainChannel->SetNotActive();

          info.str("");
          info << "Using high gain channel " << channel.GetId() << " of station " << station.GetId() << ".";
          INFOIntermediate(info);
          continue;
        }
      } // channel loop

      if (activeChannels < 2 || activeChannels > 3) {
        info.str("");
        info << "Station " << station.GetId() << " does not have two or three active channels, "
             << "station will be excluded.";
        WARNING(info);
        station.SetExcludedReason(eHardwareMismatch);
      }
    } // station loop

    return eSuccess;
  }


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


  boost::optional<revt::Channel&>
  RdChannelSelector::GetLowGainChannel(revt::Station& station,
                                       const rdet::RDetector& rDetector,
                                       const rdet::Channel& detChannel,
                                       const double tolerance)
  {
    for (auto& newChannel : station.ChannelsRange()) {
      const auto& newDetChannel = rDetector.GetStation(station.GetId()).GetChannel(newChannel.GetId());

      if (IsClose(detChannel.GetOrientationZenith(), newDetChannel.GetOrientationZenith(), tolerance)
          && IsClose(detChannel.GetOrientationAzimuth(), newDetChannel.GetOrientationAzimuth(), tolerance)
          && IsClose(detChannel.GetOrientationZeta(), newDetChannel.GetOrientationZeta(), tolerance)
          && newDetChannel.GetChannelType() == "AntennaLowGain") {

        return newChannel;
      }
    }

  return boost::none;
  }


  bool
  RdChannelSelector::IsClose(const double a, const double b, const double tolerance)
  {
    return fabs(a - b) < tolerance;
  }

}