AtmosModel.h

Go to the documentation of this file.

#ifndef AtmosModel_h
#define AtmosModel_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <string>
#include <vector>
#include "PhotoModel.h"
#include "NumericalApproximation.h"
#include "NumericalAtmosApprox.h"
 
using namespace std;
namespace Isis {
  class Pvl;

  class AtmosModel {
    public:
      AtmosModel(Pvl &pvl, PhotoModel &pmodel);
      virtual ~AtmosModel() {};
 
      // These methods were moved here from the NumericalMethods class
      static double G11Prime(double tau);
      static double Ei(double x);
      static double En(unsigned int n, double x);
      // Calculate atmospheric scattering effect
      void CalcAtmEffect(double pha, double inc, double ema, double *pstd,
                         double *trans, double *trans0, double *sbar, double *transs);
      // Used to calculate atmosphere at standard conditions
      virtual void SetStandardConditions(bool standard);
      // Obtain hemispheric and bihemispheric albedo by integrating the photometric function
      void GenerateAhTable();
      // Perform integration for Hapke Henyey-Greenstein atmosphere correction
      void GenerateHahgTables();
      // Perform integration for Hapke Henyey-Greenstein atmosphere correction. This
      // version is used for shadow modeling and does not tabulate the first and third
      // integrals like GenerateHahgTables. It only evaluates the middle integral
      // that corrects the sbar variable (which is the illumination of the ground
      // by the sky).
      void GenerateHahgTablesShadow();
      // Set parameters needed for atmospheric correction
      void SetAtmosAtmSwitch(const int atmswitch);
      void SetAtmosBha(const double bha);
      void SetAtmosHga(const double hga);
      void SetAtmosInc(const double inc);
      void SetAtmosNulneg(const string nulneg);
      void SetAtmosPhi(const double phi);
      void SetAtmosTau(const double tau);
      void SetAtmosTauref(const double tauref);
      void SetAtmosWha(const double wha);
      void SetAtmosHnorm(const double hnorm);
      void SetAtmosIord(const string offset);
      void SetAtmosEstTau(const string esttau);

      string AlgorithmName() const {
        return p_atmosAlgorithmName;
      };

      bool AtmosAdditiveOffset() const {
        return p_atmosAddOffset;
      };

      double AtmosHnorm() const {
        return p_atmosHnorm;
      };

      double AtmosBha() const {
        return p_atmosBha;
      };

      double AtmosTau() const {
        return p_atmosTau;
      };

      double AtmosWha() const {
        return p_atmosWha;
      };

      double AtmosHga() const {
        return p_atmosHga;
      };

      double AtmosTauref() const {
        return p_atmosTauref;
      };

      bool AtmosNulneg() const {
        return p_atmosNulneg;
      };

      double AtmosAb() const {
        return p_atmosAb;
      };

      double AtmosHahgsb() const {
        return p_atmosHahgsb;
      };

      int AtmosNinc() const {
        return p_atmosNinc;
      };

      double AtmosMunot() const {
        return p_atmosMunot;
      };

      vector <double> AtmosIncTable() {
        return p_atmosIncTable;
      };

      vector <double> AtmosAhTable() {
        return p_atmosAhTable;
      };

      vector <double> AtmosHahgtTable() {
        return p_atmosHahgtTable;
      };

      vector <double> AtmosHahgt0Table() {
        return p_atmosHahgt0Table;
      };

      NumericalApproximation AtmosAhSpline() {
        return p_atmosAhSpline;
      };

      NumericalApproximation AtmosHahgtSpline() {
        return p_atmosHahgtSpline;
      };

      NumericalApproximation AtmosHahgt0Spline() {
        return p_atmosHahgt0Spline;
      };
 
    protected:
      virtual void AtmosModelAlgorithm(double phase, double incidence, double emission) = 0;
 
      void SetAlgorithmName(string name) {
        p_atmosAlgorithmName = name;
      }
      void SetAtmosNulneg(bool nulneg) {
        p_atmosNulneg = nulneg;
      }
      void SetAtmosIord(bool offset) {
        p_atmosAddOffset = offset;
      }
      void SetAtmosEstTau(bool esttau) {
        p_atmosEstTau = esttau;
      }
      void SetOldTau(double tau) {
        p_atmosTauold = tau;
      }
      void SetOldWha(double wha) {
        p_atmosWhaold = wha;
      }
 
      PhotoModel *GetPhotoModel() const {
        return p_atmosPM;
      }
      bool StandardConditions() const {
        return p_standardConditions;
      }
      bool TauOrWhaChanged() const;
      double Eulgam() const {
        return p_atmosEulgam;
      }
 
      int p_atmosAtmSwitch;
      int p_atmosNinc;
 
      double p_atmosBha;
      double p_atmosBhasave;
      double p_atmosHgasave;
      double p_atmosTauref;
      double p_atmosTausave;
      double p_atmosWhasave;
 
      double p_pstd;      
      double p_trans;     
      double p_trans0;    
      double p_transs;    
      double p_sbar;      
      double p_atmosHga;
      double p_atmosTau;
      double p_atmosWha;
      double p_atmosAb;
      double p_atmosHnorm;     
      bool   p_atmosAddOffset; 
      bool   p_atmosEstTau;    
      vector <double> p_atmosIncTable;
      vector <double> p_atmosAhTable;
      double p_atmosHahgsb;
      vector <double> p_atmosHahgtTable;
      vector <double> p_atmosHahgt0Table;
      double p_atmosInc;
      double p_atmosPhi;
      double p_atmosMunot;
      double p_atmosSini;
      double p_atmosCosphi;
      double p_atmosEulgam;

      NumericalApproximation p_atmosAhSpline;
      NumericalApproximation p_atmosHahgtSpline;
      NumericalApproximation p_atmosHahgt0Spline;
 
    private:
      bool p_standardConditions;
 
      string p_atmosAlgorithmName;
 
      PhotoModel *p_atmosPM;
 
      bool p_atmosNulneg;
 
      double p_atmosTauold;
      double p_atmosWhaold;
      friend class NumericalAtmosApprox;
  };
};
 
#endif