Isis 3.0 Object Programmers' Reference

Home

---

AtmosModel.h

Go to the documentation of this file.

#ifndef AtmosModel_h
#define AtmosModel_h

#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) throw (iException &);
      static double En(unsigned int n, double x) throw (iException &);
      // Calculate atmospheric scattering effect
      void CalcAtmEffect(double pha, double inc, double ema, double *pstd, 
                         double *trans, double *trans0, double *sbar);
      // 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();
      // Set parameters needed for atmospheric correction
      void SetAtmosAtmSwitch (const int atmswitch);
      void SetAtmosBha       (const double bha   );
      void SetAtmosBharef    (const double bharef);
      void SetAtmosHga       (const double hga   );
      void SetAtmosHgaref    (const double hgaref);
      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 SetAtmosWharef    (const double wharef);
      
      string AlgorithmName () const { return p_atmosAlgorithmName; };

      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 AtmosBharef () const { return p_atmosBharef; };
      double AtmosHgaref () const { return p_atmosHgaref; };
      double AtmosTauref () const { return p_atmosTauref; };
      double AtmosWharef () const { return p_atmosWharef; };
      bool AtmosNulneg () const { return p_atmosNulneg; };
      double AtmosAb () const { return p_atmosAb; };
      double AtmosHahgsb () const { return p_atmosHahgsb; };
      int AtmosNinc () const { return p_atmosNinc; };

      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 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_atmosBharef;
      double p_atmosBhasave;
      double p_atmosHgaref;
      double p_atmosHgasave;
      double p_atmosTauref;
      double p_atmosTausave;
      double p_atmosWharef;
      double p_atmosWhasave;

      double p_pstd;   
      double p_trans;  
      double p_trans0; 
      double p_sbar;   
      double p_atmosHga;
      double p_atmosTau;
      double p_atmosWha;
      double p_atmosAb;
      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