SDetector.cc

Go to the documentation of this file.

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

#include <det/Detector.h>
#include <sdet/SDetector.h>
#include <sdet/Station.h>
#include <det/VManager.h>
#include <utl/ErrorLogger.h>
#include <utl/AugerException.h>
#include <utl/TimeStamp.h>

#include <sevt/Station.h>

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


SDetector::~SDetector()
{
  for (const auto& idp : fFullStationMap)
    delete idp.second;
}


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

  const auto& sDet = Detector::GetInstance().GetSDetector();
  for (const auto id : fDenseStationSubList)
    sDet.GetStation(id).Update();
}


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

  if (!fFullStationList.IsValid()) {

    const auto& sl = GetFullStationList();
    for (const auto id : sl) {
      const auto station = new Station(id);

      /*
       * The hardware (electronics, small PMT, scintillator)
       * of stations is updated upon creation, never
       * again to be updated in the case of simulations.
       */
      int isUUB = 0;
      station->GetStationData(isUUB, "isUUB", "stationList", "is uub");
      station->UpdateElectronics(isUUB);

      int hasSmallPMT = 0;
      station->GetStationData(hasSmallPMT, "hasSmallPMT", "stationList", "has small pmt");
      if (hasSmallPMT)
        station->MakeSmallPMT();

      int hasScintillator = 0;
      station->GetStationData(hasScintillator, "hasScintillator", "stationList", "has scintillator");
      if (hasScintillator)
        station->MakeScintillator();

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

    FetchStationGroups();

  }

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

  fCommissionedStationList.clear();

  // add the stations into the commissioned station list depending on the time
  // and update them
  for (const auto& is : fFullStationMap) {
    const Station* const station = is.second;
    if (station->GetCommissionTimeRange() == dTime) {
      station->Update();
      fCommissionedStationList[is.first] = station;
    }
  }
}


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

    const auto& manager = Detector::GetInstance().GetSManagerRegister();

    fFullStationList.Get().clear();

    VManager::IndexMap indexMap;
    auto 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.)
    fDenseStationSubList.clear();
    indexMap["reportErrors"] = "0";
    status = manager.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
SDetector::FetchStationGroups()
  const
{
  const auto& manager = Detector::GetInstance().GetSManagerRegister();

  VManager::IndexMap indexMap;
  vector<int> stationGroupIds;
  const auto 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 (const auto gid : stationGroupIds) {
    groupVec.clear();
    indexMap["groupId"] = boost::lexical_cast<string>(gid);
    manager.GetData(groupVec, "group", "stationList", indexMap);
    if (groupVec.empty())
      continue;
    groupSet.clear();
    groupSet.insert(groupVec.begin(), groupVec.end());
    fStationGroups.insert(make_pair(gid, groupSet));
  }
}


const Station&
SDetector::GetStation(const sevt::Station& station)
  const
{
  return GetStation(station.GetId());
}


const Station&
SDetector::GetStation(const int id)
  const
{
  {
    const auto 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 auto it = fFullStationMap.find(id);
    if (it != fFullStationMap.end()) {
      const Station* const station = it->second;
      if (station->IsDense())
        return *station;
    }
  }

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

  const auto it = find(fFullStationList.Get().begin(), fFullStationList.Get().end(), id);

  // Other special managers
  if (it == fFullStationList.Get().end()) {

    const auto& detector = Detector::GetInstance();
    const auto& manager = detector.GetSManagerRegister();

    const VManager::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) {

      const auto 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 auto 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 SManagerRegister?";
      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&
SDetector::GetAllStation(const int id)
  const
{
  const auto 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());
}


const PMT&
SDetector::GetPMT(const sevt::PMT& pmt)
  const
{
  return GetStation(pmt.GetStationId()).GetPMT(pmt.GetId());
}