MeasuredDBMieModel.h

Go to the documentation of this file.

#ifndef _atm_MeasuredDBMieModel_h_
#define _atm_MeasuredDBMieModel_h_


#include <atm/VMieModel.h>
#include <utl/Point.h>
#include <utl/ShadowPtr.h>
#include <utl/TimeStamp.h>

#include <string>

namespace utl {
  class TabulatedFunction;
}


namespace atm {

  class MeasuredDBMieModel : public atm::VMieModel {

  public:

    MeasuredDBMieModel();

    virtual ~MeasuredDBMieModel() { }


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

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

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

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

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

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

    double GetVerticalAerosolOpticalDepth(const unsigned int eyeId,
                                          const double altitude) const;

    double GetAttenuationLength(const utl::Point& p,
                                     const double wLength) const;

    //virtual utl::TabulatedFunctionErrors GetAttenuationLength(const utl::Point& p,
    //const std::vector<double>& wLength) const = 0;

    double EvaluateScatteringAngle(const utl::Point& p,
                                   const double angle,
                                   const double wLength) const;

    bool HasData() const;

    bool HasZone(const std::string& zoneName) const;

    void Init();

    void SetUncertaintyBound(double nSigma) const;

  private:

    // returns true if some data got cached
    bool CheckForUpdates() const;

    // zone name for zone closest to specified point
    std::string GetZoneName(const utl::Point& pt) const;

    // zone name nearest to the specified eye
    std::string GetZoneName(const unsigned int eyeId) const;

    // check whether two points are in the same zone or not
    bool CrossesZone(const utl::Point& pt1, const utl::Point& p2) const;

    // set VAOD pointer according to user request fNSigma
    void ToggleVAODPtr() const;

    mutable utl::TimeStamp fCurrentTime;

    // containers for all zone names and positions
    typedef std::map<std::string, utl::Point> ZonePosition;
    typedef std::pair<std::string, utl::Point> ZonePoint;

    mutable ZonePosition fZonePositions;

    // tables with attenuation length vs. height for different zones
    typedef std::map<std::string, utl::TabulatedFunction> ZoneFunction;

    mutable utl::ShadowPtr<ZoneFunction> fAttVsHeightMap;

    mutable utl::ShadowPtr<ZoneFunction> fAttLambdaVsHeightMap;

    mutable ZoneFunction* fVAODVsHeightMap;

    mutable utl::ShadowPtr<ZoneFunction> fCentralVAODVsHeightMap;
    mutable utl::ShadowPtr<ZoneFunction> fMinVAODVsHeightMap;
    mutable utl::ShadowPtr<ZoneFunction> fMaxVAODVsHeightMap;

    // phase function parameters for a particular zone.  Note that currently we
    // only support a single phase function slice.  If phase function is
    // recorded as a function of altitude in the future, this will have to
    // be updated accordingly.
    //
    struct PFParameters {
      double f;
      double fErr;
      double g;
      double gErr;
      double fLambda;
      double fLambdaErr;
      double gLambda;
      double gLambdaErr;
    };
    typedef std::map<std::string, PFParameters> ZonePhaseFunction;

    mutable utl::ShadowPtr<ZonePhaseFunction> fPhaseFuncMap;

    mutable bool fDbIsEmptyNow;

    mutable double fNSigma;

    double fSystematicShift;

    // Members and functors to enable zone forcing and zone swapping
    enum ZoneParam { eLosLeones, eLosMorados, eLomaAmarilla, eCoihueco, eAll };
    mutable ZoneParam fZoneParam;
    std::vector<ZoneParam> fSwapZones;

    bool ZoneMatch(const ZonePoint& pt, const std::string& name) const;

    ZoneParam StringToZoneParam(const std::string& str) const;
    std::string ZoneParamToString(const ZoneParam& zone) const;

    REGISTER_MODEL(atm::VMieModel, "MeasuredDB", MeasuredDBMieModel);
  };

} // atm


#endif // _atm_MeasuredDBMieModel_h_