CDetector.cc

Go to the documentation of this file.

#include <boost/format.hpp>
#include <boost/lexical_cast.hpp>

#include <det/Detector.h>
#include <cdet/CDetector.h>
#include <cdet/Station.h>
#include <det/VManager.h>
#include <utl/ErrorLogger.h>
#include <utl/AugerException.h>
#include <utl/TimeStamp.h>

#include <cevt/Station.h>

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


CDetector::~CDetector()
{
  for (InternalStationIterator it = fFullStationMap.begin(); 
       it != fFullStationMap.end(); ++it)
    delete it->second;
}


void
CDetector::UpdateDense()
{
  Update();

  for (vector<int>::iterator it = fDenseStationSubList.begin(), end = fDenseStationSubList.end();
       it != end; ++it)
    Detector::GetInstance().GetCDetector().GetStation(*it).Update();
}


void
CDetector::Update()
{
  // Set the full station map and pairs first time the detector is updated.

  if (!fFullStationList.IsValid()) {

    const vector<int>& sl = GetFullStationList();

    for (vector<int>::const_iterator it = sl.begin(), end = sl.end();
         it != end; ++it) {
      const int id = *it;
      Station* const station = new Station(id);

      // flag dense stations (if any) 
      const vector<int>::const_iterator denseIt =
        find(fDenseStationSubList.begin(), fDenseStationSubList.end(), id);
      if (denseIt != fDenseStationSubList.end()) {
        station->fDense = true;
        station->fInGrid = 0;
      }
      
      fFullStationMap[id] = station;
    }
    
    FetchStationGroups();

  }

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

  fCommissionedStationList.clear();

  // add the stations into the commissioned station list depending on the time
  // and update them
  for (InternalStationIterator it = fFullStationMap.begin(), end = fFullStationMap.end();
       it != end; ++it) {

    const Station* const station = it->second;

    if (station->GetCommissionTimeRange() == dTime) {
      station->Update();
      fCommissionedStationList[it->first] = station;
    }
  }
}


const vector<int>&
CDetector::GetFullStationList()
  const
{
  if (!fFullStationList.IsValid()) {

    const VManager& manager = Detector::GetInstance().GetCManagerRegister();

    fFullStationList.Get().clear();

    VManager::IndexMap indexMap;
    VManager::Status status =
      manager.GetData(fFullStationList.Get(), "fullStationList", "stationList", indexMap);

    if (status == VManager::eNotFound) {
      ostringstream err;
      err << "Could not find a list of SD Station ID's. "
             "No station information will be available!";
      DEBUGLOG(err);
    }

    fFullStationList.SetValid();

    // check for dense stations
    // (this is done separately, as there is a different convention for
    // specifying their positions.)

    // Use SManager for dense station list
    const VManager& smanager = Detector::GetInstance().GetSManagerRegister();

    fDenseStationSubList.clear();
    indexMap["reportErrors"] = "0";
    status =
      smanager.GetData(fDenseStationSubList, "denseStationList", "stationList", indexMap);


    if (status == VManager::eFound && !fDenseStationSubList.empty()) {
      INFO("Using dense stations.");
      fFullStationList.Get().insert(fFullStationList.Get().end(),
                                    fDenseStationSubList.begin(),
                                    fDenseStationSubList.end());
    }

  }

  return fFullStationList.Get();
}


void
CDetector::FetchStationGroups()
  const
{
  const VManager& manager = Detector::GetInstance().GetCManagerRegister();

  VManager::IndexMap indexMap;
  vector<int> stationGroupIds;
  const VManager::Status status =
    manager.GetData(stationGroupIds, "groupIds", "stationList", indexMap);

  if (status == VManager::eNotFound) {
    WARNING("Could not find a list of SD Station groups ids.");
    return;
  }

  fStationGroups.clear();

  vector<int> groupVec;
  set<int> groupSet;
  for (vector<int>::const_iterator gIt = stationGroupIds.begin(), end = stationGroupIds.end();
       gIt != end; ++gIt) {
    groupVec.clear();
    indexMap["groupId"] = boost::lexical_cast<string>(*gIt);
    manager.GetData(groupVec, "group", "stationList", indexMap);
    if (groupVec.empty())
      continue;
    groupSet.clear();
    groupSet.insert(groupVec.begin(), groupVec.end());
    fStationGroups.insert(make_pair(*gIt, groupSet));
  }
}


const Station&
CDetector::GetStation(const cevt::Station& station)
  const
{
  return GetStation(station.GetId());
}


const Station&
CDetector::GetStation(const int id)
  const
{
  {
    const InternalStationIterator it = fCommissionedStationList.find(id);

    if (it != fCommissionedStationList.end())
      return *it->second;
  }

  // Handle special cases.
  // 1) Dense stations.  These stations are not in the commissioned station list.
  // 2) Stations which come from some other station list manager and are
  //    hence not in the commissioned station list.

  // Special case of dense stations
  {
    const InternalStationIterator it = fFullStationMap.find(id);
    if (it != fFullStationMap.end()) {
      const Station* const station = it->second;
      if (station->IsDense())
        return *station;
    }
  }

  if (!fFullStationList.IsValid())
    GetFullStationList();

  const vector<int>::const_iterator it =
    find(fFullStationList.Get().begin(), fFullStationList.Get().end(), id);
  
  // Other special managers
  if (it == fFullStationList.Get().end()) {

    const Detector& detector = Detector::GetInstance();
    const VManager& manager = detector.GetCManagerRegister();

    VManager::IndexMap indexMap;
    indexMap["stationId"] = boost::lexical_cast<string>(id);

    string stationName;
    const bool hasName =
      manager.GetData(stationName, "name", "stationList", indexMap) == VManager::eFound;
    double dummy;
    const bool hasNorthing =
      manager.GetData(dummy, "northing", "stationList", indexMap) == VManager::eFound;
    const bool hasEasting =
      manager.GetData(dummy, "easting", "stationList", indexMap) == VManager::eFound;
    const bool hasAltitude =
      manager.GetData(dummy, "altitude", "stationList", indexMap) == VManager::eFound;

    if (hasName && hasNorthing && hasEasting && hasAltitude) {

      Station* const station = new Station(id);
      fFullStationList.Get().push_back(id);
      const pair<int, const Station*> idStation(id, station);
      fFullStationMap.insert(idStation);

      ostringstream warn;
      warn << "Station " << format("%4d") % id << " was not in the station list. "
              "It is being added individually.";
      WARNING(warn);

      // now that we are at it, check if it's commissioned
      const TimeStamp dTime = detector.GetTime();
      if (station->GetCommissionTimeRange() == dTime) {
        station->Update();
        fCommissionedStationList.insert(idStation);
        return *station;
      }

    } else {

      ostringstream err;
      err << "No station with Id = " << id << " was found. At least the following information is missing:"
          << (hasName ? "" : " name")
          << (hasNorthing ? "" : " northing")
          << (hasEasting ? "" : " easting")
          << (hasAltitude ? "" : " altitude")
          << ". Do you have some station position manager registered in CManagerRegister?";
      throw NonExistentComponentException(err.str());
    }

  }

  // individual addition ends here

  ostringstream err;
  err << "Station with Id = " << id << " is not commissioned at "
         "detector time = " << Detector::GetInstance().GetTime()
      << " or else detector description was not properly configured";
  throw NonExistentComponentException(err.str());
}


const Station&
CDetector::GetAllStation(const int id)
  const
{
  const InternalStationIterator it = fFullStationMap.find(id);
  if (it != fFullStationMap.end())
    return *it->second;

  ostringstream err;
  err << "Station with Id = " << id << " is not fund in the list of all stations.";
  throw NonExistentComponentException(err.str());
}


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