SolarSystemEphemeris.hpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 3.0 of the License, or
//  any later version.
//
//  The GNSSTk is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin, under contract to an agency or agencies
//  within the U.S. Department of Defense. The U.S. Government retains all
//  rights to use, duplicate, distribute, disclose, or release this software.
//
//  Pursuant to DoD Directive 523024
//
//  DISTRIBUTION STATEMENT A: This software has been approved for public
//                            release, distribution is unlimited.
//
//==============================================================================
 
//------------------------------------------------------------------------------------
#ifndef SOLAR_SYSTEM_EPHEMERIS_INCLUDE
#define SOLAR_SYSTEM_EPHEMERIS_INCLUDE
 
//------------------------------------------------------------------------------------
// includes
// system
#include <fstream>
#include <iostream>
#include <map>
#include <string>
#include <vector>
// GNSSTk
#include "Exception.hpp"
#include "TimeConstants.hpp"
 
namespace gnsstk
{
 
   //---------------------------------------------------------------------------------
   class SolarSystemEphemeris
   {
   public:
      enum ReturnValue
      {
         retOK = 0,     
         retEarly = -1, 
         retLate = -2,  
         retStrm = -3,  
         retEphN = -4   
      };
 
      enum Planet
      {
         // the following are relative to the solar system barycenter, except
         // MOON
         idNone = 0,              
         idMercury,               
         idVenus,                 
         idEarth,                 
         idMars,                  
         idJupiter,               
         idSaturn,                
         idUranus,                
         idNeptune,               
         idPluto,                 
         idMoon,                  
         idSun,                   
         idSolarSystemBarycenter, 
         idEarthMoonBarycenter,   
         idNutations,             
         idLibrations             
      };
 
      SolarSystemEphemeris() : EphemerisNumber(-1){};
 
      //------------------------------------------------------------------
      // reading and writing ASCII (JPL) files
 
      void readASCIIheader(const std::string& filename);
 
      int readASCIIdata(std::vector<std::string>& filenames);
 
      int readASCIIdata(const std::string& filename);
 
      int writeASCIIheader(std::ostream& os);
 
      int writeASCIIdata(std::ostream& os);
 
      //------------------------------------------------------------------
      // reading and writing binary files
 
      int writeBinaryFile(const std::string& filename);
 
      void clearStorage() { store.clear(); }
 
      int readBinaryFile(const std::string& filename);
 
      int initializeWithBinaryFile(const std::string& filename);
 
      //------------------------------------------------------------------
      // utilizing the ephemeris
 
      void relativeInertialPositionVelocity(double MJD, Planet target,
                                            Planet center, double PV[6],
                                            bool kilometers = true);
 
      double AU()
      {
         if (EphemerisNumber == -1)
         {
            return -1.0;
         }
         return constants["AU"];
      }
 
      int EphNumber() const { return EphemerisNumber; }
 
      double getConstant(const std::string& name)
      {
         if (EphemerisNumber == -1)
         {
            return -1.0;
         }
         if (constants.find(name) != constants.end())
         {
            return constants[name];
         }
         return 0.0;
      }
 
      double ratioEarthToMoonMass()
      {
         return getConstant(std::string("EMRAT"));
      }
 
      double ratioSunToEarthMass()
      {
         double em  = getConstant(std::string("EMRAT"));
         double gms = getConstant(std::string("GMS"));
         double gmb = getConstant(std::string("GMB"));
         return (gms * ((1.0 + em) / em) / gmb);
      }
 
      double startTimeMJD() const { return (startJD - MJD_TO_JD); }
 
      double endTimeMJD() const { return (endJD - MJD_TO_JD); }
 
      //------------------------------------------------------------------
      // private functions
 
   private:
      void writeBinary(std::ofstream& strm, const char *ptr, size_t size);
 
      void readBinary(char *ptr, size_t size);
 
      void readBinaryHeader(const std::string& filename);
 
      int readBinaryData(bool save);
 
      int readBinaryRecord(std::vector<double>& data_vector);
 
      int seekToJD(double JD);
 
      //------------------------------------------------------------------
      // define here for use in next function
      enum computeID
      {
         // the following are relative to the solar system barycenter, except
         // MOON
         NONE = -1, 
         MERCURY,   
         VENUS,     
         EMBARY,    
         MARS,      
         JUPITER,   
         SATURN,    
         URANUS,    
         NEPTUNE,   
         PLUTO,     
         MOON,      
         SUN,       
         NUTATIONS, 
         LIBRATIONS 
      };
 
      void inertialPositionVelocity(double MJD, computeID which, double PV[6]);
 
      //------------------------------------------------------------------
      // member data
 
      // input stream, for use by readBinary...()
      std::ifstream istrm; 
 
      // header information
 
      // protected so it can be used by class SolarSystem
      int EphemerisNumber;
 
      int Ncoeff;
 
      int Nconst; 
      std::string label[3]; 
      double startJD;       
      double endJD;         
      double interval;      
      int c_offset[13]; 
      int
         c_ncoeff[13]; 
      int c_nsets[13]; 
 
      std::map<std::string, double> constants;
 
      std::map<double, std::vector<double>> store;
 
      std::map<double, long> fileposMap;
 
      std::vector<double> coefficients;
 
   }; // end class SolarSystemEphemeris
 
} // end namespace gnsstk
 
#endif // SOLAR_SYSTEM_EPHEMERIS_INCLUDE
// nothing below this