SStationListManager.cc

Go to the documentation of this file.

#include <iostream>
#include <boost/format.hpp>
#include <boost/lexical_cast.hpp>
#include <sdet/SStationListManager.h>
#include <det/Detector.h>
#include <utl/UTCDateTime.h>

using namespace sdet;
using namespace det;
using namespace std;
using namespace utl;
using namespace ::boost::multi_index;


namespace sdet {

  // specialization for "int"
  template<>
  VManager::Status
  SStationListManager::GetData(int& returnData,
                               const string& componentProperty,
                               const VManager::IndexMap& componentIndex)
    const
  {
    const int id = GetStationId(componentIndex);
    const auto& idIndex = fStations.get<ByStationId>();
    const auto sIt = idIndex.find(id);

    if (sIt == idIndex.end())
      return VManager::eNotFound;

    if (componentProperty == "isUUB")
      returnData = sIt->fIsUUB;
    else if (componentProperty == "hasSmallPMT")
      returnData = sIt->fHasSmallPMT;
    else if (componentProperty == "hasScintillator")
      returnData = sIt->fHasScintillator;
    else if (componentProperty == "groupId")
      returnData = sIt->fGroupId;
    else if (componentProperty == "zone")
      returnData = sIt->fZone;
    else
      return VManager::eNotFound;

    return VManager::eFound;
  }


  // specialization for "double"
  template<>
  VManager::Status
  SStationListManager::GetData(double& returnData,
                               const string& componentProperty,
                               const VManager::IndexMap& componentIndex)
    const
  {
    const int id = GetStationId(componentIndex);
    const auto& idIndex = fStations.get<ByStationId>();
    const auto sIt = idIndex.find(id);

    if (sIt == idIndex.end())
      return VManager::eNotFound;

    if (componentProperty == "northing")
      returnData = sIt->fNorthing;
    else if (componentProperty == "easting")
      returnData = sIt->fEasting;
    else if (componentProperty == "altitude")
      returnData = sIt->fAltitude;
    else if (componentProperty == "axis1")
      returnData = sIt->fAxis1;
    else if (componentProperty == "axis2")
      returnData = sIt->fAxis2;
    else
      return VManager::eNotFound;

    return VManager::eFound;
  }


  // specialization for "string"
  template<>
  VManager::Status
  SStationListManager::GetData(string& returnData,
                               const string& componentProperty,
                               const VManager::IndexMap& componentIndex)
    const
  {
    const int id = GetStationId(componentIndex);
    const auto& idIndex = fStations.get<ByStationId>();
    const auto sIt = idIndex.find(id);

    if (sIt == idIndex.end())
      return VManager::eNotFound;

    if (componentProperty == "name")
      returnData = sIt->fName;
    else if (componentProperty == "commission")
      returnData = sIt->fCommissionTime;
    else if (componentProperty == "commissionUUB")
      returnData = sIt->fUUBCommissionTime;
    else if (componentProperty == "decommission")
      returnData = sIt->fDecommissionTime;
    else if (componentProperty == "band")
      returnData = sIt->fBand;
    else if (componentProperty == "ellipsoid")
      returnData = sIt->fEllipsoid;
    else
      return VManager::eNotFound;

    return VManager::eFound;
  }


  // specialization for "vector<int>"
  template<>
  VManager::Status
  SStationListManager::GetData(vector<int>& returnData,
                               const string& componentProperty,
                               const VManager::IndexMap& componentIndex)
    const
  {
    if (fStations.empty())
      return VManager::eNotFound;

    if (componentProperty == "fullStationList")
      GetFullStationList(returnData);
    else if (componentProperty == "groupIds")
      return GetGroupIds(returnData);
    else if (componentProperty == "group")
      return GetGroup(returnData, VManager::FindComponent<int>("groupId", componentIndex));
    else if (componentProperty == "stationGroup")
      return GetStationGroup(returnData, GetStationId(componentIndex));
    else if (componentProperty == "crown")
      return
        GetStationCrown(returnData,
                        GetStationId(componentIndex),
                        VManager::FindComponent<int>("crown", componentIndex));
    else
      return VManager::eNotFound;

    return VManager::eFound;
  }


  // specialization for "vector<vector<int> >"
  template<>
  VManager::Status
  SStationListManager::GetData(vector<vector<int> >& returnData,
                               const string& componentProperty,
                               const VManager::IndexMap&)
    const
  {
    if (fStations.empty())
      return VManager::eNotFound;

    if (componentProperty == "fullStationGroups")
      GetFullStationGroups(returnData);
    else
      return VManager::eNotFound;

    return VManager::eFound;
  }


  // specialization for "vector<bool>"
  template<>
  VManager::Status
  SStationListManager::GetData(vector<bool>& returnData,
                               const string& componentProperty,
                               const VManager::IndexMap& componentIndex)
    const
  {
    if (fStations.empty())
      return VManager::eNotFound;

    if (componentProperty == "inGrid") {
      const int id = GetStationId(componentIndex);
      const auto& idIndex = fStations.get<ByStationId>();
      const auto sIt = idIndex.find(id);
      if (sIt == idIndex.end())
        return VManager::eNotFound;
      returnData = sIt->fInGrid;
    } else
      return VManager::eNotFound;

    return VManager::eFound;
  }


  bool
  SStationListManager::ConditionalAddStationData(SStationListManager::StationData& station)
  {
    if (HasStationData(station.fId))
      return false;

    const TimeStamp commission =
      boost::lexical_cast<UTCDateTime>(station.fCommissionTime).GetTimeStamp();
    const TimeStamp decommission =
      boost::lexical_cast<UTCDateTime>(station.fDecommissionTime).GetTimeStamp();
    station.fCommissionTimeRange = TimeRange(commission, decommission);
    fStations.insert(station);

    return true;
  }


  bool
  SStationListManager::HasStationData(const int id)
    const
  {
    const auto& idIndex = fStations.get<ByStationId>();
    return idIndex.find(id) != idIndex.end();
  }


  void
  SStationListManager::GetFullStationList(vector<int>& returnList)
    const
  {
    returnList.clear();
    const auto& idIndex = fStations.get<ByStationId>();
    for (const auto& s : idIndex)
      returnList.push_back(s.fId);
  }


  void
  SStationListManager::GetFullStationGroups(vector<vector<int>>& returnData)
    const
  {
    if (fStations.empty())
      return;

    returnData.clear();

    const TimeStamp& dTime = Detector::GetInstance().GetTime();

    const auto& grIndex = fStations.get<ByGroupId>();

    int currentGroupId = 0;
    vector<int> currentGroup;

    for (const auto& gr : grIndex) {

      const int stationGroupId = gr.fGroupId;

      // skip group 0 and out of time stations
      if (!stationGroupId || gr.fCommissionTimeRange != dTime)
        continue;

      // new group?
      if (stationGroupId != currentGroupId) {
        if (!(currentGroup.size() > 1)) {
          returnData.push_back(move(currentGroup));
          currentGroup.clear();
        }
        currentGroupId = stationGroupId;
      }

      currentGroup.push_back(gr.fId);

    }

    if (!(currentGroup.size() > 1))
      returnData.push_back(currentGroup);
  }


  VManager::Status
  SStationListManager::GetGroupIds(vector<int>& returnData)
    const
  {
    const auto& grIndex = fStations.get<ByGroupId>();

    if (grIndex.empty())
      return VManager::eFound;

    const TimeStamp& dTime = Detector::GetInstance().GetTime();

    auto it = grIndex.begin();
    for ( ; it != grIndex.end(); ++it)
      if (it->fCommissionTimeRange == dTime)
        break;

    if (it != grIndex.end())
      returnData.push_back(it->fGroupId);

    for (++it; it != grIndex.end(); ++it)
      if (it->fCommissionTimeRange == dTime &&
          returnData.back() != it->fGroupId)
        returnData.push_back(it->fGroupId);

    return VManager::eFound;
  }


  VManager::Status
  SStationListManager::GetGroup(vector<int>& returnData, const int groupId)
    const
  {
    const TimeStamp& dTime = Detector::GetInstance().GetTime();

    const auto group = fStations.get<ByGroupId>().equal_range(groupId);

    for (auto it = group.first; it != group.second; ++it)
      if (it->fCommissionTimeRange == dTime)
        returnData.push_back(it->fId);

    return VManager::eFound;
  }


  VManager::Status
  SStationListManager::GetStationGroup(vector<int>& returnData, const int id)
    const
  {
    const auto& idIndex = fStations.get<ByStationId>();
    const auto sIt = idIndex.find(id);
    if (sIt == idIndex.end())
      return VManager::eNotFound;

    returnData.clear();

    const TimeStamp& dTime = Detector::GetInstance().GetTime();

    if (!sIt->fGroupId)
      return VManager::eFound;

    const auto group = fStations.get<ByGroupId>().equal_range(sIt->fGroupId);

    for (auto it = group.first; it != group.second; ++it)
      if (it->fCommissionTimeRange == dTime && it->fId != id)
        returnData.push_back(it->fId);

    return VManager::eFound;
  }


  VManager::Status
  SStationListManager::GetStationCrown(std::vector<int>& crown,
                                       const int id,
                                       const int nCrown,
                                       SDetectorConstants::GridIndex index)
    const
  {
    const auto& idIndex = fStations.get<ByStationId>();
    const auto sIt = idIndex.find(id);
    if (sIt == idIndex.end())
      return VManager::eNotFound;

    crown.clear();

    if (size_t(index) >= sIt->fInGrid.size() || !sIt->fInGrid[index])
      return VManager::eFound;

    if (nCrown <= 0) {
      crown.push_back(id);
      return VManager::eFound;
    }

    double level = nCrown;
    if (index == SDetectorConstants::eInfill750)
      level /= 2;

    /*
      In a = Delta axis1 and b = Delta axis2 coordinates, i.e. relative to the
      coordinates of the central station, the crown C = 3 looks like:

                        b ^
             (-)          |          (+)
                          c  c  c  c
                          |
                       c  +        c
                          |
                    c     +        c
                          |
               --c--+--+--+--+--+--c--> a
                          |
                 c        +     c
                          |
                 c        +  c
                          |
                 c  c  c  c
             (+)          |          (-)

      where (+)/(-) denote the two diagonal quadrants. For (+) quadrants we can
      describe crown stations with the following boolean expression,

        ( |a| == C && |b| <= C ) || ( |a| <= C && |b| == C ).

      In the (-) quadrants the crown stations are described as returning true for

        |a - b| == C.

      The quadrant is selected depending on the boolean value of

        sign(a) == sign(b)      -> true  for (+)
                                -> false for (-)

      According to this we can set up a MySQL query that automatically returns only
      crown stations.
    */

    const double axis1 = sIt->fAxis1;
    const double axis2 = sIt->fAxis2;

    /* we narrow down the number of candidates by selecting a square region around
       the central station and automatically satisfy condition a,b <= C */

    using boost::make_tuple;

    const auto& axesIndex = fStations.get<ByAxes>();
    const auto start = axesIndex.lower_bound(make_tuple(axis1 - level, axis2 - level));
    const auto stop = axesIndex.upper_bound(make_tuple(axis1 + level, axis2 + level));

    const TimeStamp& detTime = det::Detector::GetInstance().GetTime();

    for (auto it = start; it != stop; ++it) {

      if (size_t(index) >= it->fInGrid.size() || !it->fInGrid[index])
        continue;

      const double a = it->fAxis1 - axis1;
      const double b = it->fAxis2 - axis2;
      if (a*b >= 0) {
        if (fabs(a) != level && fabs(b) != level)
          continue;
      } else if (fabs(a - b) != level)
        continue;

      // check commission and decommission
      if (it->fCommissionTimeRange != detTime)
        continue;

      crown.push_back(it->fId);

    }

    return VManager::eFound;
  }


  string
  StringToXMLString(const string& str)
  {
    ostringstream res;

    for (const auto& c : str)
      switch (c) {
      // replace '&' with "&amp;"
      case '&':
        res << "and";
        break;
      default:
        res << c;
      }

    return res.str();
  }


  bool
  SStationListManager::DumpXML(ostream& output, const string& indent)
    const
  {
    if (fStations.empty())
      return false;

    boost::format stationFmt(
      "%1%<station id=\"%2%\">\n"
      "%1%  <northing unit=\"meter\"> %|3$.2f| </northing>\n"
      "%1%  <easting unit=\"meter\"> %|4$.2f| </easting>\n"
      "%1%  <altitude unit=\"meter\"> %|5$.2f| </altitude>\n"
      "%1%  <name> %6% </name>\n"
      "%1%  <commission> %7% </commission>\n"
      "%1%  <commissionUUB> %8% </commissionUUB>\n"
      "%1%  <decommission> %9% </decommission>\n"
      "%1%  <isUUB> %10% </isUUB>\n"
      "%1%  <hasSmallPMT> %11% </hasSmallPMT>\n"
      "%1%  <hasScintillator> %12% </hasScintillator>\n"
      "%1%  <inGrid> %13% </inGrid>\n"
      "%1%  <groupId> %14% </groupId>\n"
      "%1%  <axes> %15% %16% </axes>\n"
      "%1%  <ellipsoid> %17% </ellipsoid>\n"
      "%1%  <zone> %18% </zone>\n"
      "%1%  <band> %19% </band>\n"
      "%1%</station>\n"
    );

    const auto& sIndex = fStations.get<ByStationId>();
    for (const auto& s : sIndex) {
      ostringstream inGrid;
      if (s.fInGrid.empty())
        inGrid << '0';
      else
        for (size_t i = 1, n = s.fInGrid.size(); i < n; ++i)
          if (s.fInGrid[i])
            inGrid << i << ' ';

      output
        << (stationFmt
          % indent
          % s.fId
          % s.fNorthing
          % s.fEasting
          % s.fAltitude
          % StringToXMLString(s.fName)
          % s.fCommissionTime
          % s.fUUBCommissionTime
          % s.fDecommissionTime
          % s.fIsUUB
          % s.fHasSmallPMT
          % s.fHasScintillator
          % inGrid.str()
          % s.fGroupId
          % s.fAxis1
          % s.fAxis2
          % s.fEllipsoid
          % s.fZone
          % s.fBand)
        << '\n';
    }

    return true;
  }

}