WsfSpaceMoverBase.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing 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.
// ****************************************************************************
// ****************************************************************************
// Updated by Infoscitex, a DCS Company
// ****************************************************************************
 
#ifndef WSFSPACEMOVERBASE_HPP
#define WSFSPACEMOVERBASE_HPP
 
#include "wsf_space_export.h"
 
#include <memory>
 
class UtCalendar;
#include "UtCentralBody.hpp"
#include "UtCloneablePtr.hpp"
#include "UtColor.hpp"
#include "UtOptional.hpp"
class UtOrbitalElements;
#include "UtOrbitalPropagatorBase.hpp"
namespace ut
{
class OrbitalState;
}
class WsfAttitudeController;
class WsfConjunctionInput;
class WsfDraw;
#include "WsfGeoPoint.hpp"
#include "WsfMover.hpp"
class WsfOrbitalEvent;
class WsfOrbitalManeuver;
class WsfOrbitalManeuvering;
class WsfOrbitalMissionSequence;
class WsfScriptContext;
#include "WsfSpaceComponentRoles.hpp"
#include "WsfSpaceOrbitalMissionSimulationContext.hpp"
#include "WsfSpaceVerifyTypes.hpp"
#include "WsfStringId.hpp"

class WSF_SPACE_EXPORT WsfSpaceMoverBase : public WsfMover
{
public:
   WsfSpaceMoverBase() = delete;
   WsfSpaceMoverBase(const WsfScenario&                       aScenario,
                     std::unique_ptr<UtOrbitalPropagatorBase> aPropagatorPtr,
                     const std::string&                       aScriptClassName = "WsfSpaceMover");
   WsfSpaceMoverBase(const WsfSpaceMoverBase& aSrc);
   WsfSpaceMoverBase& operator=(const WsfSpaceMoverBase&) = delete;
   ~WsfSpaceMoverBase() override;


   WsfMover*  Clone() const override;
   const int* GetComponentRoles() const override;
   void*      QueryInterface(int aRole) override;
   bool       PreInitialize(double aSimTime) override;
   bool       Initialize(double aSimTime) override;
   bool       Initialize2(double aSimTime) override;
   bool       ProcessInput(UtInput& aInput) override;
   void       Update(double aSimTime) override;


   const ut::OrbitalState& GetOrbitalState() const;
   double                  GetAvailableDeltaV() const;
   double                  GetRequiredDuration(double aDeltaV) const;
   double                  GetRequiredDeltaV(double aDuration) const;
   double GetManeuverDuration(const UtCalendar& aEpoch, const WsfOrbitalManeuver& aManeuver, double aDeltaV) const;
   bool   PerformStagingOperation();
   const ut::CentralBody&  GetCentralBody() const;
   const ut::CentralPoint& GetCentralPoint() const;
   bool                    Maneuver(const UtCalendar& aEpoch, const UtVec3d& aCommandedDeltaV, UtVec3d& aActualDeltaV);
 
   virtual bool SetInitialPoint(double aLat, double aLon, double aAlt, double aSpeed, double aHeading);


   WSF_SPACE_DEPRECATED WsfGeoPoint GetInitialPositionLLA() const;
   UtVec3d                          GetInitialPositionECI() const;
   UtVec3d                          GetInitialPositionWCS() const;
   UtVec3d                          GetInitialVelocityECI() const;
   UtVec3d                          GetInitialVelocityWCS() const;
   const char* GetScriptClassName() const override;
 
   WsfSpatialDomain GetSpatialDomain() const override { return WSF_SPATIAL_DOMAIN_SPACE; }
 
   // IsExtrapolating here means that no propulsive forces are occurring.
   // While it is true that during Delta-V maneuver this isn't true, it is predominately so.
   bool IsExtrapolating() const override { return true; }

   const UtOrbitalPropagatorBase& GetPropagator() const { return *mPropagatorPtr; }

   UtOrbitalPropagatorBase& GetPropagator() { return *mPropagatorPtr; }

   const WsfOrbitalManeuvering& GetOrbitalManeuvering() const;

   bool InitializeOrbitalManeuvering(const UtCalendar& aEpoch);

   const WsfOrbitalEvent* GetCurrentMissionEvent() const;

   const WsfOrbitalMissionSequence& GetMissionEvents() const;

   void ScheduleMission(const UtCalendar& aEpoch, std::unique_ptr<WsfOrbitalMissionSequence> aMissionEventsPtr);

   void CancelMission();

   bool VerifyMission(const UtCalendar&                 aEpoch,
                      const WsfOrbitalMissionSequence&  aSequence,
                      wsf::space::verify::PreOperation  aPreVerifyOp  = wsf::space::verify::PreOperation{},
                      wsf::space::verify::PostOperation aPostVerifyOp = wsf::space::verify::PostOperation{}) const;

   bool VerifyMission(const UtCalendar& aEpoch) const;

   WsfAttitudeController& GetAttitudeController() { return *mAttitudePtr; }

   double GetSimTimeOfEpoch() const { return mSimTimeOfEpoch; }

   WsfScriptContext& GetScriptContext() { return *mContextPtr; }
 
   void UpdatePropagation(const UtCalendar& aEpoch);

   const UtCalendar& GetCurrentTime() const { return mPropagatorPtr->GetCurrentTime(); }

   double GetElementOutputUpdateInterval() const { return 600.0; }

   const std::string& GetDescriptor() const { return mPropagatorPtr->GetDescriptor(); }

   const std::string& GetDesignator() const { return mPropagatorPtr->GetDesignator(); }
 
   const ut::OrbitalState& GetInitialOrbitalState() const;
 
   double GetInitialHeading() const;

   void SetInitialOrbitalState(const ut::OrbitalState& aState) { mPropagatorPtr->SetInitialOrbitalState(aState); }
 
   bool GetFutureLocationWCS(double aSimTime, double aLocationWCS[3]) final;

   class SpaceModel : public WsfMover::KinematicModel
   {
   public:
      SpaceModel(double                                   aSimTime,
                 WsfStringId                              aModelTypeId,
                 std::unique_ptr<UtOrbitalPropagatorBase> aPropagatorPtr,
                 WsfDraw*                                 aDrawPtr = nullptr); // If we want to draw the trajectory.
 
      bool GetLocationXYZ(double aTime, double aLocXYZ[3]) const override;
 
      bool GetVelocityXYZ(double aTime, double aVelXYZ[3]) const override;
 
   protected:
      bool Update(double aSimTime) const;
 
      std::unique_ptr<UtOrbitalPropagatorBase> mPropagatorPtr;
      mutable UtCalendar                       mUpdateTime;
      mutable double                           mLastUpdateTime;
      mutable UtVec3d                          mLastLocXYZ;
      mutable UtVec3d                          mLastLocWCS;
      mutable UtVec3d                          mLastVelWCS;
   };
 
   WsfMover::KinematicModel* CreateKinematicModel(double       aSimTime,
                                                  WsfStringId  aModelTypeId,
                                                  const double aLocationWCS[3],
                                                  const double aVelocityWCS[3],
                                                  WsfMover*    aMoverPtr,
                                                  WsfDraw*     aDrawPtr) const override;

   void SetTargetOrientationECI(double aPsi, double aTheta, double aPhi);
 
   ut::optional<UtColor> GetOrbitColor() const { return mOrbitColor; }
   UtColor               GetOrbitColorValue() const { return mOrbitColor.value_or(UtColor(1, 1, 1)); }
   bool                  OrbitColorSet() const { return mOrbitColor.has_value(); }
   void                  UpdateColor(double aSimTime, const UtColor& aColor);
   void SetOrbitColor(const std::string& aOrbitColor) { SetOrbitColor(UtColor::GetColorMapping(aOrbitColor)); }
   void SetOrbitColor(const UtColor& aOrbitColor);
 
   bool IsTLEInputAllowed() const noexcept { return mTLE_InputAllowed; }
   void SetTLEInputAllowed(bool aTLE_InputAllowed) noexcept { mTLE_InputAllowed = aTLE_InputAllowed; }

   double GetLookAngleTo(const UtVec3d& aLocationWCS) const;

   double GetIncidenceAngle(const UtVec3d& aLocationWCS) const;

   double GetTargetElevationAngle(const UtVec3d& aLocationWCS) const;

   double GetSquintAngleTo(const UtVec3d& aLocationWCS) const;

   double GetDistanceToHorizon() const;

   double GetLookAngleToHorizon() const;
 
private:
   bool AddDeltaV(const UtVec3d& aDeltaV_ECI);
 
   ut::CloneablePtr<UtOrbitalPropagatorBase>   mPropagatorPtr;
   ut::CloneablePtr<WsfOrbitalManeuvering>     mManeuveringPtr;
   ut::CloneablePtr<WsfAttitudeController>     mAttitudePtr;
   ut::CloneablePtr<WsfConjunctionInput>       mConjunctionInputPtr;
   wsf::space::OrbitalMissionSimulationContext mMissionContext;
   double                                      mSimTimeOfEpoch{0.0};
   WsfScriptContext*                           mContextPtr;
   ut::OrbitalState                            mOrbitalState;
   ut::optional<UtColor>                       mOrbitColor;
 
   bool mTLE_InputAllowed{false};
};
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(WsfSpaceMoverBase, cWSF_COMPONENT_SPACE_MOVER)
 
#endif