WsfPathList.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 WSFPATHLIST_HPP
#define WSFPATHLIST_HPP
 
#include "wsf_export.h"
 
#include <vector>
 
#include "UtEntity.hpp"
#include "UtLog.hpp"
#include "UtSphericalEarth.hpp"
#include "UtVec3.hpp"
#include "WsfPathState.hpp"

class WSF_EXPORT WsfPathList
{
public:
   class WSF_EXPORT Segment
   {
   public:
      Segment()
         : mInitialState()
         , mDuration(0.0)
         , mRollRate(0.0)
         , mIsApproximation(false)
      {
      }
      virtual ~Segment() = default;

      virtual void ComputeState(double aRelativeSimTime, WsfPathState& aState) = 0;

      virtual Segment* Clone() const = 0;

      void Initialize(double aDuration, const WsfPathState& aState)
      {
         mDuration     = aDuration;
         mInitialState = aState;
      }
 
      void SetRollRate(double aRollRate) { mRollRate = aRollRate; }

      const WsfPathState& GetInitialState() const { return mInitialState; }

      double GetDuration() const { return mDuration; }
      void SetDuration(double aDuration) { mDuration = aDuration; }

      virtual void Print(ut::log::MessageStream& aStream);

      WsfPathState mInitialState;
      double mDuration;
      double mRollRate;
      bool mIsApproximation;
   };

   class DynamicsData
   {
   public:
      DynamicsData()
         : mLinearAcceleration()
         , mClimbRate()
         , mFlightAngle()
      {
      }
      void SetLinearAcceleration(double aAcceleration) { mLinearAcceleration = aAcceleration; }
 
      void SetClimbRate(double aClimbRate) { mClimbRate = aClimbRate; }
 
      void SetFlightAngle(double aFlightAngle) { mFlightAngle = aFlightAngle; }
      double mLinearAcceleration;
      double mClimbRate;
      double mFlightAngle;
   };

   class RotationData
   {
   public:
      RotationData()
         : mRotationRadius(UtSphericalEarth::cEARTH_RADIUS)
      {
      }
 
      void InitializeRotation(UtVec3d aInitialLocationWCS, UtVec3d aRotationAxisWCS);
 
      void SetRotationRadius(double aEarthRadius) { mRotationRadius = aEarthRadius; }
      double mRotationRadius;
      UtVec3d mInitialLocationWCS;
      UtVec3d mRotationAxis;
      UtVec3d mInitialDirectionWCS;
   };

   class RotationArcSegment : public WsfPathList::Segment, public WsfPathList::RotationData
   {
   public:
      RotationArcSegment()
         : mRoll(0.0)
      {
      }
      Segment* Clone() const override { return new RotationArcSegment(*this); }
      void     ComputeState(double aRelativeSimTime, WsfPathState& aState) override;
      void     SetTargetRoll(double aRoll) { mRoll = aRoll; }
      void     Print(ut::log::MessageStream& aStream) override;
 
      double mRoll;
   };

   class RotationSegment : public WsfPathList::Segment, public WsfPathList::RotationData, public WsfPathList::DynamicsData
   {
   public:
      RotationSegment()
         : mRoll(0.0)
      {
      }
      Segment* Clone() const override { return new RotationSegment(*this); }
      void     ComputeState(double aRelativeSimTime, WsfPathState& aState) override;
      void     SetTargetRoll(double aRoll) { mRoll = aRoll; }
      void     Print(ut::log::MessageStream& aStream) override;
 
      double mRoll;
   };

   class WSF_EXPORT PauseSegment : public WsfPathList::Segment
   {
   public:
      Segment* Clone() const override { return new PauseSegment(*this); }
      void     ComputeState(double aRelativeSimTime, WsfPathState& aState) override { aState = mInitialState; }
      void     Print(ut::log::MessageStream& aStream) override;
   };
 
   typedef std::vector<Segment*> SegmentList;
 
   WsfPathList();
   WsfPathList(const WsfPathList& aSrc);
   ~WsfPathList();
   WsfPathList& operator=(const WsfPathList& aRhs) = delete;

   void GetState(double aRelativeSimTime, WsfPathState& aState);

   void Reset();

   void Append(Segment* aSegmentPtr);

   void Append(Segment* aSegmentPtr, const WsfPathState& aEndState);
 
   void Append(double aDuration, WsfPathList& aPathList);
 
   void PopBack();
 
   double GetDuration() const;
 
   double GetEndStateValid() { return mEndStateValid; }

   bool Empty() const { return mSegments.empty(); }

   const WsfPathState& GetEndState();

   void SetEndState(WsfPathState& aState)
   {
      mEndState      = aState;
      mEndStateValid = true;
   }

   const SegmentList& GetSegments() const { return mSegments; }
 
   void PrintPath(ut::log::MessageStream& aStream);
 
 
private:
   void GetStateP(double aRelativeSimTime, WsfPathState& aState);
 
   double                mDuration;
   int                   mLastSegmentIndex;
   double                mLastSegmentStartTime;
   std::vector<Segment*> mSegments;
   WsfPathState          mEndState;
   bool                  mEndStateValid;
};
 
#endif