WsfSpaceOrbitalPropagatorCondition.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2022 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 WSFSPACEORBITALPROPAGATORCONDITION_HPP
#define WSFSPACEORBITALPROPAGATORCONDITION_HPP
 
#include "wsf_space_export.h"
 
#include <utility>
 
#include "UtCalendar.hpp"
class UtInput;
class UtOrbitalPropagatorBase;
#include "UtUnitTypes.hpp"
#include "UtVec3.hpp"
#include "WsfObject.hpp"
 
namespace wsf
{
namespace space
{
class OrbitalPropagatorConditionVisitor;

class WSF_SPACE_EXPORT OrbitalPropagatorCondition : public WsfObject
{
public:
   OrbitalPropagatorCondition* Clone() const override = 0;
 
   bool ProcessInput(UtInput& aInput) override;

   unsigned GetOrbitNumber() const { return mOrbitNumber; }

   void SetOrbitNumber(unsigned aOrbitNumber) { mOrbitNumber = aOrbitNumber; }

   virtual bool ValidateParameterRanges() const { return true; }

   virtual bool GetTimeToCondition(const UtOrbitalPropagatorBase& aPropagator, double& aTimeToCondition) const = 0;

   virtual void Accept(OrbitalPropagatorConditionVisitor& aVisitor) = 0;

   virtual std::string GetConditionString() const = 0;
 
protected:
   unsigned mOrbitNumber{0};
};

class WSF_SPACE_EXPORT OrbitalPropagatorOptimizingCondition : public OrbitalPropagatorCondition
{
public:
   virtual bool Objective(UtOrbitalPropagatorBase& aPropagator, const UtCalendar& aBaseEpoch, double aOffsetTime) const = 0;

   virtual std::pair<bool, double> InitialGuess(const UtOrbitalPropagatorBase& aPropagator) const = 0;

   bool GetTimeToCondition(const UtOrbitalPropagatorBase& aPropagator, double& aTimeToCondition) const final;

   virtual bool HandleSpecialCases(const UtOrbitalPropagatorBase& aPropagator, double& aTimeToCondition) const
   {
      return false;
   }
};

class WSF_SPACE_EXPORT NoneCondition : public OrbitalPropagatorCondition
{
public:
   NoneCondition() { SetType(cTYPE); }
 
   NoneCondition* Clone() const override { return new NoneCondition{*this}; }
 
   bool GetTimeToCondition(const UtOrbitalPropagatorBase& aPropagator, double& aTimeToCondition) const override;
 
   void Accept(OrbitalPropagatorConditionVisitor& aVisitor) override;
 
   std::string GetConditionString() const override { return "NONE"; }
 
   constexpr static const char* cTYPE{"none"};
};

class WSF_SPACE_EXPORT RelativeTimeCondition : public OrbitalPropagatorCondition
{
public:
   RelativeTimeCondition() { SetType(cTYPE); }
 
   RelativeTimeCondition* Clone() const override { return new RelativeTimeCondition{*this}; }
 
   bool ProcessInput(UtInput& aInput) override;
 
   UtTimeValue GetOffsetTime() const { return mOffsetTime; }
 
   void SetOffsetTime(const UtTimeValue& aOffsetTime) { mOffsetTime = aOffsetTime; }
 
   bool ValidateParameterRanges() const override;
 
   bool GetTimeToCondition(const UtOrbitalPropagatorBase& aPropagator, double& aTimeToCondition) const override;
 
   void Accept(OrbitalPropagatorConditionVisitor& aVisitor) override;
 
   std::string GetConditionString() const override { return "AT_RELATIVE_TIME"; }
 
   constexpr static const char* cTYPE{"relative_time"};
 
private:
   UtTimeValue mOffsetTime{};
};

class WSF_SPACE_EXPORT PeriapsisCondition : public OrbitalPropagatorOptimizingCondition
{
public:
   PeriapsisCondition() { SetType(cTYPE); }
 
   PeriapsisCondition* Clone() const override { return new PeriapsisCondition{*this}; }
 
   std::pair<bool, double> InitialGuess(const UtOrbitalPropagatorBase& aPropagator) const override;
 
   bool Objective(UtOrbitalPropagatorBase& aPropagator, const UtCalendar& aBaseEpoch, double aOffsetTime) const override;
 
   bool HandleSpecialCases(const UtOrbitalPropagatorBase& aPropagator, double& aTimeToCondition) const override;
 
   void Accept(OrbitalPropagatorConditionVisitor& aVisitor) override;
 
   std::string GetConditionString() const override { return "AT_PERIAPSIS"; }
 
   constexpr static const char* cTYPE{"periapsis"};
};

class WSF_SPACE_EXPORT ApoapsisCondition : public OrbitalPropagatorOptimizingCondition
{
public:
   ApoapsisCondition() { SetType(cTYPE); }
 
   ApoapsisCondition* Clone() const override { return new ApoapsisCondition{*this}; }
 
   std::pair<bool, double> InitialGuess(const UtOrbitalPropagatorBase& aPropagator) const override;
 
   bool Objective(UtOrbitalPropagatorBase& aPropagator, const UtCalendar& aBaseEpoch, double aOffsetTime) const override;
 
   bool HandleSpecialCases(const UtOrbitalPropagatorBase& aPropagator, double& aTimeToCondition) const override;
 
   void Accept(OrbitalPropagatorConditionVisitor& aVisitor) override;
 
   std::string GetConditionString() const override { return "AT_APOAPSIS"; }
 
   constexpr static const char* cTYPE{"apoapsis"};
};

class WSF_SPACE_EXPORT AscendingNodeCondition : public OrbitalPropagatorOptimizingCondition
{
public:
   AscendingNodeCondition() { SetType(cTYPE); }
 
   AscendingNodeCondition* Clone() const override { return new AscendingNodeCondition{*this}; }
 
   std::pair<bool, double> InitialGuess(const UtOrbitalPropagatorBase& aPropagator) const override;
 
   bool Objective(UtOrbitalPropagatorBase& aPropagator, const UtCalendar& aBaseEpoch, double aOffsetTime) const override;
 
   bool HandleSpecialCases(const UtOrbitalPropagatorBase& aPropagator, double& aTimeToCondition) const override;
 
   void Accept(OrbitalPropagatorConditionVisitor& aVisitor) override;
 
   std::string GetConditionString() const override { return "AT_ASCENDING_NODE"; }
 
   constexpr static const char* cTYPE{"ascending_node"};
};

class WSF_SPACE_EXPORT DescendingNodeCondition : public OrbitalPropagatorOptimizingCondition
{
public:
   DescendingNodeCondition() { SetType(cTYPE); }
 
   DescendingNodeCondition* Clone() const override { return new DescendingNodeCondition{*this}; }
 
   std::pair<bool, double> InitialGuess(const UtOrbitalPropagatorBase& aPropagator) const override;
 
   bool Objective(UtOrbitalPropagatorBase& aPropagator, const UtCalendar& aBaseEpoch, double aOffsetTime) const override;
 
   bool HandleSpecialCases(const UtOrbitalPropagatorBase& aPropagator, double& aTimeToCondition) const override;
 
   void Accept(OrbitalPropagatorConditionVisitor& aVisitor) override;
 
   std::string GetConditionString() const override { return "AT_DESCENDING_NODE"; }
 
   constexpr static const char* cTYPE{"descending_node"};
};

class WSF_SPACE_EXPORT EclipseEntryCondition : public OrbitalPropagatorCondition
{
public:
   EclipseEntryCondition() { SetType(cTYPE); }
 
   EclipseEntryCondition* Clone() const override { return new EclipseEntryCondition{*this}; }
 
   bool GetTimeToCondition(const UtOrbitalPropagatorBase& aPropagator, double& aTimeToCondition) const override;
 
   void Accept(OrbitalPropagatorConditionVisitor& aVisitor) override;
 
   std::string GetConditionString() const override { return "AT_ECLIPSE_ENTRY"; }
 
   constexpr static const char* cTYPE{"eclipse_entry"};
};

class WSF_SPACE_EXPORT EclipseExitCondition : public OrbitalPropagatorCondition
{
public:
   EclipseExitCondition() { SetType(cTYPE); }
 
   EclipseExitCondition* Clone() const override { return new EclipseExitCondition{*this}; }
 
   bool GetTimeToCondition(const UtOrbitalPropagatorBase& aPropagator, double& aTimeToCondition) const override;
 
   void Accept(OrbitalPropagatorConditionVisitor& aVisitor) override;
 
   std::string GetConditionString() const override { return "AT_ECLIPSE_EXIT"; }
 
   constexpr static const char* cTYPE{"eclipse_exit"};
};
 
class RadiusCondition : public OrbitalPropagatorOptimizingCondition
{
public:
   RadiusCondition() = default;
 
   bool ProcessInput(UtInput& aInput) override;
 
   UtLengthValue GetRadius() const { return mRadius; }
 
   void SetRadius(const UtLengthValue& aRadius) { mRadius = aRadius; }
 
   bool ValidateParameterRanges() const override;
 
protected:
   UtLengthValue mRadius{};
};

class WSF_SPACE_EXPORT AscendingRadiusCondition : public RadiusCondition
{
public:
   AscendingRadiusCondition() { SetType(cTYPE); }
 
   AscendingRadiusCondition* Clone() const override { return new AscendingRadiusCondition{*this}; }
 
   std::pair<bool, double> InitialGuess(const UtOrbitalPropagatorBase& aPropagator) const override;
 
   bool Objective(UtOrbitalPropagatorBase& aPropagator, const UtCalendar& aBaseEpoch, double aOffsetTime) const override;
 
   void Accept(OrbitalPropagatorConditionVisitor& aVisitor) override;
 
   std::string GetConditionString() const override { return "AT_ASCENDING_RADIUS"; }
 
   constexpr static const char* cTYPE{"ascending_radius"};
};

class WSF_SPACE_EXPORT DescendingRadiusCondition : public RadiusCondition
{
public:
   DescendingRadiusCondition() { SetType(cTYPE); }
 
   DescendingRadiusCondition* Clone() const override { return new DescendingRadiusCondition{*this}; }
 
   std::pair<bool, double> InitialGuess(const UtOrbitalPropagatorBase& aPropagator) const override;
 
   bool Objective(UtOrbitalPropagatorBase& aPropagator, const UtCalendar& aBaseEpoch, double aOffsetTime) const override;
 
   void Accept(OrbitalPropagatorConditionVisitor& aVisitor) override;
 
   std::string GetConditionString() const override { return "AT_DESCENDING_RADIUS"; }
 
   constexpr static const char* cTYPE{"descending_radius"};
};
 
class WSF_SPACE_EXPORT IntersectionCondition : public OrbitalPropagatorOptimizingCondition
{
public:
   IntersectionCondition() = default;
 
   double GetRAAN() const { return mRAAN; }
   double GetInclination() const { return mInclination; }
 
   void SetRAAN(double aRAAN);
   void SetInclination(double aInclination);
 
   void SetIntersectionRAAN_Inclination(double aRAAN, double aInclination);
 
   bool HandleSpecialCases(const UtOrbitalPropagatorBase& aPropagator, double& aTimeToCondition) const override;
 
protected:
   UtVec3d OrbitNormal(double aRAAN, double aInclination) const;
 
   double mRAAN{0.0};
   double mInclination{0.0};
};

class WSF_SPACE_EXPORT NorthernIntersectionCondition : public IntersectionCondition
{
public:
   NorthernIntersectionCondition() { SetType(cTYPE); }
 
   NorthernIntersectionCondition* Clone() const override { return new NorthernIntersectionCondition{*this}; }
 
   std::pair<bool, double> InitialGuess(const UtOrbitalPropagatorBase& aPropagator) const override;
 
   bool Objective(UtOrbitalPropagatorBase& aPropagator, const UtCalendar& aBaseEpoch, double aOffsetTime) const override;
 
   void Accept(OrbitalPropagatorConditionVisitor& aVisitor) override;
 
   std::string GetConditionString() const override { return "AT_NORTHERN_INTERSECTION"; }
 
   constexpr static const char* cTYPE{"northern_intersection"};
};

class WSF_SPACE_EXPORT SouthernIntersectionCondition : public IntersectionCondition
{
public:
   SouthernIntersectionCondition() { SetType(cTYPE); }
 
   SouthernIntersectionCondition* Clone() const override { return new SouthernIntersectionCondition{*this}; }
 
   std::pair<bool, double> InitialGuess(const UtOrbitalPropagatorBase& aPropagator) const override;
 
   bool Objective(UtOrbitalPropagatorBase& aPropagator, const UtCalendar& aBaseEpoch, double aOffsetTime) const override;
 
   void Accept(OrbitalPropagatorConditionVisitor& aVisitor) override;
 
   std::string GetConditionString() const override { return "AT_SOUTHERN_INTERSECTION"; }
 
   constexpr static const char* cTYPE{"southern_intersection"};
};
 
} // namespace space
} // namespace wsf
 
#endif // WSFSPACEORBITALPROPAGATORCONDITION_HPP