PhotoModel.h

Go to the documentation of this file.

#ifndef PhotoModel_h
#define PhotoModel_h

#include <string>
#include <vector>
#include "NumericalApproximation.h"
#include "Pvl.h"

namespace Isis {
  class PhotoModel {
    public:
      PhotoModel(Pvl &pvl);
      virtual ~PhotoModel() {};

      inline QString AlgorithmName() const {
        return p_photoAlgorithmName;
      };

      virtual void SetStandardConditions(bool standard);
      bool StandardConditions() const {
        return p_standardConditions;
      }

      // Obtain topographic derivative
      double PhtTopder(double phase, double incidence, double emission);

      // Obtain arccosine
      static double PhtAcos(double cosang);

      // Calculate the surface brightness
      double CalcSurfAlbedo(double pha, double inc, double ema);

      virtual void SetPhotoL(const double l) {};

      inline double PhotoL() const {
        return p_photoL;
      };

      virtual void SetPhotoK(const double k) {};

      inline double PhotoK() const {
        return p_photoK;
      };

      virtual void SetPhotoHg1(const double hg1) {};

      inline double PhotoHg1() const {
        return p_photoHg1;
      };

      virtual void SetPhotoHg2(const double hg2) {};

      inline double PhotoHg2() const {
        return p_photoHg2;
      };

      virtual void SetPhotoBh(const double bh) {};

      inline double PhotoBh() const {
        return p_photoBh;
      };

      virtual void SetPhotoCh(const double ch) {};

      inline double PhotoCh() const {
        return p_photoCh;
      };

      virtual void SetPhotoWh(const double wh) {};

      inline double PhotoWh() const {
        return p_photoWh;
      };

      virtual void SetPhotoHh(const double hh) {};

      inline double PhotoHh() const {
        return p_photoHh;
      };

      virtual void SetPhotoB0(const double b0) {};

      inline double PhotoB0() const {
        return p_photoB0;
      };

      virtual void SetPhotoTheta(const double theta) {};

      inline double PhotoTheta() const {
        return p_photoTheta;
      };

      virtual void SetOldTheta(double theta) {};

      virtual void SetPhoto0B0Standard(const std::string &b0standard) {};

      inline std::string Photo0B0Standard() const {
        return p_photo0B0Standard;
      }

      inline double Hfunc(double u, double gamma) {
        return (1.0 + 2.0 * u) / (1.0 + 2.0 * u * gamma);
      }
 
      virtual void SetPhotoPhaseList(const std::string phasestrlist) {};
      virtual void SetPhotoKList(const std::string kstrlist) {};
      virtual void SetPhotoLList(const std::string kstrlist) {};
      virtual void SetPhotoPhaseCurveList(const std::string phasecurvestrlist) {};

      inline std::vector<double> PhotoPhaseList() const {
        return p_photoPhaseList;
      };

      inline std::vector<double> PhotoKList() const {
        return p_photoKList;
      };

      inline std::vector<double> PhotoLList() const {
        return p_photoLList;
      };

      inline std::vector<double> PhotoPhaseCurveList() const {
        return p_photoPhaseCurveList;
      };

    protected:
      virtual double PhotoModelAlgorithm(double phase,
                                         double incidence, double emission) = 0;
      double p_photoL;
      double p_photoK;
      double p_photoHg1;
      double p_photoHg2;
      double p_photoBh;
      double p_photoCh;
      double p_photoCott;
      double p_photoCot2t;
      double p_photoTant;
      double p_photoSr;
      double p_photoOsr;
      QString p_algName;
      std::string p_photo0B0Standard;
      double p_photoWh;
      double p_photoHh;
      double p_photoB0;
      double p_photoB0save;
      double p_photoTheta;
      double p_photoThetaold;

      std::vector<double> p_photoPhaseList;
      std::vector<double> p_photoKList;
      std::vector<double> p_photoLList;
      std::vector<double> p_photoPhaseCurveList;
      int p_photoPhaseAngleCount;
      NumericalApproximation p_photoKSpline;
      NumericalApproximation p_photoLSpline;
      NumericalApproximation p_photoBSpline;

    private:
      QString p_photoAlgorithmName;
      bool p_standardConditions;
  };
};

#endif