SpiceRotation.h

Go to the documentation of this file.

#ifndef SpiceRotation_h
#define SpiceRotation_h

#include <string>
#include <vector>

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

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

#define J2000Code    1

namespace Isis {
  class SpiceRotation {
    public:
      SpiceRotation(int frameCode);
      /*      SpiceRotation( int NaifCode );
      We would like to call refchg instead to avoid the strings.  Currently Naif does
      not have refchg_c, but only the f2c'd refchg.c.*/
      SpiceRotation(int frameCode, int targetCode);
      SpiceRotation(const SpiceRotation &rotToCopy);

      virtual ~SpiceRotation() { }

      void SetFrame(int frameCode) {
        p_constantFrames[0] = frameCode;
      };
      int Frame() {
        return p_constantFrames[0];
      };

      void SetTimeBias(double timeBias);
      enum Source { Spice,                  
                    Nadir,                  
                    Memcache,               
                    PolyFunction,           
                    PolyFunctionOverSpice}; 
                                            //   polynomial

      enum PartialType {WRT_RightAscension, WRT_Declination, WRT_Twist};

      enum DownsizeStatus {Yes, Done, No};
      enum NaifFrameType { INERTL = 1, PCK = INERTL + 1, CK = PCK + 1, TK = CK + 1, DYN = TK + 1};

      void SetEphemerisTime(double et);

      double EphemerisTime() const {
        return p_et;
      };

      std::vector<double> GetCenterAngles();
      
      std::vector<double> Matrix();
      std::vector<double> AngularVelocity() {
        return p_av;
      };
      std::vector<double> &ConstantMatrix() {
        return p_TC;
      };
      std::vector<double> &TimeBasedMatrix() {
        return p_CJ;
      };

      std::vector<double> J2000Vector(const std::vector<double>& rVec);

      std::vector<double> ReferenceVector(const std::vector<double>& jVec);

      std::vector<double> EvaluatePolyFunction();
      void MinimizeCache(DownsizeStatus status) {
        p_minimizeCache = status;
      };

      void LoadCache(double startTime, double endTime, int size);

      void LoadCache(double time);

      void LoadCache(Table &table);

      Table LineCache(const QString &tableName);

      void ReloadCache();

      Table Cache(const QString &tableName);
      void CacheLabel(Table &table);

      void LoadTimeCache();

      std::vector<double> Angles(int axis3, int axis2, int axis1);

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

      void SetPolynomial(const Source type=PolyFunction);

      void SetPolynomial(const std::vector<double>& abcAng1,
                         const std::vector<double>& abcAng2,
                         const std::vector<double>& abcAng3,
                         const Source type = PolyFunction);

      void GetPolynomial(std::vector<double>& abcAng1,
                         std::vector<double>& abcAng2,
                         std::vector<double>& abcAng3);

      void SetPolynomialDegree(int degree);

      Source GetSource() {
        return p_source;
      };

      void SetSource(Source source) {
        p_source = source;
        return;
      };

      void ComputeBaseTime();

      double GetBaseTime() {
        return p_baseTime;
      };

      double GetTimeScale() {
        return p_timeScale;
      };

      void SetOverrideBaseTime(double baseTime, double timeScale);

      double DPolynomial(const int coeffIndex);

      std::vector<double> ToReferencePartial(std::vector<double>& lookJ,
                                             PartialType partialVar, int coeffIndex);
      double WrapAngle(double compareAngle, double angle);
      void SetAxes(int axis1, int axis2, int axis3);
      std::vector<double> GetFullCacheTime();
      void FrameTrace(double et);

      std::vector<int>  ConstantFrameChain() {
        return p_constantFrames;
      };

      std::vector<int>  TimeFrameChain() {
        return p_timeFrames;
      };

      void InitConstantRotation(double et);
      std::vector<double> ConstantRotation();
      std::vector<double> TimeBasedRotation();
      void DCJdt(std::vector<double> &dRJ);

      bool HasAngularVelocity() {
        return p_hasAngularVelocity;
      };

      void ComputeAv();
      std::vector<double> Extrapolate(double timeEt);


    protected:
      void SetFullCacheParameters(double startTime, double endTime, int cacheSize);
      std::vector<double> p_cacheTime;  
      std::vector<std::vector<double> > p_cache;      

      //    J2000 to 1st constant frame (CJ) or
      //    coefficients of polynomial
      //    fit to rotation angles
      int p_degree;                     
      int p_axis1;                      
      int p_axis2;                      
      int p_axis3;                      
      void SetEphemerisTimeMemcache();
      void SetEphemerisTimeNadir();
      void SetEphemerisTimeSpice();
      void SetEphemerisTimePolyFunction();
      void SetEphemerisTimePolyFunctionOverSpice();

    private:
      std::vector<int> p_constantFrames;  
      //    The first entry will always be the target frame code
      std::vector<int> p_timeFrames;      
      //    The last entry will always be 1 (J2000 code)
      double p_timeBias;                  

      double p_et;                        
      Quaternion p_quaternion;            
      //   rotation at et

      bool p_matrixSet;                   

      Source p_source;                    
      int p_axisP;                        
      //   vector for defining a nadir rotation
      int p_axisV;                        
      //   vector for defining a nadir rotation
      int p_targetCode;                   

      double p_baseTime;                  
      double p_timeScale;                 
      bool p_degreeApplied;               
      //    of degree p_degree has been created and
      //    used to fill the cache
      std::vector<double> p_coefficients[3];  
      bool p_noOverride;                  
      double p_overrideBaseTime;          
      double p_overrideTimeScale;         
      DownsizeStatus p_minimizeCache;     
      double p_fullCacheStartTime;        
      double p_fullCacheEndTime;          
      int p_fullCacheSize;                
      std::vector<double> p_TC;           
      //    time-based rotations in frame chain from J2000 to target)
      //    to the target frame
      std::vector<double> p_CJ;           
      //    after all the time-based rotations in frame chain from
      std::vector<std::vector<double> > p_cacheAv;
      std::vector<double> p_av;           
      bool p_hasAngularVelocity;          
      std::vector<double> StateTJ();      
  };
};

#endif