PhotoModel.h

#ifndef PhotoModel_h
#define PhotoModel_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <string>
#include <vector>
 
#include <QString>
#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) {
        p_photoL = l;
      }

      inline double PhotoL() const {
        return p_photoL;
      }
 
      virtual void SetPhotoK(const double k) {
        p_photoK = k;
      }

      inline double PhotoK() const {
        return p_photoK;
      }
 
      virtual void SetPhotoHg1(const double hg1) {
        p_photoHg1 = hg1;
      }

      inline double PhotoHg1() const {
        return p_photoHg1;
      }
 
      virtual void SetPhotoHg2(const double hg2) {
        p_photoHg2 = hg2;
      }

      inline double PhotoHg2() const {
        return p_photoHg2;
      }
 
      virtual void SetPhotoBh(const double bh) {
        p_photoBh = bh;
      }

      inline double PhotoBh() const {
        return p_photoBh;
      }
 
      virtual void SetPhotoCh(const double ch) {
        p_photoCh = ch;
      }

      inline double PhotoCh() const {
        return p_photoCh;
      }
 
      virtual void SetPhotoWh(const double wh) {
        p_photoWh = wh;
      }

      inline double PhotoWh() const {
        return p_photoWh;
      }
 
      virtual void SetPhotoHh(const double hh) {
        p_photoHh = hh;
      }

      inline double PhotoHh() const {
        return p_photoHh;
      }
 
      virtual void SetPhotoB0(const double b0) {
        p_photoB0 = b0;
      }

      inline double PhotoB0() const {
        return p_photoB0;
      }
 
      virtual void SetPhotoTheta(const double theta) {
        p_photoTheta = theta;
      }

      inline double PhotoTheta() const {
        return p_photoTheta;
      }
 
      // virtual void SetOldTheta(double theta) = 0;
 
      virtual void SetPhoto0B0Standard(const QString &b0standard) {
        p_photo0B0Standard = b0standard;
      }

      inline QString 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 QString) {}
      virtual void SetPhotoKList(const QString) {}
      virtual void SetPhotoLList(const QString) {}
      virtual void SetPhotoPhaseCurveList(const QString) {}

      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;
      QString 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