EventStationPositionsManager.cc

Go to the documentation of this file.

#include <sdet/EventStationPositionsManager.h>

#include <fwk/RunController.h>
#include <evt/Event.h>
#include <sevt/SEvent.h>
#include <utl/ErrorLogger.h>
#include <utl/Point.h>

#include <AugerEvent.h>
#include <IoSdData.h>

#include <det/Detector.h>
#include <sdet/SDetector.h>
#include <sdet/SManagerRegister.h> // needed for registration macro

using namespace std;
using namespace fwk;
using namespace evt;
using namespace sevt;
using namespace sdet;
using namespace det;
using namespace utl;

REGISTER_S_MANAGER("EventStationPositionsManager", EventStationPositionsManager)


namespace sdet {

  const string outdatedMessage =
    "Station list source is outdated or no real manager present";


  void
  EventStationPositionsManager::Init(const string& configLink)
  {
    // call shadowed VManager::Init() first
    VManager::Init(configLink);

    fBranch.GetChild("Band").GetData(fBand);
    fBranch.GetChild("Zone").GetData(fZone);
    fBranch.GetChild("Ellipsoid").GetData(fEllipsoid);
    /*
     * If the IsUUB property does not exist (as is the case
     * for the pre-upgrade XML), set IsUUB to 0.
     */
    if (fBranch.GetChild("IsUUB"))
      fBranch.GetChild("IsUUB").GetData(fIsUUB);
    else
      fIsUUB = 0;
    fBranch.GetChild("Commission").GetData(fCommission);
    fBranch.GetChild("CommissionUUB").GetData(fCommissionUUB);
    fBranch.GetChild("Decommission").GetData(fDecommission);
  }


  inline
  void
  UTMToAxes(const double easting, const double northing,
            double& axis1, double& axis2)
  {
    axis1 = 6.666970851e-4*easting + 3.849861836e-4*northing - 2559.709820;
    axis2 = 6.082521603e-8*easting + 7.698225084e-4*northing - 4592.669600;
  }


  inline
  void
  AxesToUTM(const double axis1, const double axis2,
            double& easting, double& northing)
  {
    easting = 394392 + 1500*axis1 - 750.146*axis2;
    northing = 5965850 - 0.118518*axis1 + 1299.06*axis2;
  }


  // Generic data getters

  template<>
  VManager::Status
  EventStationPositionsManager::GetStationData<>(int& returnData,
                                                 const string& componentProperty,
                                                 const string& componentName,
                                                 const IndexMap& componentIndex)
    const
  {
    if (componentName != "stationList")
      return eNotFound;

    if (componentProperty == "axis1" ||
        componentProperty == "axis2") {

      double easting;
      GetData(easting, "easting", componentName, componentIndex);
      double northing;
      GetData(northing, "northing", componentName, componentIndex);
      double axis1;
      double axis2;
      UTMToAxes(easting, northing, axis1, axis2);

      returnData = int(round(componentProperty == "axis1" ? axis1 : axis2));

      ostringstream warn;
      warn << outdatedMessage << ", guessing station with id="
           << FindComponent<string>("stationId", componentIndex) << " has "
           << componentProperty << '=' << returnData;
      WARNING(warn);
      return eFound;

    } else if (componentProperty == "groupId") {

      ostringstream warn;
      warn << outdatedMessage << ", guessing "
           << componentProperty << " for station with id="
           << FindComponent<string>("stationId", componentIndex) << " is impossible!";
      WARNING(warn);
      returnData = 0;
      return eFound;

    } else if (componentProperty == "zone") {

      returnData = fZone;
      return eFound;

    } else if (componentProperty == "isUUB") {

      returnData = fIsUUB;
      return eFound;
    }

    return eNotFound;
  }


  template<>
  VManager::Status
  EventStationPositionsManager::GetStationData(double& returnData,
                                               const string& componentProperty,
                                               const string& componentName,
                                               const IndexMap& componentIndex)
    const
  {
    if (componentName != "stationList")
      return eNotFound;

    if (componentProperty == "northing" ||
        componentProperty == "easting" ||
        componentProperty == "altitude") {

      const IoSdStation* const st = FindStation(componentIndex);

      ostringstream message;
      message << outdatedMessage;

      if (st) {
        returnData = (componentProperty == "northing") ? st->northing() :
          (componentProperty == "easting" ? st->easting() :  st->altitude());
        message << ", taking " << componentProperty << '=' << returnData << " "
                   "for station id=" << st->id() << " from raw event";
        WARNING(message);
        return eFound;
      }

      message << ", station with id=" << FindComponent<string>("stationId", componentIndex)
              << " can not be found in raw event either";
      ERROR(message);
      return eNotFound;

    } else if (componentProperty == "axis1" ||
               componentProperty == "axis2") {

      int axis = 0;
      const Status status =
        GetStationData(axis, componentProperty, componentName, componentIndex);
      returnData = axis;
      return status;

    }

    return eNotFound;
  }


  template<>
  VManager::Status
  EventStationPositionsManager::GetStationData(string& returnData,
                                               const string& componentProperty,
                                               const string& componentName,
                                               const IndexMap& componentIndex)
    const
  {
    if (componentName != "stationList")
      return eNotFound;

    if (componentProperty == "name") {

      const auto st = FindStation(componentIndex);

      ostringstream message;
      message << outdatedMessage;

      if (st) {
        returnData = st->name();
        message << ", taking " << componentProperty << "='" << returnData << "' "
                   "for station id=" << st->id() << " from raw event";
        WARNING(message);
        return eFound;
      }

      message << ", station with id=" << FindComponent<string>("stationId", componentIndex)
              << " can not be found in raw event either";
      ERROR(message);
      return eNotFound;

    } else if (componentProperty == "commission") {

      returnData = fCommission;
      return eFound;

    } else if (componentProperty == "commissionUUB") {

      returnData = fCommissionUUB;
      return eFound;

    } else if (componentProperty == "decommission") {

      returnData = fDecommission;
      return eFound;

    } else if (componentProperty == "band") {

      returnData = fBand;
      return eFound;

    } else if (componentProperty == "ellipsoid") {

      returnData = fEllipsoid;
      return eFound;

    }

    return eNotFound;
  }


  template<>
  VManager::Status
  EventStationPositionsManager::GetStationData(vector<int>& returnData,
                                               const string& componentProperty,
                                               const string& componentName,
                                               const IndexMap& /* componentIndex */)
    const
  {
    if (componentName != "stationList")
      return eNotFound;

    if (componentProperty == "stationGroup") {
      ostringstream message;
      message << outdatedMessage << ", station will not be part of any group";
      WARNING(message);
      returnData.clear();
      return eFound;
    }

    return eNotFound;
  }


  template<>
  VManager::Status
  EventStationPositionsManager::GetStationData(vector<bool>& returnData,
                                               const string& componentProperty,
                                               const string& componentName,
                                               const IndexMap& componentIndex)
    const
  {
    if (componentName == "stationList" && componentProperty == "inGrid") {

      const int sId = FindComponent<int>("stationId", componentIndex);

      const auto& sDetector = det::Detector::GetInstance().GetSDetector();
      const auto& pos = sDetector.GetStation(sId).GetPosition();
      vector<bool> grid(SDetectorConstants::kGridIndexSize);
      for (const auto& s : sDetector.AllStationsRange()) {
        if (s.GetId() == sId /* || !s.IsInGrid(SDetectorConstants::eAny)) */)
          continue;

        const double d = (pos - s.GetPosition()).GetMag();
        if (d < 100*meter && s.GetId() < sId) {
          // looks like doublet/triplet
          grid.clear();
          break;
        } else if (fabs(d - 433*meter) < 100*meter) {
          // looks like 433 m infill
          grid[SDetectorConstants::eInfill433] = true;
        } else if (fabs(d - 750*meter) < 100*meter) {
          // looks like 750 m infill
          grid[SDetectorConstants::eInfill750] = true;
        } else if (fabs(d - 1500*meter) < 150*meter) {
          // looks like standard array
          grid[SDetectorConstants::eStandard] = true;
        }
      }

      ostringstream message;
      message << "guessed inGrid property from distances to neighbours =";
      if (grid.empty())
        message << " 0";
      else {
        for (size_t i = 0, n = grid.size(); i < n; ++i) {
          if (grid[i])
            message << ' ' << (i + 1);
        }
      }
      WARNING(message);

      returnData = grid;

      return eFound;
    }

    return eNotFound;
  }


  const IoSdStation*
  EventStationPositionsManager::FindStation(const int id)
    const
  {
    const auto& event = RunController::GetInstance().GetCurrentEvent();

    if (!event.HasRawEvent()) {
      ERROR("Event has no raw event!");
      return 0;
    }

    const auto& rawEvent = event.GetRawEvent();

    if (!rawEvent.HasSd()) {
      ERROR("Event has no raw SD event!");
      return 0;
    }

    const auto& stations = rawEvent.Sd().Stations;

    for (const auto& s : stations)
      if (int(s.id()) == id)
        return &s;

    return nullptr;
  }

}