RdStationRejector.cc

Go to the documentation of this file.

#include "RdStationRejector.h"

#include <fwk/CentralConfig.h>

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

#include <utl/Branch.h>
#include <utl/ErrorLogger.h>
#include <utl/String.h>

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

#include <vector>


using namespace std;
using namespace fwk;
using namespace det;
using namespace utl;
using namespace evt;
using namespace revt;


namespace RdStationRejector {

  void
  RdStationRejector::ExcludeOrRejectStation(Station& station, unsigned long long int reason=1)
  {
    if (fExcludeStations) {
      if (reason > 1)
        station.SetExcludedReason(eInBadPeriod);
      else
        station.SetExcludedReason(eManuallyExcluded);
    } else {
      station.SetRejectedReason(reason);  // use bad period DB reason
    }
  }


  VModule::ResultFlag
  RdStationRejector::Init()
  {
    const Branch topB = CentralConfig::GetInstance()->GetTopBranch("RdStationRejector");
    topB.GetChild("InfoLevel").GetData(fInfoLevel);
    topB.GetChild("useStationsInStationList").GetData(fUseStationsInStationList);
    topB.GetChild("stationList").GetData(fStationList);
    topB.GetChild("excludeStations").GetData(fExcludeStations);
    topB.GetChild("excludeNlStations").GetData(fExcludeNlStations);
    topB.GetChild("useBadPeriodDB").GetData(fUseBadPeriodDB);

    fBadPeriodReasons =
      static_cast<unsigned long long int>((((1ULL << (eNumRejectionStatusBits - 1)) - 1) << 1) + 1);

    const auto rejectAllExceptOf =
      topB.GetChild("rejectAllBadPeriodReasonsExceptOf").Get<vector<string>>();
    for (const auto& elem : rejectAllExceptOf) {
      fBadPeriodReasons = fBadPeriodReasons ^ gMapRejectionStatus[elem];
    }

    ostringstream msg;

    if (fUseStationsInStationList) {
      if (fStationList.empty()) {
        ERROR("Only select stations for list but list is empty!");
        return eFailure;
      }
      msg << "Use only the following stations:";
    } else {
      msg << "Exclude or reject the following stations:";
    }
    for (auto & id: fStationList)
      msg << " " << id;
    msg << ".";

    msg << "\nExclude stations (instead of rejecting them) : " << fExcludeStations
        << "\nExclude all stations with NL electronis: " << fExcludeNlStations
        << "\nUse BadPeriod DB: " << fUseBadPeriodDB
        << "\nRegister additional BadStations:";

    fRejectMap.clear();
    for (Branch b = topB.GetFirstChild(); b; b = b.GetNextSibling()) {
      if (b.GetName() != "BadStation")
        continue;

      const size_t stationId = VManager::FindComponent<size_t>("id", b.GetAttributes());
      const string reason = VManager::FindComponent<string>("reason", b.GetAttributes());
      vector<utl::TimeStamp> range;
      b.GetData(range);
      fRejectMap.insert(make_pair(range[0], make_pair(range[1], stationId)));
      msg << "\n  registered: id = " << stationId << " [" << range[0] << ", " << range[1] << ")";
    }

    INFOFinal(msg);

    return fRejectMap.empty() ? eFailure : eSuccess;
  }


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

    REvent& rEvent = event.GetREvent();
    Detector& detector = Detector::GetInstance();

    ostringstream info;

    if (detector.GetTime() != event.GetHeader().GetTime())
      detector.Update(event.GetHeader().GetTime());

    const rdet::RDetector& rDetector = detector.GetRDetector();

    if (fExcludeNlStations) {
      for (auto& station : rEvent.StationsRange()) {
        // Get bit depth to distinguish between german (12) and dutch stations (14)
        const auto& detChannel = rDetector.GetStation(station.GetId()).GetChannel(1);
        const int bitDepth = detChannel.GetBitDepth();

        if (bitDepth != 12 && bitDepth != 14) {
          info.str("");
          info << "Station " << station.GetId() << " has invalid bit depth of " << bitDepth
               << ". Can not decide if DE or NL electronics. Station is not rejected.";
          WARNING(info);
          continue;
        }

        if (bitDepth == 14) {
          info.str("");
          info << "Station " << station.GetId() << " has NL electronics. Station is excluded.";
          INFOIntermediate(info);

          station.SetExcludedReason(eManuallyExcluded);
          continue;
        }
      }
    }

    // reject station that are in bad period database
    if (fUseBadPeriodDB) {
      for (auto& station : rEvent.StationsRange()) {
        unsigned long long int reason = rDetector.GetBadStationReason(station.GetId());
        if (reason & fBadPeriodReasons) {
          info.str("");
          info << "Excluded station " << station.GetId()
               << " as bad period because of reason " << (reason & fBadPeriodReasons);
          INFOFinal(info);
          ExcludeOrRejectStation(station, reason);
        }
      }
    }

    // manually reject stations - bad station
    const TimeStamp& time = detector.GetTime();
    TimeRangeMap::IdCollection badIds = fRejectMap.GetBadStations(time);
    vector<int> deselectedIds;

    for (auto& stationId : badIds) {
      if (rEvent.HasStation(stationId)) {
        deselectedIds.push_back(stationId);
        ExcludeOrRejectStation(rEvent.GetStation(stationId));
      }
    }

    // manually reject stations
    if (fStationList.size() > 0) {
      if (fUseStationsInStationList) {
        for (auto& station : rEvent.StationsRange()) {
          const int stationId = station.GetId();

          // remove station if not found in list
          auto it = find(fStationList.begin(), fStationList.end(), stationId);
          if (it == fStationList.end()) {
            deselectedIds.push_back(stationId);
            ExcludeOrRejectStation(station);
          }
        }
      } else {
        for (auto& stationId : fStationList) {
          if (rEvent.HasStation(stationId)) {
            deselectedIds.push_back(stationId);
            ExcludeOrRejectStation(rEvent.GetStation(stationId));
          }
        }
      }
    }

    if (!deselectedIds.empty()) {
      ostringstream info;
      info << "station" << String::Plural(deselectedIds) << ' '
           << String::OfSortedIds(deselectedIds) << " excluded or rejected.";
      INFO(info);
    }

    return eSuccess;
  }


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

}