Framework/Atmosphere/Atmosphere.h

Go to the documentation of this file.

#ifndef _atm_Atmosphere_h_
#define _atm_Atmosphere_h_

#include <atm/VModel.h>
#include <atm/MolecularIds.h>
#include <utl/AugerUnits.h>

#include <vector>
#include <map>


namespace det {
  class Detector;
}

namespace fdet {
  class Pixel;
}

namespace fevt {
  class Pixel;
}

namespace utl {
  class Point;
  class Vector;
  class TabulatedFunction;
}

namespace atm {

  class AttenuationResult;
  class ScatteringResult;
  class CloudResult;
  class ProfileResult;
  class VRayleighModel;
  class VProfileModel;
  class VMieModel;
  class VFluorescenceModel;
  class VCherenkovModel;
  class VCloudModel;
  class InclinedAtmosphericProfile;
  class AerosolDB;
  class MolecularDB;
  class OverallQualityDB;
  class LidarDB;
  class GOESDB;


  class Atmosphere {
  public:
    enum EmissionMode {
      eFluorescence = 0,
      eCerenkov
    };

    Atmosphere() { }

    ~Atmosphere() { Clean(); }

    void Update() { Clean(); }



    atm::AttenuationResult EvaluateRayleighAttenuation(const utl::Point& xInit,
                                                       const utl::Point& xFinal,
                                                       const std::vector<double>& wLength) const;

    double EvaluateRayleighAttenuation(const utl::Point& xInit,
                                       const utl::Point& xFinal,
                                       const double wLength) const;

    atm::ScatteringResult EvaluateRayleighScattering(const utl::Point& xA,
                                                     const utl::Point& xB,
                                                     const double angle, const double distance,
                                                     const std::vector<double>& xLength) const;

    double EvaluateRayleighScattering(const utl::Point& xA,
                                      const utl::Point& xB,
                                      const double angle, const double distance,
                                      const double xLength) const;

    atm::ScatteringResult EvaluateRayleighScattering(const utl::Point& xA,
                                                     const utl::Point& xB,
                                                     const double angle, const double distance,
                                                     const atm::AttenuationResult& rayleighAttenuation) const;

    double EvaluateRayleighScattering(const utl::Point& xA,
                                      const utl::Point& xB,
                                      const double angle, const double distance,
                                      const double xLength,
                                      const double rayleighAttenuation) const;

    double GetRayleighAttenuationLength(const utl::Point& xA,
                                        const double wLength) const;



    atm::AttenuationResult EvaluateMieAttenuation(const utl::Point& xInit,
                                                  const utl::Point& xFinal,
                                                  const std::vector<double>& wLength) const;

    double EvaluateMieAttenuation(const utl::Point& xInit,
                                  const utl::Point& xFinal,
                                  const double wLength) const;

    atm::ScatteringResult EvaluateMieScattering(const utl::Point& xA,
                                                const utl::Point& xB,
                                                const double angle, const double distance,
                                                const std::vector<double>& xLength) const;

    double EvaluateMieScattering(const utl::Point& xA,
                                 const utl::Point& xB,
                                 const double angle, const double distance,
                                 const double xLength) const;

    atm::ScatteringResult EvaluateMieScattering(const utl::Point& xA,
                                                const utl::Point& xB,
                                                const double angle, const double distance,
                                                const atm::AttenuationResult& mieAttenuation) const;

    double EvaluateMieScattering(const utl::Point& xA,
                                 const utl::Point& xB,
                                 const double angle, const double distance,
                                 const double xLength,
                                 const double mieAttenuation) const;

    double GetMieAttenuationLength(const utl::Point& xA,
                                   const double wLength) const;


    double GetVerticalAerosolOpticalDepth(const unsigned int eyeId,
                                          const double altitude = 4.5*utl::km) const;



    atm::CloudResult EvaluateCloudCoverage(const fdet::Pixel& pix,
                                           const utl::Point& x) const;

    atm::CloudResult EvaluateCloudCoverage(const fevt::Pixel& pix,
                                           const utl::Point& x) const;

    atm::CloudResult EvaluateCloudCoverage(const unsigned int eyeId,
                                           const unsigned int telId,
                                           const unsigned int pixId,
                                           const utl::Point& x) const;



    const atm::ProfileResult& EvaluateDepthVsHeight() const;

    const atm::ProfileResult& EvaluateHeightVsDepth() const;

    const atm::ProfileResult& EvaluatePressureVsHeight() const;

    const atm::ProfileResult& EvaluateVaporPressureVsHeight() const;

    const atm::ProfileResult& EvaluateTemperatureVsHeight() const;

    const atm::ProfileResult& EvaluateDensityVsHeight() const;

    const atm::ProfileResult& EvaluateRefractionIndexVsHeight() const;

    const atm::ProfileResult& EvaluateRefractionIndexVsHeight(const double wavelength) const;


    void InitSlantProfileModel(const utl::Point& core, const utl::Vector& dir,
                               const double deltaX) const;

    double IntegratedGrammage(const utl::Point& pStart, const utl::Point& pStop,
                              const double delta) const;

    const atm::ProfileResult& EvaluateSlantDepthVsDistance() const;

    const atm::ProfileResult& EvaluateDistanceVsSlantDepth() const;

    const atm::ProfileResult& EvaluateHeightVsSlantDepth() const;

    const atm::ProfileResult& EvaluateHeightVsDistance() const;



    const utl::TabulatedFunction& EvaluateFluorescenceYield(const double heightAboveSeaLevel) const;

    const std::vector<double>& GetWavelengths(const EmissionMode mode = eFluorescence) const;

    double GetdEdX0() const;

    double GetDeExcitationTime(const double height) const;

    double GetVerticalTimeOfFlight(const double height1, const double height2) const;


    void SetCherenkovEnergyCutoff(const double eCut) const;

    double AngularCherenkovCDF(const double theta,
                               const double verticalDepth,
                               const double showerAge) const;

    double AngularCherenkovPDF(const double theta,
                               const double verticalDepth,
                               const double showerAge) const;

    const utl::TabulatedFunction&
    EvaluateCherenkovPhotons(const utl::Point& xA,
                             const utl::Point& xB,
                             const double showerAge) const;

    const utl::TabulatedFunction&
    EvaluateCherenkovDirect(const utl::Point& xA,
                            const utl::Point& xB,
                            const utl::Point& xEye,
                            const double showerAge) const;

    double
    EvaluateDirectCherenkovProbability(const utl::Point& xA,
                                       const utl::Point& xB,
                                       const utl::Point& xEye,
                                       const double showerAge) const;

    double
    EvaluateDirectCherenkovProbability(const utl::Point& xA,
                                       const utl::Point& xB,
                                       const utl::Point& xEye,
                                       const double showerAge,
                                       const double wavelength) const;

    enum ModelWithUncertainty {
      eMie
    };

    void SetUncertaintyBound(const ModelWithUncertainty model,
                             const double nSigma) const;



    const AerosolDB& GetAerosolDB() const;


    const MolecularDB& GetMolecularDB(const MolecularIds::ProfileId& id) const;


    const OverallQualityDB& GetOverallQualityDB() const;


    const LidarDB& GetLidarDB() const;


    const GOESDB& GetGOESDB() const;


  private:
    Atmosphere(const Atmosphere&);
    Atmosphere& operator=(const Atmosphere&);

    void Init();

    void Clean();

    static bool HasModel(VModel* const model);

    VRayleighModel* fRayleighModel = nullptr;
    VProfileModel* fProfileModel = nullptr;
    VMieModel* fMieModel = nullptr;
    VFluorescenceModel* fFluorescenceModel = nullptr;
    VCherenkovModel* fCherenkovModel = nullptr;
    VCloudModel* fCloudModel = nullptr;
    mutable InclinedAtmosphericProfile* fInclinedProfileModel = nullptr;

    mutable AerosolDB* fAerosolDB = nullptr;
    mutable OverallQualityDB* fOverallQualityDB = nullptr;
    mutable LidarDB* fLidarDB = nullptr;
    mutable GOESDB* fGOESDB = nullptr;

    typedef std::map<MolecularIds::ProfileId, MolecularDB*> MolecularDBMap;
    mutable MolecularDBMap fMolecularDBMap;

    friend class det::Detector;

  };

}


#endif