WsfOrbitalEvent.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2016 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 WSFORBITALMISSIONEVENT_HPP
#define WSFORBITALMISSIONEVENT_HPP
 
#include "wsf_space_export.h"
 
#include "UtCalendar.hpp"
#include "UtCloneablePtr.hpp"
#include "UtException.hpp"
class UtInput;
class UtOrbitalPropagatorBase;
#include "UtScriptClassDefine.hpp"
#include "UtUnitTypes.hpp"
class WsfOrbitalEventVisitor;
#include "WsfSpaceOrbitalPropagatorCondition.hpp"
class WsfSpaceMoverBase;
class WsfScenario;
#include "WsfObject.hpp"
#include "WsfStringId.hpp"
#include "WsfUniqueId.hpp"
 
namespace wsf
{
namespace space
{
class OrbitalMissionContext;
 
} // namespace space
} // namespace wsf

class WSF_SPACE_EXPORT WsfOrbitalEvent : public WsfUniqueId, public WsfObject
{
public:
   WsfOrbitalEvent(const WsfOrbitalEvent& aSrc);
   WsfOrbitalEvent& operator=(const WsfOrbitalEvent&) = delete;
   ~WsfOrbitalEvent() override                        = default;

   WsfOrbitalEvent* Clone() const override = 0;
 
   static WsfOrbitalEvent* Create(const WsfScenario& aScenario, UtInput& aInput, bool aIgnoreSomeExceptions = false);
 
   bool         ProcessInput(UtInput& aInput) override;
   virtual bool Initialize(const UtCalendar& aEpoch, const wsf::space::OrbitalMissionContext& aContext);

   bool CanVerify() const { return mCanVerify; }
 
   virtual bool VerifyCondition() const;
 
   virtual bool EvaluatePreconditions(const wsf::space::OrbitalMissionContext& aContext) const;
 
   virtual bool EvaluatePostconditions(const wsf::space::OrbitalMissionContext& aContext) const;
 
   virtual bool ValidateParameterRanges(const std::string& aExecutingPlatformName) const;

   bool IsComplete() const { return mIsComplete; }

   bool IsCanceled() const { return mIsCanceled; }

   void SetCanceled() { mIsCanceled = true; }
 
   bool Execute(const UtCalendar& aEpoch, wsf::space::OrbitalMissionContext& aContext);
 
   const char* GetScriptClassName() const override { return "WsfOrbitalEvent"; }

   bool IsFinite() const { return mIsFinite; }

   void SetFinite(bool aIsFinite) { mIsFinite = aIsFinite; }

   bool HasExecuted() const { return mHasExecuted; }

   const wsf::space::OrbitalPropagatorCondition& GetCondition() const { return *mCondition; }

   wsf::space::OrbitalPropagatorCondition& GetCondition() { return *mCondition; }

   // Condition::Type GetConditionType() const { return mCondition.GetType(); }

   WsfStringId GetConditionString() const { return mCondition->GetConditionString(); }

   void SetCondition(std::unique_ptr<wsf::space::OrbitalPropagatorCondition> aConditionPtr)
   {
      mCondition = std::move(aConditionPtr);
   }
 
   // void SetConditionType(Condition::Type aConditionType) { mCondition.SetType(aConditionType); }

   const UtCalendar& GetStartTime() const { return mStartTime; }

   void SetStartTime(const UtCalendar& aStartTime) { mStartTime = aStartTime; }

   const UtCalendar& GetEvaluationTime() const { return mEvaluationTime; }

   UtTimeValue GetDuration() const { return mDuration; }
 
   void SetDuration(const UtTimeValue& aDuration);
   void SetOnlyDuration(const UtTimeValue& aDuration);

   UtTimeValue GetUpdateInterval() const { return mUpdateInterval; }

   void SetUpdateInterval(const UtTimeValue& aUpdateInterval) { mUpdateInterval = aUpdateInterval; }

   virtual const WsfOrbitalEvent* GetCurrentMissionEvent() const { return this; }

   virtual WsfOrbitalEvent* GetCurrentMissionEvent() { return this; }

   virtual WsfOrbitalEvent* AdvanceMissionEvent(const UtCalendar&                        aEpoch,
                                                const wsf::space::OrbitalMissionContext& aContext);

   class AdvanceMissionEventException : public UtException
   {
   public:
      AdvanceMissionEventException();
   };

   virtual bool IsSequence() const { return false; }

   virtual double GetRequiredDeltaV(const UtOrbitalPropagatorBase& aPropagator) const { return 0.0; }

   virtual double GetDeltaV() const { return 0.0; }

   virtual bool GetNextExecutionTime(const UtCalendar&              aCurrentTime,
                                     const UtOrbitalPropagatorBase& aPropagator,
                                     UtCalendar&                    aNextExecutionTime);
 
   virtual void Accept(WsfOrbitalEventVisitor* aVisitorPtr) = 0;
 
protected:
   explicit WsfOrbitalEvent(const WsfScenario& aScenario);
 
   virtual bool InitializeVariables(const UtCalendar&                        aCurrentTime,
                                    const UtCalendar&                        aEvaluationTime,
                                    const wsf::space::OrbitalMissionContext& aContext);
 
   virtual bool InitializeTimes(const UtCalendar& aEpoch, const wsf::space::OrbitalMissionContext& aContext);

   virtual bool ExecuteEvent(const UtCalendar& aCurrentTime, wsf::space::OrbitalMissionContext& aContext) = 0;
 
   virtual bool EvaluateCompletion(const UtCalendar& aEpoch, const UtOrbitalPropagatorBase& aPropagator);
 
   static WsfOrbitalEvent* Create(const WsfScenario& aScenario, WsfStringId aType);
 
   ut::CloneablePtr<wsf::space::OrbitalPropagatorCondition> mCondition{};
   bool                                                     mIsFinite;
   bool                                                     mHasExecuted;
   bool                                                     mIsComplete;
   bool                                                     mIsCanceled;
   bool                                                     mDebug;
   bool               mCanVerify; 
   UtCalendar         mStartTime;
   UtCalendar         mEvaluationTime;
   UtTimeValue        mDuration;
   UtTimeValue        mUpdateInterval;
   const WsfScenario& mScenario;
};
 
#endif