CStationListManager.cc

Go to the documentation of this file.

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

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


namespace cdet {

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

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

  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
CStationListManager::GetData(double& returnData,
                             const string& componentProperty,
                             const VManager::IndexMap& componentIndex)
  const
{
  const int id = GetStationId(componentIndex);
  const StationIdIndex& idIndex = fStations.get<ByStationId>();
  const StationIdIndex::const_iterator 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
CStationListManager::GetData(string& returnData,
                             const string& componentProperty,
                             const VManager::IndexMap& componentIndex)
  const
{
  const int id = GetStationId(componentIndex);
  const StationIdIndex& idIndex = fStations.get<ByStationId>();
  const StationIdIndex::const_iterator 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 == "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
CStationListManager::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
CStationListManager::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
CStationListManager::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 StationIdIndex& idIndex = fStations.get<ByStationId>();
    typedef StationIdIndex::const_iterator StationIterator;
    const StationIterator sIt = idIndex.find(id);
    if (sIt == idIndex.end())
      return VManager::eNotFound;
    returnData = sIt->fInGrid;
  }
  else
    return VManager::eNotFound;

  return VManager::eFound;
}


bool
CStationListManager::ConditionalAddStationData(CStationListManager::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
CStationListManager::HasStationData(const int id)
  const
{
  const StationIdIndex& idIndex = fStations.get<ByStationId>();
  return idIndex.find(id) != idIndex.end();
}


void
CStationListManager::GetFullStationList(vector<int>& returnList)
  const
{
  returnList.clear();
  const StationIdIndex& idIndex = fStations.get<ByStationId>();
  for (StationIdIndex::const_iterator sIt = idIndex.begin();
       sIt != idIndex.end(); ++sIt)
    returnList.push_back(sIt->fId);
}


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

  returnData.clear();

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

  typedef GroupIdIndex::const_iterator GroupIterator;

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

  int currentGroupId = 0;
  vector<int> currentGroup;

  for (GroupIterator it = grIndex.begin(); it != grIndex.end(); ++it) {

    const int stationGroupId = it->fGroupId;

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

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

    currentGroup.push_back(it->fId);

  }

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


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

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

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

  typedef GroupIdIndex::const_iterator GroupIterator;

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

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

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

  return VManager::eFound;
}


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

  typedef GroupIdIndex::const_iterator GroupIterator;
  typedef pair<GroupIterator, GroupIterator> GroupRange;

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

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

  return VManager::eFound;
}


VManager::Status
CStationListManager::GetStationGroup(vector<int>& returnData, const int id)
  const
{
  const StationIdIndex& idIndex = fStations.get<ByStationId>();
  typedef StationIdIndex::const_iterator StationIterator;
  const StationIterator 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;

  typedef GroupIdIndex::const_iterator GroupIterator;
  typedef pair<GroupIterator, GroupIterator> GroupRange;

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

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

  return VManager::eFound;
}


VManager::Status
CStationListManager::GetStationCrown(std::vector<int>& crown,
                                     const int id,
                                     const int nCrown,
                                     CDetectorConstants::GridIndex index)
  const
{
  const StationIdIndex& idIndex = fStations.get<ByStationId>();
  typedef StationIdIndex::const_iterator StationIterator;
  const StationIterator 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 == CDetectorConstants::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 AxesIndex& axesIndex = fStations.get<ByAxes>();
  typedef AxesIndex::const_iterator AxesIterator;
  const AxesIterator start =
    axesIndex.lower_bound(make_tuple(axis1 - level, axis2 - level));
  const AxesIterator stop =
    axesIndex.upper_bound(make_tuple(axis1 + level, axis2 + level));

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

  for (AxesIterator 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 (string::const_iterator it = str.begin(); it != str.end(); ++it)
    switch (*it) {
    // replace '&' with "&amp;"
    case '&':
      res << "and";
      break;
    default:
      res << *it;
    }

  return res.str();
}


bool
CStationListManager::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%  <decommission> %8% </decommission>\n"
    "%1%  <inGrid> %9% </inGrid>\n"
    "%1%  <groupId> %10% </groupId>\n"
    "%1%  <axes> %11% %12% </axes>\n"
    "%1%  <ellipsoid> %13% </ellipsoid>\n"
    "%1%  <zone> %14% </zone>\n"
    "%1%  <band> %15% </band>\n"
    "%1%</station>\n"
  );

  const StationIdIndex& sIndex = fStations.get<ByStationId>();
  for (StationIdIndex::const_iterator sIt = sIndex.begin();
       sIt != sIndex.end(); ++sIt)
  {
    ostringstream inGrid;
    if (sIt->fInGrid.size()==0)
      inGrid << "0";
    else
      for (size_t i = 1; i < sIt->fInGrid.size(); ++i)
        if (sIt->fInGrid[i])
          inGrid << i << " ";

    output
      << stationFmt
        % indent
        % sIt->fId
        % sIt->fNorthing
        % sIt->fEasting
        % sIt->fAltitude
        % StringToXMLString(sIt->fName)
        % sIt->fCommissionTime
        % sIt->fDecommissionTime
        % inGrid.str()
        % sIt->fGroupId
        % sIt->fAxis1
        % sIt->fAxis2
        % sIt->fEllipsoid
        % sIt->fZone
        % sIt->fBand
      << '\n';
  }

  return true;
}

} // cdet

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// End: