WsfExtEntityDeadReckon.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.
// ****************************************************************************
 
 
#ifndef WSFEXTENTITYDEADRECKON_HPP
#define WSFEXTENTITYDEADRECKON_HPP
 
#include "wsf_export.h"
 
#include <map>
 
#include "UtCallback.hpp"
#include "UtCallbackHolder.hpp"
#include "WsfEvent.hpp"
 
class UtInput;
class WsfMover;
class WsfPlatform;
class WsfExtInterface;
 
 
struct WSF_EXPORT WsfExtEntityDeadReckonSetup
{
   WsfExtEntityDeadReckonSetup();
   bool   mDR_ServiceRequested;
   double mHeartbeatTimer;
   double mMoverUpdateTimer;
   double mInitialDistributionInterval;
 
   double mEntityPositionThreshold;
   double mEntityOrientationThreshold;
};

class WSF_EXPORT WsfExtEntityDeadReckon : public WsfExtEntityDeadReckonSetup
{
public:
   WsfExtEntityDeadReckon(WsfExtInterface* aExtInterfacePtr);
 
   void Initialize();
 
   bool ProcessInput(UtInput& aInput);
 
   void RequestService(bool aHeartbeatRequired);
 
   void ForceUpdate(double aSimTime, WsfPlatform* aPlatformPtr, bool aForceSend = false);
 
   void RequireExternalEntities(bool aExternalEntitiesRequired);

   void UseInitialDistributionInterval() { mUseInitialDistrubutionInterval = true; }

   double GetHeartbeatTimer() const { return mHeartbeatTimer; }

   void SetHeartbeatTimerOverride(double aTime) { mHeartbeatTimerOverride = aTime; }

   double GetEntityOrientationThreshold() const { return mEntityOrientationThreshold; }

   double GetEntityPositionThreshold() const { return mEntityPositionThreshold; }
 
   double GetInitialDistributionInterval() const { return mInitialDistributionInterval; }

   void SetInitialDistributionInterval(double aValue) { mInitialDistributionInterval = aValue; }
 
   double GetMoverUpdateTimer() const { return mMoverUpdateTimer; }
   void   SetMoverUpdateTimer(double aMoverUpdateTimer) { mMoverUpdateTimer = aMoverUpdateTimer; }

   struct DR_State
   {
      DR_State();
      void LoadFromPlatform(double aSimTime, WsfPlatform& aPlatform);
      void Extrapolate(double aDeltaTime, WsfPlatform& aPlatform, DR_State& aExtrapState);
 
      double mLocationWCS[3];
      double mVelocityWCS[3];
      double mAccelerationWCS[3];
      double mOrientationWCS[3];
      double mPastOrientationWCS[3];
      double mAngularRateWCS[3];
      double mPastAngularRateWCS[3];
   };
 
   enum UpdateType
   {
      cNO_CHANGE = 0,
      cDR_CHANGE = 1,
      cHEARTBEAT = 2
   };

   class PlatformDR
   {
   public:
      PlatformDR(double aSimTime, WsfPlatform* aPlatformPtr);
      PlatformDR();
 
      bool         mInitialized;
      bool         mIsUpdated;
      UpdateType   mLastUpdateType;
      double       mLastSendTime;
      double       mLastTimeMoverUpdate;
      double       mHeartbeatTimer;
      WsfPlatform* mPlatformPtr;
      // State before MoverUpdated was last called with 'true'
      DR_State mSentState;
      // State before MoverUpdated was last called
      DR_State mUpdatedState;
   };

   UtCallbackListN<void(double, PlatformDR&)> DeadReckonChanged;

   UtCallbackListN<void(double, PlatformDR&)> MoverUpdated;
 
private:
   void UpdateDeadReckon(double aSimTime, WsfPlatform* aPlatformPtr, bool aForceUpdate);
 
   bool IsStateAccurate(double aSimTime, PlatformDR& aState, bool aForceUpdate);
 
   void HandlePlatformDeleted(double aSimTime, WsfPlatform* aPlatformPtr);
   void HandlePlatformAdded(double aSimTime, WsfPlatform* aPlatformPtr);
   void HandleMoverUpdated(double aSimTime, WsfMover* aMoverPtr);
 
   double HandleHeartbeat(double aSimTime, size_t aPlatformIndex);
 
   double CalculateHeartbeatTimer(double aAverageHeartbeatTimer, double aMultiplier) const;

   class HeartbeatEvent : public WsfEvent
   {
   public:
      HeartbeatEvent() = delete;
      HeartbeatEvent(double aSimTime, WsfExtEntityDeadReckon* aExtPtr, size_t aPlatformIndex)
         : WsfEvent(aSimTime)
         , mExtPtr(aExtPtr)
         , mPlatformIndex(aPlatformIndex)
      {
      }
      EventDisposition Execute() override;
 
      WsfExtEntityDeadReckon* mExtPtr;
      size_t                  mPlatformIndex;
   };
 
   UtCallbackHolder mCallbacks;
 
   std::map<size_t, PlatformDR> mDeadReckonData;
   bool                         mExternalEntitiesRequired;
   bool mHeartbeatRequired;
 
   bool   mInitialized;
   bool   mUseSimpleExtrapolations;
   bool   mUseInitialDistrubutionInterval;
   double mHeartbeatTimerOverride;
   double mInitialDistributionStart;
 
   WsfExtInterface* mExtInterfacePtr;
};
 
#endif