WsfTargetPointOptions.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2020 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 WSFTARGETPOINTOPTIONS_HPP
#define WSFTARGETPOINTOPTIONS_HPP
 
#include <sstream>
#include <stdexcept>
#include <type_traits>
 
#include "UtCloneablePtr.hpp"
#include "UtLog.hpp"
class UtInput;
#include "wsf_space_export.h"
 
#include "UtOrbitalPropagatorBase.hpp"
#include "WsfLibrationPoint.hpp"
#include "WsfLibrationTargetPoint.hpp"
#include "WsfOrbitalManeuver.hpp"
#include "WsfOrbitalReferenceFrame.hpp"
#include "WsfOrbitalTargetPoint.hpp"
#include "WsfPropagatorTargetPoint.hpp"
#include "WsfSimulation.hpp"
#include "WsfTrackId.hpp"
 
namespace wsf
{
namespace space
{

class WSF_SPACE_EXPORT TargetPointOptions
{
public:
   explicit TargetPointOptions(const WsfTrackId& aLocalTrackId);
   TargetPointOptions(LibrationPoint::System aSystem, LibrationPoint::Point aPoint);
   TargetPointOptions(const UtVec3d& aPosition, const UtVec3d& aVelocity);
   TargetPointOptions(const TargetPointOptions& aOther) = default;
   ~TargetPointOptions()                                = default;
 
   enum class Type
   {
      cPLATFORM,
      cTRACK,
      cLIBRATION_POINT,
      cPROVIDED_TARGET,
      cKINEMATIC_STATE,
   };
 
   bool ProcessInput(UtInput& aInput);
 
   std::unique_ptr<OrbitalTargetPoint> InstantiatePoint(const UtCalendar& aEpoch) const;

   bool HasPlatformTarget() const { return mTargetType == Type::cPLATFORM; }

   bool HasTrackTarget() const { return mTargetType == Type::cTRACK; }

   bool HasLibrationPointTarget() const { return mTargetType == Type::cLIBRATION_POINT; }

   bool HasProvidedTarget() const { return mTargetType == Type::cPROVIDED_TARGET; }

   bool HasKinematicStateTarget() const { return mTargetType == Type::cKINEMATIC_STATE; }

   bool IsValid() const;

   bool HasPositionOffset() const { return mHasPositionOffset; }

   bool HasVelocityOffset() const { return mHasVelocityOffset; }

   bool HasKinematicOffset() const { return HasPositionOffset() || HasVelocityOffset(); }

   const UtVec3d& GetPositionOffset() const { return mPositionOffset; }

   const UtVec3d& GetVelocityOffset() const { return mVelocityOffset; }

   const std::string& GetPositionOffsetUnits() const { return mPositionOffsetUnits; }

   const std::string& GetVelocityOffsetUnits() const { return mVelocityOffsetUnits; }

   wsf::space::OrbitalReferenceFrame GetPositionOffsetFrame() const { return mPositionOffsetFrame; }

   wsf::space::OrbitalReferenceFrame GetVelocityOffsetFrame() const { return mVelocityOffsetFrame; }

   UtVec3d GetPositionOffsetInUnits() const;

   UtVec3d GetVelocityOffsetInUnits() const;

   const std::string& GetPlatformName() const { return mPlatformName; }

   const WsfTrackId& GetLocalTrackId() const { return mLocalTrackId; }

   wsf::space::LibrationPoint::System GetLP_System() const { return mLP_System; }

   wsf::space::LibrationPoint::Point GetLP_Point() const { return mLP_Point; }

   const UtVec3d& GetKinematicStatePosition() const { return mKinematicStatePosition; }

   UtVec3d GetKinematicStatePositionInUnits() const;

   const std::string& GetKinematicStatePositionUnits() const { return mKinematicStatePositionUnits; }

   const UtVec3d& GetKinematicStateVelocity() const { return mKinematicStateVelocity; }

   UtVec3d GetKinematicStateVelocityInUnits() const;

   const std::string& GetKinematicStateVelocityUnits() const { return mKinematicStateVelocityUnits; }

   const UtOrbitalPropagatorBase* GetTargetPropagator() const { return mTargetPropagator.get(); }

   void SetPositionOffset(const UtVec3d&                    aOffset,
                          const std::string&                aOffsetUnits,
                          wsf::space::OrbitalReferenceFrame aOffsetFrame);

   void SetVelocityOffset(const UtVec3d&                    aOffset,
                          const std::string&                aOffsetUnits,
                          wsf::space::OrbitalReferenceFrame aOffsetFrame);

   void ClearPositionOffset();

   void ClearVelocityOffset();

   bool HasOffsetTime() const { return mHasOffsetTime; }

   const UtTimeValue& GetOffsetTime() const { return mOffsetTime; }

   void SetOffsetTime(const UtTimeValue& aTimeOffset);

   void ClearOffsetTime();

   bool HasLagTime() const { return mHasLagTime; }

   const UtTimeValue& GetLagTime() const { return mLagTime; }

   void SetLagTime(const UtTimeValue& aLagTime);

   void ClearLagTime();

   void SetPlatformName(const std::string& aPlatformName);

   void SetLocalTrackId(const WsfTrackId& aTrackId);

   void SetLibrationPoint(wsf::space::LibrationPoint::System aSystem, wsf::space::LibrationPoint::Point aPoint);

   void SetTargetPoint(std::unique_ptr<wsf::space::OrbitalTargetPoint> aTargetPoint);

   void SetKinematicState(const UtVec3d&     aPositionInertial,
                          const std::string& aPositionUnits,
                          const UtVec3d&     aVelocityInertial,
                          const std::string& aVelocityUnits);

   bool RequiresTargetPropagator() const { return mTargetType == Type::cPLATFORM || mTargetType == Type::cTRACK; }

   void SetTargetPropagator(std::unique_ptr<UtOrbitalPropagatorBase> aTargetPropagatorPtr)
   {
      mTargetPropagator = std::move(aTargetPropagatorPtr);
   }

   bool RequiresManeuveringPropagator() const { return HasLagTime() || HasOffsetTime(); }

   void SetManeuveringPropagator(std::unique_ptr<UtOrbitalPropagatorBase> aManeuveringPropagatorPtr)
   {
      mManeuveringPropagator = std::move(aManeuveringPropagatorPtr);
   }

   bool ValidateParameterRanges(const std::string& aExecutingPlatformName, const std::string& aManeuverType) const;

   static bool ValidOffsetFrame(wsf::space::OrbitalReferenceFrame aFrame);
 
private:
   std::unique_ptr<OrbitalTargetPoint> FormInitialTarget(const UtCalendar& aEpoch) const;
   std::unique_ptr<OrbitalTargetPoint> FormOffsetTarget(std::unique_ptr<OrbitalTargetPoint> aPointPtr) const;
   std::unique_ptr<OrbitalTargetPoint> FormKinematicOffsetTarget(std::unique_ptr<OrbitalTargetPoint> aTargetPtr) const;
 
   Type                               mTargetType{Type::cTRACK};
   UtVec3d                            mPositionOffset{};
   std::string                        mPositionOffsetUnits{};
   wsf::space::OrbitalReferenceFrame  mPositionOffsetFrame{wsf::space::OrbitalReferenceFrame::cUNKNOWN};
   UtVec3d                            mVelocityOffset{};
   std::string                        mVelocityOffsetUnits{};
   wsf::space::OrbitalReferenceFrame  mVelocityOffsetFrame{wsf::space::OrbitalReferenceFrame::cUNKNOWN};
   UtTimeValue                        mOffsetTime{0.0};
   UtTimeValue                        mLagTime{0.0};
   std::string                        mPlatformName{};
   WsfTrackId                         mLocalTrackId{};
   wsf::space::LibrationPoint::System mLP_System{wsf::space::LibrationPoint::System::cUNKNOWN};
   wsf::space::LibrationPoint::Point  mLP_Point{wsf::space::LibrationPoint::Point::cUNKNOWN};
   UtVec3d                            mKinematicStatePosition{};
   std::string                        mKinematicStatePositionUnits{};
   UtVec3d                            mKinematicStateVelocity{};
   std::string                        mKinematicStateVelocityUnits{};
   mutable ut::CloneablePtr<wsf::space::OrbitalTargetPoint> mTargetPoint{nullptr};
   mutable ut::CloneablePtr<UtOrbitalPropagatorBase>        mTargetPropagator{nullptr};
   ut::CloneablePtr<UtOrbitalPropagatorBase>                mManeuveringPropagator{nullptr};
   bool                                                     mHasPositionOffset{false};
   bool                                                     mHasVelocityOffset{false};
   bool                                                     mHasOffsetTime{false};
   bool                                                     mHasLagTime{false};
};
 
} // namespace space
} // namespace wsf
 
#endif // WSFTARGETPOINTOPTIONS_HPP