WsfDE_File.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2020 Infoscitex, a DCS Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef WSFDEFILE_HPP
#define WSFDEFILE_HPP
 
// This class is based on the equivalent functionality from NOVAS.
/*
  Naval Observatory Vector Astrometry Software (NOVAS)
  C Edition, Version 3.1
 
  eph_manager.h: Header file for eph_manager.c
 
  U. S. Naval Observatory
  Astronomical Applications Dept.
  Washington, DC
  http://www.usno.navy.mil/USNO/astronomical-applications
*/
 
#include <array>
#include <cstdint>
#include <fstream>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "UtVec3.hpp"

class WsfDE_File
{
public:
   explicit WsfDE_File(const std::string& aFileName);
   ~WsfDE_File() = default;

   enum class Body : int
   {
      cMERCURY                 = 0,
      cVENUS                   = 1,
      cEARTH                   = 2,
      cMARS                    = 3,
      cJUPITER                 = 4,
      cSATURN                  = 5,
      cURANUS                  = 6,
      cNEPTUNE                 = 7,
      cPLUTO                   = 8,
      cMOON                    = 9,
      cSUN                     = 10,
      cSOLAR_SYSTEM_BARYCENTER = 11,
      cEARTH_MOON_BARYCENTER   = 12
   };

   struct Date
   {
      double mParts[2];
   };

   struct Workspace
   {
      Workspace()
      {
         // These Chebyshev polynomials are constant.
         mPc[0] = 1.0;
         mVc[0] = 0.0;
         mVc[1] = 1.0;
      }
 
      int                    mNumP{2};   
      int                    mNumV{3};   
      std::array<double, 18> mPc{};      
      std::array<double, 18> mVc{};      
      double                 mTwoT{0.0}; 
   };
 
   void GetPlanetEphemeris(const Date& aEpoch,
                           Body        aTarget,
                           Body        aOrigin,
                           Workspace&  aWorkspace,
                           UtVec3d&    aPosition,
                           UtVec3d&    aVelocity) const;

   int GetDE_Num() const { return mDE_Num; }

   double GetFileStartJD() const { return mInitialJD; }

   double GetFileEndJD() const { return mFinalJD; }

   const std::string& GetFileName() const { return mFileName; }
 
   class Error : public std::runtime_error
   {
   public:
      explicit Error(const std::string& aWhat)
         : std::runtime_error(aWhat)
      {
      }
   };
 
private:
   class Record
   {
   public:
      explicit Record(int aRecordLength);
      void          Read(std::ifstream& aStream, int aRecordLength);
      const double* Data(int aOffset) const;
 
   private:
      std::vector<double> mData;
   };
 
   const Record& GetRecord(int aRecordNumber) const;
 
   void State(const Date& aTimeJD, Body aTarget, Workspace& aWorkspace, UtVec3d& aPosition, UtVec3d& aVelocity) const;
   void Interpolate(const double* aBuffer,
                    double        aInterpolationEpoch,
                    double        aIntervalSpan,
                    int           aNumCoeffPerComponent,
                    int           aNumSetsCoeff,
                    Workspace&    aWorkspace,
                    UtVec3d&      aPosition,
                    UtVec3d&      aVelocity) const;
   Date PrepareEpoch(const Date& aEpoch) const;
   int  ComputeRecordNumber(const Date& aEpoch) const;
   void ComputeInterpolationTimes(const Date& aEpoch, int aRecordNum, double& aInterpolationTime, double& aIntervalSpan) const;
   void        LoadAllRecords(std::ifstream& aFileStream);
   static void Split(double aValue, double& aWhole, double& aFraction);
 
   std::string                   mFileName{};     
   std::uint32_t                 mDE_Num{};       
   double                        mEM_Factor{1.0}; 
   std::array<std::uint32_t, 12> mRecordOffset{}; 
   std::array<std::uint32_t, 12> mNumCoeffPerComponent{}; 
   std::array<std::uint32_t, 12> mNumSetsCoeff{};         
   double                        mInitialJD{0.0};         
   double                        mFinalJD{0.0};           
   double                        mRecordInterval{0.0};    
   int                           mRecordLength{0};        
   int                           mInitialRecordNum{};     
   int                           mFinalRecordNum{};       
   std::vector<Record>           mRecords{};              
};
 
#endif // WSFDEFILE_HPP