SpicePosition.h

#ifndef SpicePosition_h
#define SpicePosition_h
 
/* SPDX-License-Identifier: CC0-1.0 */
#include <string>
#include <vector>
 
#include <SpiceUsr.h>
#include <SpiceZfc.h>
#include <SpiceZmc.h>
 
#include "Table.h"
#include "PolynomialUnivariate.h"
 
// ale includes
#include "ale/States.h"
 
#include <nlohmann/json.hpp>
 
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);
      void LoadCache(nlohmann::json &isd);
 
      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 (m_state != NULL);
      };
 
      int cacheSize() const {
        if (m_state) {
          return m_state->getStates().size();
        }
        return 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();
 
      //======================================================================
      // 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;     
 
      Source p_source;                    
      std::vector<double> p_cacheTime;    
      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;                 
 
      ale::States *m_state; 
  };
};
 
#endif