WsfDisPlatform.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 WSFDISPLATFORM_HPP
#define WSFDISPLATFORM_HPP
 
#include "wsf_export.h"
 
#include <list>
#include <map>
#include <memory>
#include <utility>
#include <vector>
 
class DisBeam;
class DisEmission;
#include "DisEntityState.hpp"
class DisEventId;
#include "ext/WsfExtEntityDeadReckon.hpp"
class DisSystem;
#include "UtVec3.hpp"
#include "WsfComponent.hpp"
class WsfDisArticulatedPart;
class WsfDisInterface;
 
#include "WsfExchange.hpp"
 
class WsfPlatform;
#include "WsfSensor.hpp"
class WsfTrack;
#include "WsfTrackId.hpp"
 
class WsfDisPlatform;
 
namespace wsf
{
namespace comm
{
class Comm;
class Result;
} // namespace comm
} // namespace wsf
 
class WSF_EXPORT WsfDisPlatformComponent : public WsfComponentT<WsfDisPlatform>
{
public:
   virtual void SendingEmission(double aSimTime, DisEmission* aEmissionPtr, DisEventId& aPreviousNumber) {}
   virtual void TurnOffEmission(DisEmission* aEmissionPtr) {}
   virtual void AllocateEmissionSystems(DisUint8& emitterId) {}
};
 

 
class WSF_EXPORT WsfDisPlatform
{
public:
   using Component     = WsfDisPlatformComponent;
   using ComponentList = WsfComponentListT<WsfDisPlatformComponent>;
 
   enum PDUTypeType
   {
      cPDUTYPE_NOT_DEFINED  = 0x00000000,
      cPDUTYPE_SIGNAL       = 0x00000010,
      cPDUTYPE_EMISSION     = 0x00000020,
      cPDUTYPE_ENTITY_STATE = 0x00000040,
      cPDUTYPE_TRANSMITTER  = 0x00000080
   };
 
   WsfDisPlatform(double                          aSimTime,
                  WsfPlatform*                    aPlatformPtr,
                  WsfDisInterface*                aInterfacePtr,
                  std::unique_ptr<DisEntityState> aEntityStatePtr,
                  const DisEntityId&              aEntityId,
                  const DisEntityType&            aEntityType,
                  bool                            aIsIncomingTransfer,
                  bool                            aIsOutgoingTransfer);
 
   ~WsfDisPlatform();



   WsfPlatform* GetPlatform() const { return mPlatformPtr; }

   void CreateEmission(double aSimTime, const DisEntityId& aDisEntityId);

   bool IsIncomingTransfer() const { return mIsIncomingTransfer; }

   bool HasBeenReplaced() const { return mHasBeenReplaced; }

   void SetHasBeenReplaced(bool aHasBeenReplaced) { mHasBeenReplaced = aHasBeenReplaced; }

   const DisEntityId& GetEntityId() const { return mEntityStatePtr->GetEntityId(); }

   const DisEntityType& GetEntityType() const { return mEntityStatePtr->GetEntityType(); }

   DisUint8 GetForceId() const { return mEntityStatePtr->GetForceId(); }
 
   WsfPlatform* GetShadowPlatform() const { return mShadowPlatformPtr; }
   void         SetShadowPlatform(WsfPlatform* aPlatformPtr) { mShadowPlatformPtr = aPlatformPtr; }

 
   WsfDisInterface* GetInterface() const { return mInterfacePtr; }
 
   void AddComponent(Component* aComponentPtr) { mComponents.AddComponent(aComponentPtr); }
 
   const ComponentList& GetComponents() const { return mComponents; }


 
   int AddArticulation(int aType, int aParentType, unsigned int aPublishBitmap, WsfArticulatedPart* aPartPtr, int aStartCount);
 
   void ForceUpdate(double aSimTime);
 
   void GetEntityState(double& aEntityStateUpdateTime, DisEntityState*& aEntityStatePtr);
 
   void SetEntityState(double aSimTime, DisEntityState* aEntityStatePtr);

   DisEntityState* GetEntityState() { return mEntityStatePtr.get(); }

   double GetEntityStateUpdateTime() const { return mEntityStateUpdateTime; }

   void SetEntityStateUpdateTime(double aSimTime) { mEntityStateUpdateTime = aSimTime; }

   double GetLastTimeEntityStateSent() const { return mLastTimeEntityStateSent; }

   double GetInitialDistributionTime() const { return mInitialDistributionTime; }

   double GetLastTimeMoverUpdated() const { return mLastTimeMoverUpdated; }



 
   bool GetEmissionPDU() const { return mSendEmissionPDU; }
   void SendEmissionsPDU(double aSimTime);
 
   DisSystem* GetSensorSystem(WsfSensor* aSensorPtr);

   using SB_Key             = std::pair<unsigned char, unsigned char>;
   using SB_MapType         = std::map<SB_Key, unsigned int>;
   using SB_MapTypeIterator = std::map<SB_Key, unsigned int>::iterator;
   using SB_MapTypePair     = std::pair<SB_Key, unsigned int>;
 
   unsigned char GetPartIdToBeamId(unsigned int aUniqueId);
 
   unsigned int GetSysBeamIdToPartId(SB_Key aSB_Key);
   void         SetSysBeamIdToPartId(SB_Key aSB_Key, unsigned int aUniqueId);


 
   void Comment(double aSimTime, const std::string& aComment);
 
   void CommFrequencyChanged(double aSimTime, wsf::comm::Comm* aCommPtr);
   void CommTurnedOff(double aSimTime, wsf::comm::Comm* aCommPtr);
   void CommTurnedOn(double aSimTime, wsf::comm::Comm* aCommPtr);
 
 
   void MessageReceived(double             aSimTime,
                        wsf::comm::Comm*   aXmtrPtr,
                        wsf::comm::Comm*   aRcvrPtr,
                        const WsfMessage&  aMessage,
                        wsf::comm::Result& aResult);
 
   void MessageTransmitted(double aSimTime, wsf::comm::Comm* aCommPtr, const WsfMessage& aMessage);
 
   void MoverUpdated(double aSimTime, WsfExtEntityDeadReckon::PlatformDR& aDeadReckonData);
 
   void PlatformDeleted(double aSimTime);
 
   void PlatformInitialized(double aSimTime);
 
   void SensorDetectionChanged(double aSimTime, WsfSensor* aSensorPtr, size_t aTargetPlatformIndex, WsfSensorResult& aResult);
 
   void SensorFrequencyChanged(double aSimTime, WsfSensor* aSensorPtr, WsfSensorMode* aModePtr);
 
   void SensorModeActivated(double aSimTime, WsfSensor* aSensorPtr, WsfSensorMode* aModePtr);
 
   void SensorModeDeactivated(double aSimTime, WsfSensor* aSensorPtr, WsfSensorMode* aModePtr);
 
   void SensorRequestCanceled(double aSimTime, WsfSensor* aSensorPtr, const WsfTrack* aTrackPtr);
 
   void SensorRequestInitiated(double aSimTime, WsfSensor* aSensorPtr, WsfSensorMode* aModePtr, const WsfTrack* aTrackPtr);
 
   void SensorRequestUpdated(double aSimTime, WsfSensor* aSensorPtr, WsfSensorMode* aModePtr, const WsfTrack* aTrackPtr);
 
   void SensorScanUpdated(double aSimTime, WsfSensor* aSensorPtr);
 
   void SensorTrackDropped(double aSimTime, WsfSensor* aSensorPtr, const WsfTrack* aTrackPtr);
 
   void SensorTrackInitiated(double aSimTime, WsfSensor* aSensorPtr, const WsfTrack* aTrackPtr);
 
   void SensorTurnedOff(double aSimTime, WsfSensor* aSensorPtr);
   void SensorTurnedOn(double aSimTime, WsfSensor* aSensorPtr);
 
   void ResetEntityId(const DisEntityId& aDisEntityId);
 
   void SetEntityId(const DisEntityId& aDisEntityId);




   bool PlatformBeingTracked(DisEntityId& anEntityId);
   bool GetSendDis() const { return mSendDis; }
   void SetSendDis(bool aFlag) { mSendDis = aFlag; }
   void SetSendTransmitterPdus(bool aFlag) { mSendTransmitterPdus = aFlag; }

   WsfExchange::Query* GetQueryPtr() { return mQueryPtr.get(); }
   WSF_DEPRECATED void SetQueryPtr(WsfExchange::Query* aQueryPtr);
   void                SetQueryPtr(std::unique_ptr<WsfExchange::Query> aQueryPtr);


   void SetDoExtrapolate(bool aFlag) { mDoExtrapolate = aFlag; }
 
   void TrySendCMEData(double simTime);
 
   void SendOrQueueEmissionsPDU(double aSimTime);
 
   // Allow applications to set SendDIS status of platform at creation time.
   using InitialSendDisStatusCallback = UtCallbackListN<void(WsfDisPlatform*, bool&)>;
   static InitialSendDisStatusCallback InitialSendDisStatus;
 
private:
   class TrackingRequest
   {
   public:
      WsfTrackId  mTrackId;
      size_t      mTargetIndex;
      WsfStringId mModeNameId;
   };

   class SensorData
   {
   public:
      SensorData(WsfSensor* aSensorPtr, DisSystem* aSystemPtr)
         : mSensorPtr(aSensorPtr)
         , mSystemPtr(aSystemPtr)
         , mScanUpdateTime(-1.0)
         , mScanFraction(0.0)
         , mScanRate(0.0)
         , mBeamList()
         , mBeamModeName()
         , mDetectBeamPtr(nullptr)
         , mDetectList()
         , mTrackList()
         , mTrackingRequestList()
         , mLastBeamCountSent(0)
      {
      }
 
      WsfSensor* mSensorPtr;
      DisSystem* mSystemPtr;
      double mScanUpdateTime;
      double mScanFraction;
      double mScanRate;
 
      std::vector<DisBeam*> mBeamList;
      std::vector<WsfStringId> mBeamModeName;
 
      DisBeam* mDetectBeamPtr;

      std::list<DisEntityId> mDetectList;

      std::list<DisEntityId> mTrackList;

      std::list<TrackingRequest> mTrackingRequestList;

      DisUint8 mLastBeamCountSent;
   };
 
   class SendInitialCMEDataEvent : public WsfEvent
   {
   public:
      SendInitialCMEDataEvent(double aSimTime, WsfDisInterface* aInterfacePtr, const DisEntityId& aEntityId);
 
      EventDisposition Execute() override;
 
   private:
      WsfDisInterface* mInterfacePtr;
      DisEntityId      mEntityId;
   };
 
   struct SimpleAccelerationData
   {
      SimpleAccelerationData()
         : mLastUpdate(0)
      {
      }
      double  mLastUpdate;
      UtVec3d mPastVelocity;
      UtVec3d mPastOrientationWCS;
   };
 
   SensorData* GetSensorData(WsfSensor* aSensorPtr);
 
   void MarkSensorAsOff(SensorData& aSensorData);
 
   void RebuildTrackJamLists(SensorData& aSensorData);
 
   unsigned char SetPartIdToBeamIdP(unsigned int aUniqueId);
 
   void SendInitialCMEData(double aSimTime);
 
   void UpdateBeamConfiguration(double aSimTime, SensorData& aSensorData);
 
   void UpdateBeamsWithSweepPosition(double aSimTime, SensorData& aSensorData);
 
   void UpdateBeamsWithTrackingRequests(SensorData& aSensorData);
 
   void UpdateSensorUpdateList(double aSimTime);
 
   void UpdateSystemFromSensor(SensorData& aSensorData);
 
   bool UpdateTrackingRequestList(double aSimTime, SensorData& aSensorData, WsfSensorMode* aModePtr, const WsfTrack* aTrackPtr);
 
   void UpdateSimpleAccelerations(double                              aSimTime,
                                  WsfExtEntityDeadReckon::PlatformDR& aDeadReckonData,
                                  bool                                aDeadReckonChange);
 
   // The heartbeat timer differs depending on how many times an entity state has
   // been sent:
   //
   // a) It is zero when an entity state has yet to be sent.  This forces the
   //    entity state to be sent on the first call to MoverUpdated.
   // b) After MoverUpdate has been called once, it is set to a random value that
   //    is some fraction of the DIS heartbeat timer.  This spreads entity state
   //    updates out for non-moving or very slow moving entities.
   // c) On the second and subsequent updates it will be the DIS heartbeat timer
   //    +/- 10%.  Again, this prevents clustering of updates.
 
   double mHeartbeatTimer;
 
   double mHeartbeatTimerOverride;
   DisEmission* mEmissionPtr;

   std::unique_ptr<DisEntityState> mEntityStatePtr;

   double mEntityStateUpdateTime;

   std::unique_ptr<DisEntityState> mPlaybackEntityStatePtr;

   double mPlaybackEntityStateUpdateTime;

   WsfDisInterface* mInterfacePtr;

   double mLastTimeEmissionSent;

   double mLastTimeEntityStateSent;

   double mLastTimeMoverUpdated;

   double mInitialDistributionTime;

   SimpleAccelerationData* mSimpleAccelerationDataPtr;

   WsfPlatform* mPlatformPtr;

   bool mIsIncomingTransfer;

   bool mIsOutgoingTransfer;

   bool mHasBeenReplaced;

   bool mSendEmissionPDU;

   bool mScheduledInitialCMEData;

   WsfPlatform* mShadowPlatformPtr;
 
   std::vector<WsfDisArticulatedPart*> mArticulatedPartList;
 
   using IdMap         = std::map<unsigned int, unsigned char>;
   using IdMapIterator = std::map<unsigned int, unsigned char>::iterator;
   using IdMapPair     = std::pair<unsigned int, unsigned char>;
 
   IdMap      mPartIdToBeamIdMap;
   SB_MapType mSysBeamToPartIdMap;
 
   std::vector<SensorData> mSensors;

   bool mSendDis;
   bool mSendTransmitterPdus;
   bool mEntityStateSent;
   bool mFirstUpdate;
   bool mSendEmissionPdu;
   bool mDoExtrapolate;
 
   std::unique_ptr<WsfExchange::Query> mQueryPtr{nullptr};
 
   ComponentList mComponents;
};
 
#endif