WsfSpaceOrbitalMissionSimulationContext.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2021 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 WSFSPACEORBITALMISSIONSIMULATIONCONTEXT_HPP
#define WSFSPACEORBITALMISSIONSIMULATIONCONTEXT_HPP
 
#include "UtCloneablePtr.hpp"
class UtInput;
 
#include "WsfEvent.hpp"
#include "WsfOrbitalMissionSequence.hpp"
class WsfSpaceMoverBase;
#include "WsfSpaceOrbitalMissionContext.hpp"
 
namespace wsf
{
namespace space
{

class OrbitalMissionSimulationContext : public OrbitalMissionContext
{
public:
   explicit OrbitalMissionSimulationContext(WsfSpaceMoverBase& aMover);
   OrbitalMissionSimulationContext(WsfSpaceMoverBase& aMover, const OrbitalMissionSimulationContext& aOther);
   OrbitalMissionSimulationContext(const OrbitalMissionSimulationContext& aOther) = delete;
   ~OrbitalMissionSimulationContext() override                                    = default;
 
   void                           Update(const UtCalendar& aEpoch) override;
   bool                           Initialize(const UtCalendar& aEpoch) override;
   const UtOrbitalPropagatorBase& GetPropagator() const override;
   WsfSimulation*                 GetSimulation() const override;
   WsfSpaceMoverBase*             GetSpaceMover() const override;
   void   InitiateMissionEvent(const UtCalendar& aEpoch, const WsfOrbitalEvent& aMissionEvent) const override;
   void   UpdateMissionEvent(const UtCalendar& aEpoch, const WsfOrbitalEvent& aMissionEvent) const override;
   void   CompleteMissionEvent(const UtCalendar& aEpoch, const WsfOrbitalEvent& aMissionEvent) const override;
   void   CancelMissionEvent(const UtCalendar& aEpoch, const WsfOrbitalEvent& aMissionEvent) const override;
   bool   Maneuver(const UtCalendar& aEpoch, const UtVec3d& aCommandedDeltaV, UtVec3d& aActualDeltaV) const override;
   double GetAvailableDeltaV() const override;
   double GetRequiredDeltaV(double aDuration) const override;
   bool   PerformStagingOperation() const override;
   std::string GetName() const override;
   double GetManeuverDuration(const UtCalendar& aEpoch, const WsfOrbitalManeuver& aManeuver, double aDeltaV) const override;
 
   // Methods specific to the simulation context

   bool ProcessInput(UtInput& aInput);
 
   UtCalendar GetLastUpdateTime() const { return mLastUpdateTime; }

   void Schedule(WsfOrbitalEvent* aMissionEventPtr);

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

   const WsfOrbitalMissionSequence& GetMissionEvents() const;
 
private:
   class Event : public WsfEvent
   {
   public:
      Event(WsfOrbitalEvent* aMissionEventPtr, OrbitalMissionSimulationContext& aContext);
      ~Event() override = default;
      WsfEvent::EventDisposition Execute() override;
 
   private:
      WsfOrbitalEvent*                             mMissionEventPtr;
      wsf::space::OrbitalMissionSimulationContext& mContext;
      UtCalendar                                   mTime;          // Absolute value of event time from GetTime().
      size_t                                       mPlatformIndex; // to verify future platform validity
      size_t                                       mMissionEventId;
   };

   class SetEvents : public WsfEvent
   {
   public:
      SetEvents(const UtCalendar&                          aEpoch,
                std::unique_ptr<WsfOrbitalMissionSequence> aMissionEventsPtr,
                OrbitalMissionSimulationContext&           aContext);
      ~SetEvents() override = default;
      WsfEvent::EventDisposition Execute() override;
 
   private:
      UtCalendar                                 mEpoch;
      std::unique_ptr<WsfOrbitalMissionSequence> mMissionEventsPtr;
      OrbitalMissionSimulationContext&           mContext;
   };

   const WsfOrbitalEvent* GetCurrentMissionEvent() const;

   void ScheduleNextMissionEvent(const UtCalendar& aEpoch);
 

   bool ScheduleMissionP(const UtCalendar& aEpoch, std::unique_ptr<WsfOrbitalMissionSequence> aMissionEventsPtr);

   bool IsReportable(const WsfOrbitalEvent& aOrbitalEvent) const;
 
   WsfSpaceMoverBase&                          mMover; 
   UtCalendar                                  mLastUpdateTime{};
   ut::CloneablePtr<WsfOrbitalMissionSequence> mMissionEventsPtr;
};
 
} // namespace space
} // namespace wsf
 
#endif // WSFSPACEORBITALMISSIONSIMULATIONCONTEXT_HPP