SpicePosition.h

Go to the documentation of this file.

#ifndef SpicePosition_h
#define SpicePosition_h

#include <string>
#include <vector>

#include <SpiceUsr.h>
#include <SpiceZfc.h>
#include <SpiceZmc.h>

#include "Table.h"
#include "PolynomialUnivariate.h"

namespace Isis {
  class NumericalApproximation;

  class SpicePosition {
    public:
      //??? jw
      enum Source { Spice,       
                    Memcache,    
                    HermiteCache,
                    PolyFunction, 
                    PolyFunctionOverHermiteConstant 
                    //                table and adding nth degree polynomial
                  };

      SpicePosition(int targetCode, int observerCode);

      virtual ~SpicePosition();

      void SetTimeBias(double timeBias);
      double GetTimeBias() const;

      virtual void SetAberrationCorrection(const QString &correction);
      virtual QString GetAberrationCorrection() const;
      double GetLightTime() const;

      const std::vector<double> &SetEphemerisTime(double et);
      enum PartialType {WRT_X, WRT_Y, WRT_Z};

      double EphemerisTime() const {
        return p_et;
      };

      const std::vector<double> &GetCenterCoordinate();

      const std::vector<double> &Coordinate() {
        return p_coordinate;
      };

      const std::vector<double> &Velocity();

      bool HasVelocity() {
        return p_hasVelocity;
      };

      void LoadCache(double startTime, double endTime, int size);
      void LoadCache(double time);
      void LoadCache(Table &table);

      Table LineCache(const QString &tableName);
      Table LoadHermiteCache(const QString &tableName);

      void ReloadCache();
      void ReloadCache(Table &table);

      Table Cache(const QString &tableName);

      bool IsCached() const {
        return (p_cache.size() > 0);
      };

      void SetPolynomial(const Source type = PolyFunction);

      void SetPolynomial(const std::vector<double>& XC,
                         const std::vector<double>& YC,
                         const std::vector<double>& ZC,
                         const Source type = PolyFunction);

      void GetPolynomial(std::vector<double>& XC,
                         std::vector<double>& YC,
                         std::vector<double>& ZC);

      void SetPolynomialDegree(int degree);

      Source GetSource() {
        return p_source;
      };

      void ComputeBaseTime();

      double GetBaseTime() {
        return p_baseTime;
      };

      void SetOverrideBaseTime(double baseTime, double timeScale);

      double GetTimeScale() {
        return p_timeScale;
      };

      double DPolynomial(const int coeffIndex);

      std::vector<double> CoordinatePartial(SpicePosition::PartialType partialVar, int coeffIndex);

      std::vector<double> VelocityPartial(SpicePosition::PartialType partialVar, int coeffIndex);
      enum OverrideType {NoOverrides, ScaleOnly, BaseAndScale};
      void Memcache2HermiteCache(double tolerance);
      std::vector<double> Extrapolate(double timeEt);
      std::vector<double> HermiteCoordinate();
    protected:
      void SetEphemerisTimeMemcache();
      void SetEphemerisTimeHermiteCache();
      virtual void SetEphemerisTimeSpice();
      void SetEphemerisTimePolyFunction();
      void SetEphemerisTimePolyFunctionOverHermiteConstant();

      std::vector<int> HermiteIndices(double tol, std::vector <int> indexList);

      //======================================================================
      // New methods support for light time correction and swap of observer/target
      SpicePosition(int targetCode, int observerCode, bool swapObserverTarget);
      int getObserverCode() const;
      int getTargetCode() const;
      double getAdjustedEphemerisTime() const;
      void computeStateVector(double et, int target, int observer, 
                              const QString &refFrame, 
                              const QString &abcorr, 
                              double state[6], bool &hasVelocity,
                              double &lightTime) const;
      void setStateVector(const double state[6], const bool &hasVelocity);
      void setLightTime(const double &lightTime);
      //======================================================================

    private:
      void init(int targetCode, int observerCode,
                const bool &swapObserverTarget = false);
      void ClearCache();
      void LoadTimeCache();
      void CacheLabel(Table &table);
      double ComputeVelocityInTime(PartialType var);

      int p_targetCode;                   
      int p_observerCode;                 

      double p_timeBias;                  
      QString p_aberrationCorrection; 

      double p_et;                        
      std::vector<double> p_coordinate;   
      std::vector<double> p_velocity;     

      NumericalApproximation *p_xhermite;
      NumericalApproximation *p_yhermite;
      NumericalApproximation *p_zhermite;

      Source p_source;                    
      std::vector<double> p_cacheTime;    
      std::vector<std::vector<double> > p_cache;         
      std::vector<std::vector<double> > p_cacheVelocity; 
      std::vector<double> p_coefficients[3];             

      double p_baseTime;                  
      double p_timeScale;                 
      bool p_degreeApplied;               
      //    of degree p_degree has been created and
      //    used to fill the cache
      int p_degree;                       
      double p_fullCacheStartTime;        
      double p_fullCacheEndTime;          
      double p_fullCacheSize;             
      bool p_hasVelocity;                 
      OverrideType p_override;            
      double p_overrideBaseTime;          
      double p_overrideTimeScale;         

      // Variables support observer/target swap and light time correction
      bool   m_swapObserverTarget;  
      double m_lt;                 
  };
};

#endif