Detector.h

Go to the documentation of this file.

#ifndef _det_Detector_h_
#define _det_Detector_h_

#include <det/VManager.h>
#include <det/ManagerRegister.h>
#include <utl/TimeStamp.h>
#include <utl/AugerException.h>
#include <utl/Singleton.h>
#include <utl/config.h>

#ifdef AUGER_SQLITE_ENABLED
#  include <det/VSQLManager_SQLite.h>
#else
#  include <det/VSQLManager_MySQL.h>
#endif

// Detector namespace is partitioned into det, sdet, fdet and rdet for
// practical reasons.  However, user will probably expect both
// S and F detectors to be included with Detector.h, so we
// put them in this header file

#include <sdet/SManagerRegister.h>
#include <fdet/FManagerRegister.h>
#include <mdet/MManagerRegister.h>
#include <cdet/CManagerRegister.h>
#include <atm/AManagerRegister.h>
#include <atm/Atmosphere.h>
#include <utl/CoordinateSystemPtr.h>

#include <rdet/RManagerRegister.h>


namespace sdet {
  class SDetector;
}

namespace fdet {
  class FDetector;
}

namespace rdet {
  class RDetector;
}

namespace mdet {
  class MDetector;
}

namespace cdet {
  class CDetector;
}

namespace atm {
  class Atmosphere;
  class VProfileModel;
  class VRayleighModel;
  class VMieModel;
}

namespace fwk {
  class ParametricGeoMagneticField;
}

namespace utl {
  class Vector;
  class Point;
}

namespace det {

  class Detector : public utl::Singleton<Detector> {

  public:
    // SD
    const sdet::SDetector& GetSDetector() const;

    ManagerRegister& GetSManagerRegister() const
    { return sdet::SManagerRegister::GetInstance(); }

    // FD
    const fdet::FDetector& GetFDetector() const;

    ManagerRegister& GetFManagerRegister() const
    { return fdet::FManagerRegister::GetInstance(); }

    // RD
    const rdet::RDetector& GetRDetector() const;

    ManagerRegister& GetRManagerRegister() const
    { return rdet::RManagerRegister::GetInstance(); }

    // MD
    const mdet::MDetector& GetMDetector() const;
    ManagerRegister& GetMManagerRegister() const
    { return mdet::MManagerRegister::GetInstance(); }

    // CD
    const cdet::CDetector& GetCDetector() const;
    ManagerRegister& GetCManagerRegister() const
    { return cdet::CManagerRegister::GetInstance(); }

    // Atm
    const atm::Atmosphere& GetAtmosphere() const
    { return fAtmosphere; }

    ManagerRegister& GetAManagerRegister() const
    { return atm::AManagerRegister::GetInstance(); }

    void Update(const utl::TimeStamp& time, const bool invData = true, const bool invComp = true, const bool forceRadio = false);

    utl::TimeStamp GetTime() const { return fTime; }

    utl::CoordinateSystemPtr GetSiteCoordinateSystem() const
    { return fSiteReferenceSystem; }

    utl::CoordinateSystemPtr GetReferenceCoordinateSystem() const
    { return fReferenceCoordinateSystem; }

    fwk::ParametricGeoMagneticField& GetGeoMagneticField();
    utl::Vector GetGeoMagneticFieldAt (const utl::Point & location);

  private:
    Detector();
    ~Detector();

    Detector(const Detector& detector);
    Detector operator=(const Detector& detector);

    mutable sdet::SDetector* fSDetector = nullptr;
    mutable fdet::FDetector* fFDetector = nullptr;
    mutable rdet::RDetector* fRDetector = nullptr;
    mutable cdet::CDetector* fCDetector = nullptr;
    mutable mdet::MDetector* fMDetector = nullptr;
    atm::Atmosphere fAtmosphere;
    utl::TimeStamp fTime;
    utl::CoordinateSystemPtr fSiteReferenceSystem;
    utl::CoordinateSystemPtr fReferenceCoordinateSystem;

    fwk::ParametricGeoMagneticField* fGeoMagneticField = nullptr;

    friend class utl::Singleton<Detector>;

  };

}


#endif