SolarSystem.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_INCLUDE
#define SOLAR_SYSTEM_INCLUDE
 
//------------------------------------------------------------------------------------
// includes
// system
#include <fstream>
#include <iostream>
#include <map>
#include <string>
#include <vector>
 
// GNSSTk
#include "EphTime.hpp"
#include "Exception.hpp"
#include "Position.hpp"
 
// geomatics
#include "EOPStore.hpp"
#include "EarthOrientation.hpp"
#include "IERSConvention.hpp"
#include "SolarSystemEphemeris.hpp"
#include "SolidEarthTides.hpp"
#include "SunEarthSatGeometry.hpp"
#include "logstream.hpp"
 
namespace gnsstk
{
 
   //---------------------------------------------------------------------------------
   class SolarSystem : public SolarSystemEphemeris, public EOPStore
   {
 
   public:
      SolarSystem(IERSConvention inputiers = IERSConvention::Unknown)
      {
         iersconv = inputiers;
      }
 
      void setConvention(const IERSConvention& conv)
      {
         iersconv = conv;
         testIERSvsEphemeris(iersconv, EphNumber());
      }
 
      IERSConvention getConvention() const { return iersconv; }
 
      int initializeWithBinaryFile(std::string filename)
      {
         int iret = SolarSystemEphemeris::initializeWithBinaryFile(filename);
 
         // if not defined, set IERS convention to the default; otherwise test it.
         if (iersconv == IERSConvention::Unknown)
         {
            if (EphNumber() == 403)
            {
               iersconv = IERSConvention::IERS1996;
            }
            else if (EphNumber() == 405)
            {
               iersconv = IERSConvention::IERS2010; // the default
            }
            else
            {
               LOG(ERROR) << "Unknown ephemeris number " << EphNumber();
            }
         }
         else
         {
            testIERSvsEphemeris(iersconv, EphNumber());
         }
 
         return iret;
      }
 
      CommonTime startTime() const
      {
         EphTime t;
         t.setMJD(SolarSystemEphemeris::startTimeMJD());
         t.setTimeSystem(TimeSystem::TDB);
         return static_cast<CommonTime>(t);
      }
 
      CommonTime endTime() const
      {
         EphTime t;
         t.setMJD(SolarSystemEphemeris::endTimeMJD());
         t.setTimeSystem(TimeSystem::TDB);
         return static_cast<CommonTime>(t);
      }
 
      EarthOrientation getEOP(double mjdutc)
      {
         return EOPStore::getEOP(mjdutc, iersconv);
      }
 
      Position ECEFPosition(const SolarSystemEphemeris::Planet body,
                            const EphTime& tt);
 
      void ECEFPositionVelocity(const SolarSystemEphemeris::Planet body,
                                const EphTime& tt, Position& Pos, Position& Vel);
 
      Position solarPosition(const EphTime& tt)
      {
         try
         {
            return ECEFPosition(SolarSystemEphemeris::idSun, tt);
         }
         catch (Exception& e)
         {
            GNSSTK_RETHROW(e);
         }
      }
 
      Position lunarPosition(const EphTime& tt)
      {
         try
         {
            return ECEFPosition(SolarSystemEphemeris::idMoon, tt);
         }
         catch (Exception& e)
         {
            GNSSTK_RETHROW(e);
         }
      }
 
      void solarPositionVelocity(const EphTime& tt, Position& Pos, Position& Vel)
      {
         try
         {
            return ECEFPositionVelocity(SolarSystemEphemeris::idSun, tt, Pos,
                                        Vel);
         }
         catch (Exception& e)
         {
            GNSSTK_RETHROW(e);
         }
      }
 
      void lunarPositionVelocity(const EphTime& tt, Position& Pos, Position& Vel)
      {
         try
         {
            return ECEFPositionVelocity(SolarSystemEphemeris::idMoon, tt, Pos,
                                        Vel);
         }
         catch (Exception& e)
         {
            GNSSTK_RETHROW(e);
         }
      }
 
      Matrix<double> satelliteAttitude(const EphTime& tt, const Position& SV)
      {
         try
         {
            Position Sun = SolarSystem::solarPosition(tt);
            return gnsstk::satelliteAttitude(SV, Sun);
         }
         catch (Exception& e)
         {
            GNSSTK_RETHROW(e);
         }
      }
 
      void sunOrbitAngles(const EphTime& tt, const Position& Pos,
                          const Position& Vel, double& beta, double& phi)
      {
         try
         {
            Position Sun = SolarSystem::solarPosition(tt);
            gnsstk::sunOrbitAngles(Pos, Vel, Sun, beta, phi);
         }
         catch (Exception& e)
         {
            GNSSTK_RETHROW(e);
         }
      }
 
      Triple computeSolidEarthTides(const Position site, const EphTime& tt)
      {
         try
         {
            const Position Sun  = SolarSystem::solarPosition(tt);
            const Position Moon = SolarSystem::lunarPosition(tt);
            const double EMRAT  = SolarSystem::ratioEarthToMoonMass();
            const double SERAT  = SolarSystem::ratioSunToEarthMass();
            return gnsstk::computeSolidEarthTides(site, tt, Sun, Moon, EMRAT,
                                                 SERAT, iersconv);
         }
         catch (Exception& e)
         {
            GNSSTK_RETHROW(e);
         }
      }
 
      Triple computePolarTides(const Position site, const EphTime& tt)
      {
         try
         {
            EphTime ttag(tt);
            ttag.convertSystemTo(TimeSystem::UTC);
            const EarthOrientation eo = EOPStore::getEOP(ttag.dMJD(), iersconv);
            return gnsstk::computePolarTides(site, tt, eo.xp, eo.yp, iersconv);
         }
         catch (Exception& e)
         {
            GNSSTK_RETHROW(e);
         }
      }
 
   private:
      IERSConvention iersconv;
 
      void testIERSvsEphemeris(const IERSConvention conv,
                               const int ephno)
      {
         if (ephno == -1)
         {
            return; // no ephemeris (yet)
         }
 
         if ((ephno == 403 && conv != IERSConvention::IERS1996) ||
             (ephno == 405 && conv != IERSConvention::IERS2003 &&
              conv != IERSConvention::IERS2010))
         {
 
            LOG(WARNING) << "Warning - IERS convention (" << conv
                         << ") is inconsistent with SolarSystemEphemeris ("
                         << ephno << ")";
         }
      }
 
   }; // end class SolarSystem
 
} // end namespace gnsstk
 
#endif // SOLAR_SYSTEM_INCLUDE
// nothing below this