WsfOrbitalConjunctionAssessment.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 WSFORBITALCONJUNCTIONASSESSMENT_HPP
#define WSFORBITALCONJUNCTIONASSESSMENT_HPP
 
#include "UtCalendar.hpp"
class UtCovariance;
#include "UtException.hpp"
#include "UtOrbitalPropagatorBase.hpp"
#include "UtSpline.hpp"
#include "UtVec3.hpp"
#include "WsfLocalTrack.hpp"

struct WsfOrbitalConjunctionRecord
{
   std::string mPrimary;          
   std::string mSecondary;        
   double      mMinTime;          
   double      mStartTime;        
   double      mEndTime;          
   double      mMaxProbability;   
   double      mMissDistance;     
   double      mRelativeVelocity; 
};

class WsfOrbitalConjunctionAssessment
{
public:
   struct Options
   {
      double mCutRadius;       
      double mStepRadians;     
      double mExclusionFactor; 
      double mInitialSearchTime;   
      double mFinalSearchTime;     
      double mDefaultObjectRadius; 
      double mDefaultVariance;     
   };

   enum class Status
   {
      cNO_CONJUNCTION = 0,
      cCONJUNCTION_FOUND,
      cREACHED_FINAL_TIME
   };
 
   WsfOrbitalConjunctionAssessment(WsfLocalTrack&                 aPrimary,
                                   double                         aPrimarySize,
                                   WsfLocalTrack&                 aSecondary,
                                   double                         aSecondarySize,
                                   const Options&                 aOptions,
                                   const UtOrbitalPropagatorBase* aPropPtr);

   Status FindNext();

   bool ReachedFinalTime() const { return mStatus == Status::cREACHED_FINAL_TIME; }

   WsfOrbitalConjunctionRecord CurrentConjunction() const;

   double DefaultVariance() const { return mOptions.mDefaultVariance; }

   double DefaultObjectRadius() const { return mOptions.mDefaultObjectRadius; }
 
private:
   struct Kinematics
   {
      UtVec3d mPosition;
      UtVec3d mVelocity;
      UtVec3d mAcceleration;
   };

   struct State
   {
      double  DistanceFunction() const;
      double  DistanceFunctionPrime() const;
      double  DistanceFunctionPrimePrime() const;
      UtVec3d RelativePosition() const;
      UtVec3d RelativeVelocity() const;
      UtVec3d RelativeAcceleration() const;
 
      double     mTime;
      Kinematics mPrimary;
      Kinematics mSecondary;
   };
 
   class Encounter
   {
   public:
      Encounter();

      void Reset();

      void Compute(const State&        aCurr,
                   const State&        aNext,
                   double              aCombinedRadius,
                   const UtCovariance& aCombinedCovariance,
                   double              aScaleFactor);

      bool HasCloseEncounter() const { return mRecord.mStartTime < mRecord.mEndTime; }

      WsfOrbitalConjunctionRecord GetRecord() const { return mRecord; }
 
   private:
      void          ComputeProbability(const UtInterpolatingPolynomial<UtVec3d, 5>& aPath, double aCombinedRadius);
      void          ComputeEncounterTimes(const UtInterpolatingPolynomial<UtVec3d, 5>& aPath,
                                          double                                       aCurrTime,
                                          double                                       aNextTime,
                                          double                                       aMinTime,
                                          UtCovariance&                                aCombinedCovariance);
      static double RecomputeMinTime(const UtInterpolatingPolynomial<UtVec3d, 5>& aFunction,
                                     double                                       aLowRange,
                                     double                                       aHighRange);

      template<typename Callable>
      static double ContractTowardRoot(Callable aFunction, double aFixed, double aLimit)
      {
         if (aFunction(aFixed) >= 0.0)
         {
            return aLimit;
         }
         double delta = (aLimit - aFixed) / 2.0;
         double xTest = aFixed + delta;
         while (aFunction(xTest) > 0.0)
         {
            delta /= 2.0;
            xTest = aFixed + delta;
         }
         return xTest + 2.0 * delta;
      }
 
      WsfOrbitalConjunctionRecord mRecord;
   };

   class Object
   {
   public:
      Object(WsfLocalTrack& aTrack, double aSize, const UtOrbitalPropagatorBase* aPropPtr);

      double EstimateTimeStep(double aTime, double aRadians);

      double Periapsis() const;

      double Apoapsis() const;

      double Size() const;

      UtCovariance Covariance(double aTime) const;

      Kinematics Propagate(double aTime);

      void SetConjunctionAssessment(const WsfOrbitalConjunctionAssessment* aConjPtr);

      std::string GetName() const;
 
   private:
      double OrbitRadiusSquared(double aTime);
      double Eccentricity() const;
      double SemiMajorAxis() const;
      double MeanMotion() const;
      void   UpdatePropagator(double aTime);
 
      WsfLocalTrack&                           mTrack;        
      UtCalendar                               mSimStartTime; 
      double                                   mSize;         
      std::unique_ptr<UtOrbitalPropagatorBase> mPropPtr;      
      const WsfOrbitalConjunctionAssessment*   mConjPtr;      
   };
 
   bool   FastFilter();
   void   PredictNextState();
   double FindMinimum();
   double ComputeNextTime();
 
   Object mPrimary;   
   Object mSecondary; 
 
   Options mOptions; 
 
   State mCurrent; 
   State mNext;    
 
   Status    mStatus;    
   Encounter mEncounter; 
};
 
#endif // WSFORBITALCONJUNCTIONASSESSMENT_HPP