Detector.cc

Go to the documentation of this file.

#include <iostream>
#include <sstream>
#include <map>

#include <det/Detector.h>
#include <det/ManagerRegister.h>
#include <fwk/CentralConfig.h>
#include <utl/Reader.h>
#include <utl/ErrorLogger.h>
#include <utl/TimeStamp.h>

#include <fwk/CoordinateSystemRegistry.h>
#include <utl/CoordinateSystem.h>

#include <sdet/SManagerRegister.h>
#include <sdet/SDetector.h>
#include <fdet/FManagerRegister.h>
#include <fdet/FDetector.h>
#include <atm/AManagerRegister.h>

#include <rdet/RManagerRegister.h>
#include <rdet/RDetector.h>

#include <mdet/MManagerRegister.h>
#include <mdet/MDetector.h>

#include <cdet/CManagerRegister.h>
#include <cdet/CDetector.h>

#warning RU: magnetic field model fwk->det
#include <fwk/MagneticFieldModel.h>
#include <fwk/ParametricGeoMagneticField.h>

using namespace std;
using namespace det;
using namespace sdet;
using namespace fdet;
using namespace rdet;
using namespace mdet;
using namespace cdet;
using namespace atm;
using namespace utl;
using namespace fwk;


Detector::Detector()
{
  const auto cc = CentralConfig::GetInstance();

  // Configure the SManagerRegister from an external XML file.
  auto sManagerConfigBranch = cc->GetTopBranch("SManagerRegister");
  if (sManagerConfigBranch)
    SManagerRegister::GetInstance().Configure(sManagerConfigBranch);
  else {
    INFO("Could not access a configuration file for the SManagerRegister. "
         "The Detector interface will not be able to get information about the SD "
         "(This is not an error, unless you are planning to use the surface detector information).");
  }

  // Configure the FManagerRegister from an external XML file
  auto fManagerConfigBranch = cc->GetTopBranch("FManagerRegister");
  if (fManagerConfigBranch)
    FManagerRegister::GetInstance().Configure(fManagerConfigBranch);
  else {
    INFO("Could not access a configuration file for the FManagerRegister. "
         "The Detector interface will not be able to get information about the FD "
         "(this is not an error, unless you are planning to use fluorescence detector information).");
  }

  // Configure the RManagerRegister from an external XML file
  auto rManagerConfigBranch = cc->GetTopBranch("RManagerRegister");
  if (rManagerConfigBranch)
    RManagerRegister::GetInstance().Configure(rManagerConfigBranch);
  else {
    INFO("Could not access a configuration file for the RManagerRegister. "
         "The Detector interface will not be able to get information about Radio "
         "(this is not an error, unless you are planning to use radio detector information).");
  }

  // Configure the MManagerRegister from an external XML file.
  auto mManagerConfigBranch = cc->GetTopBranch("MManagerRegister");
  if (mManagerConfigBranch)
    MManagerRegister::GetInstance().Configure(mManagerConfigBranch);
  else {
    INFO("Could not access a configuration file for the MManagerRegister. "
         "The Detector interface will not be able to get information about the MD "
         "(this is not an error, unless you are planning to use muon detector information).");
  }

  // Configure the CManagerRegister from an external XML file
  auto cManagerConfigBranch = cc->GetTopBranch("CManagerRegister");
  if (cManagerConfigBranch)
    CManagerRegister::GetInstance().Configure(cManagerConfigBranch);
  else {
    INFO("Could not access a configuration file for the CManagerRegister. "
         "The Detector interface will not be able to get information about MARTA "
         "(this is not an error, unless you are planning to use MARTA detector information).");
  }

  // Configure the AManagerRegister from an external XML file
  auto aManagerConfigBranch = cc->GetTopBranch("AManagerRegister");
  if (aManagerConfigBranch) {
    AManagerRegister::GetInstance().Configure(aManagerConfigBranch);
  } else {
    INFO("Could not access a configuration file for the AManagerRegister. "
         "The Detector interface will not be able to get information about the Atmosphere "
         "(this is not an error, unless you are planning to use the Atmosphere information).");
  }

  fAtmosphere.Init();

  fSiteReferenceSystem = fwk::CoordinateSystemRegistry::Get("Malargue");

  fReferenceCoordinateSystem = fwk::CoordinateSystemRegistry::Get("PampaAmarilla");
}


const sdet::SDetector&
Detector::GetSDetector()
  const
{
  if (!fSDetector) {
    fSDetector = new SDetector();
    fSDetector->Update();
  }
  return *fSDetector;
}


const fdet::FDetector&
Detector::GetFDetector()
  const
{
  if (!fFDetector) {
    fFDetector = new FDetector();
    fFDetector->Update();
  }
  return *fFDetector;
}


const rdet::RDetector&
Detector::GetRDetector()
  const
{
  if (!fRDetector) {
    fRDetector = new RDetector();
    fRDetector->Update();
  }
  return *fRDetector;
}


const mdet::MDetector&
Detector::GetMDetector()
  const
{
  if (!fMDetector) {
    fMDetector = new MDetector();
    fMDetector->Update();
  }
  return *fMDetector;
}


const cdet::CDetector&
Detector::GetCDetector()
  const
{
  if (!fCDetector) {
    fCDetector = new CDetector();
    fCDetector->Update();
  }
  return *fCDetector;
}


void
Detector::Update(const TimeStamp& time, const bool invData, const bool invComp, const bool forceRadio)
{

  if (fTime == time) {
    WARNING("Already at the requested time.");
  } else {
    ostringstream info;
    info << "to time " << time;
    INFO(info);

    fTime = time;

    // Update time in Detector. This method also
    // deletes currently constructed surface stations and fluorescence
    // stations (actual deletion is handled by Update() methods of SDetector
    // and FDetector, respectively).

    if (fSDetector)
      fSDetector->Update();
    if (fFDetector)
      fFDetector->Update();
    if (fRDetector)
      fRDetector->Update();
    if (fMDetector)
      fMDetector->Update(invData, invComp);
    if (fCDetector)
      fCDetector->Update();

    fAtmosphere.Update();

    delete fGeoMagneticField;
    fGeoMagneticField = nullptr;
  }
  // update the dense array, even if the time stamp has not changed.
  if (fSDetector)
    fSDetector->UpdateDense();
  if (fCDetector)
    fCDetector->UpdateDense();

  // Update to add virtual stations to RDetector which in the mean time have
  // been added to the RStationListManager.
  // TODO: Replace buy a better logic (e.g., UpdateStar(), similar to UpdateDense)
  if (forceRadio && fRDetector)
    fRDetector->Update();
}


fwk::ParametricGeoMagneticField&
Detector::GetGeoMagneticField()
{
#warning RU: Magnetic field should be handled same way as all other components. No global singleton.
  if (!fGeoMagneticField)
    fGeoMagneticField =
      new fwk::ParametricGeoMagneticField(fwk::MagneticFieldModel::instance().ModelForTime(fTime));
  return *fGeoMagneticField;
}


utl::Vector
Detector::GetGeoMagneticFieldAt(const utl::Point& location)
{
  return GetGeoMagneticField().Get(location);
}


Detector::~Detector()
{
  delete fGeoMagneticField;
  delete fRDetector;
  delete fFDetector;
  delete fSDetector;
  delete fMDetector;
  delete fCDetector;
}