WsfOrbitalTargeting.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2017 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 WSFORBITALTARGETING_HPP
#define WSFORBITALTARGETING_HPP
 
#include "wsf_space_export.h"
 
#include <numeric>
#include <utility>
#include <vector>
 
#include "UtCalendar.hpp"
#include "UtCloneablePtr.hpp"
#include "UtLambertProblem.hpp"
class UtOrbitalPropagatorBase;
#include "UtVec3.hpp"
 
namespace wsf
{
namespace space
{
class OrbitalTargetPoint;
class OrbitalTargetingCost;
} // namespace space
} // namespace wsf

class WSF_SPACE_EXPORT WsfOrbitalTargeting
{
public:
   WsfOrbitalTargeting(const UtCalendar&                     aTime,
                       UtOrbitalPropagatorBase&              aInterceptorProp,
                       const wsf::space::OrbitalTargetPoint& aTarget);
 
   WsfOrbitalTargeting(const UtCalendar&                     aTime,
                       UtOrbitalPropagatorBase&              aInterceptorProp,
                       const wsf::space::OrbitalTargetPoint& aTarget,
                       bool                                  aAllowHyperbolic,
                       bool                                  aAllowEarthHit);
 
   WsfOrbitalTargeting(const WsfOrbitalTargeting& aOther) = delete;
   WsfOrbitalTargeting(WsfOrbitalTargeting&&)             = default;
 
   ~WsfOrbitalTargeting() = default;
 
   UtLambertProblem::Result
   MinimizeDeltaV(double aDtMax, double aDvMax, bool aRendezvous, double aTimeTolerance, double& aDt, double& aDv) const;
 
   UtLambertProblem::Result
   MinimizeDeltaT(double aDtMax, double aDvMax, bool aRendezvous, double aTimeTolerance, double& aDt, double& aDv) const;

   UtLambertProblem::Result MinimizeCost(const wsf::space::OrbitalTargetingCost& aCost,
                                         double                                  aDtMax,
                                         double                                  aDvMax,
                                         bool                                    aRendezvous,
                                         double                                  aTimeTolerance,
                                         double&                                 aDt,
                                         double&                                 aDv) const;
 
   static bool GoShortWay(const UtVec3d& aLocationInterceptor,
                          const UtVec3d& aVelocityInterceptor,
                          const UtVec3d& aLocationTarget);
 
   UtLambertProblem::Result Solve(double aDt, bool aRendezvous, double& aDeltaV) const;
 
   UtLambertProblem::Result Solve(double aDt, UtVec3d& aDeltaV_Intercept, UtVec3d& aDeltaV_Rendezvous) const;
 
   double GetTolerance() const { return mTolerance; }
 
   void SetTolerance(double aTolerance) { mTolerance = aTolerance; }
 
private:
   struct Sample
   {
      Sample() = default;
      Sample(double aDt, double aDv, bool aHasSolution)
         : mDt{aDt}
         , mDv{aDv}
         , mHasSolution{aHasSolution}
      {
      }
 
      double mDt{std::numeric_limits<double>::max()};
      double mDv{std::numeric_limits<double>::max()};
      double mCost{std::numeric_limits<double>::max()};
      bool   mHasSolution{false};
   };
 
   Sample Solve(double aDt, bool aRendezvous) const;

   std::vector<std::pair<double, double>> FindAllRangesCost(const wsf::space::OrbitalTargetingCost& aCost,
                                                            double                                  aDtZero,
                                                            double                                  aDtMax,
                                                            double                                  aDvMax,
                                                            bool                                    aRendezvous) const;

   UtLambertProblem::Result SearchCost(const wsf::space::OrbitalTargetingCost& aCost,
                                       double                                  aDtLow,
                                       double                                  aDtHigh,
                                       bool                                    aRendezvous,
                                       double                                  aDvMax,
                                       double                                  aTimeTolerance,
                                       double&                                 aDeltaV) const;
 
   const UtCalendar                               mTime;
   UtOrbitalPropagatorBase&                       mInterceptorProp;
   UtCloneablePtr<wsf::space::OrbitalTargetPoint> mTargetPtr;
   double                                         mTolerance{1.0e-9};
   bool                                           mAllowEarthHit{false};
};
 
#endif