WsfSensor.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 WSFSENSOR_HPP
#define WSFSENSOR_HPP
 
#include "wsf_export.h"
 
#include <memory>
#include <vector>
 
class UtInput;
#include "UtQuaternion.hpp"
#include "UtRandom.hpp"
#include "WsfArticulatedPart.hpp"
#include "WsfCategoryList.hpp"
#include "WsfComponentList.hpp"
class WsfEM_Rcvr;
class WsfEM_Xmtr;
#include "WsfEvent.hpp"
#include "WsfMeasurement.hpp"
class WsfMessage;
class WsfPlatform;
class WsfSensor;
#include "WsfSensorComponent.hpp"
class WsfSensorMode;
class WsfSensorModeList;
class WsfSensorResult;
class WsfSensorScheduler;
class WsfSensorTracker;
class WsfSingleSensorObserver;
class WsfTrack;
class WsfTrackId;
#include "WsfTrackListFwd.hpp"
#include "script/WsfScriptContext.hpp"

class WSF_EXPORT WsfSensor : public WsfArticulatedPart
{
public:
   using Result = WsfSensorResult;

   enum
   {

      cACTIVE = 0x00000001,
      cSEMI_ACTIVE = 0x00000002,
      cPASSIVE = 0x00000004,


      cRADIO    = 0x00000010, 
      cINFRARED = 0x00000020, 
      cVISUAL   = 0x00000040, 
      cACOUSTIC = 0x00000080, 


      cIMAGING = 0x00001000 
   };

   class WSF_EXPORT Settings
   {
   public:
      Settings()
         : mModeIndex(0)
         , mRequiredPd(0.0)
         , mLockonTime(-1.0)
      {
      }

      size_t mModeIndex;

      double mRequiredPd;

      double mLockonTime;
   };
 
   WsfSensor(const WsfScenario& aScenario);
   ~WsfSensor() override;


   using ComponentList = WsfComponentListT<WsfSensorComponent>;
   ComponentList&       GetComponents() { return mComponents; }
   const ComponentList& GetComponents() const { return mComponents; }


   WsfComponent* CloneComponent() const override { return Clone(); }
   const int*    GetComponentRoles() const override;
   void*         QueryInterface(int aRole) override;
   int           GetComponentInitializationOrder() const override { return cWSF_INITIALIZE_ORDER_SENSOR; }
 
   bool AllowDetectionChancesFor(WsfPlatform* aPlatformPtr);
   void AddIgnoredCategory(const std::string& aCategory);
 
   virtual bool AttemptToDetect(double aSimTime, WsfPlatform* aTargetPtr, Settings& aSettings, WsfSensorResult& aResult);


   const char* GetScriptClassName() const override;
   WsfSensor*   Clone() const override = 0;
   bool         PreInitialize(double aSimTime) override;
   bool         Initialize(double aSimTime) override;
   bool         Initialize2(double aSimTime) override;
   void         PlatformAdded(double aSimTime, WsfPlatform* aPlatformPtr) override;
   void         PlatformDeleted(WsfPlatform* aPlatformPtr) override;
   void         PreInput() override;
   bool         ProcessInput(UtInput& aInput) override;
   void         Update(double aSimTime) override;
   void         UpdatePosition(double aSimTime) override;
   virtual void PerformScheduledDetections(double aSimTime);



   bool ThreadSafe() const { return mThreadSafe; }
   void SetThreadSafe() { mThreadSafe = true; }
   void SetNotThreadSafe() { mThreadSafe = false; }



   bool ShowCalibrationData() const { return mShowCalibrationData; }
   void SetShowCalibrationData(bool aShowCalibrationData) { mShowCalibrationData = aShowCalibrationData; }


   void AttachObserver(WsfSingleSensorObserver* aObserverPtr);
   void DetachObserver(WsfSingleSensorObserver* aObserverPtr);
   void NotifyDeleted();
   void NotifyTrackInitiated(double aSimTime, const WsfTrack& aTrack);
   void NotifyTrackUpdated(double aSimTime, const WsfTrack& aTrack);
   void NotifyTrackDropped(double aSimTime, const WsfTrack& aTrack);
   void NotifyTargetUpdated(double aSimTime, WsfPlatform* aTargetPtr, WsfSensorResult& aResult);
   void NotifyTurnedOff(double aSimTime);
   void NotifyTurnedOn(double aSimTime);
 
   virtual void NotifySensorDetectionAttempted(double aSimTime, WsfPlatform* aTargetPtr, WsfSensorResult& aResult);



   int GetClass() const { return mClass; }

   bool IsClassActive() const { return (mClass & cACTIVE) != 0; }

   bool IsClassPassive() const { return (mClass & cPASSIVE) != 0; }

   bool IsClassSemiActive() const { return (mClass & cSEMI_ACTIVE) != 0; }

   bool IsClassAcoustic() const { return (mClass & cACOUSTIC) != 0; }

   bool IsClassInfrared() const { return (mClass & cINFRARED) != 0; }

   bool IsClassRadio() const { return (mClass & cRADIO) != 0; }

   bool IsClassVisual() const { return (mClass & cVISUAL) != 0; }

   bool IsClassImaging() const { return (mClass & cIMAGING) != 0; }



   void TurnOff(double aSimTime) override;
   void TurnOn(double aSimTime) override;
   void SetNonOperational(double aSimTime) override;
   void SetOperational(double aSimTime) override;
   void PartBroken(double aSimTime) override;

   double GetUpdateInterval() const override { return mUpdateInterval; }


   virtual size_t      GetEM_RcvrCount() const;
   virtual WsfEM_Rcvr& GetEM_Rcvr(size_t aIndex) const;
   virtual size_t      GetEM_RcvrCount(size_t aModeIndex) const;
   virtual WsfEM_Rcvr& GetEM_Rcvr(size_t aModeIndex, size_t aIndex) const;
   virtual size_t      GetEM_XmtrCount() const;
   virtual WsfEM_Xmtr& GetEM_Xmtr(size_t aIndex) const;
   virtual size_t      GetEM_XmtrCount(size_t aModeIndex) const;
   virtual WsfEM_Xmtr& GetEM_Xmtr(size_t aModeIndex, size_t aIndex) const;


   virtual bool WithinFieldOfView(double aSimTime, WsfPlatform* aPlatformPtr);
   virtual bool WithinFieldOfView(double aSimTime, WsfTrack* aTrackPtr);


   virtual WsfStringId    GetCurrentModeName() const;
   virtual WsfSensorMode* GetCurrentMode() const;
   virtual size_t         GetModeCount() const;
   virtual WsfSensorMode* GetModeEntry(size_t aModeIndex) const;
   virtual size_t         GetModeIndex(WsfStringId aModeNameId) const;
   virtual WsfStringId    GetModeName(size_t aModeIndex) const;
   virtual void           DeselectMode(double aSimTime, WsfStringId aModeNameId);
   virtual void           SelectMode(double aSimTime, WsfStringId aModeNameId);
   virtual void           ScheduleModeChange(double aSimTime, bool aSelectModeFlag, WsfStringId aModeNameId);
   virtual bool           IsModeChangeScheduled() const;
   virtual double         GetModeSelectDelay() const;

 
   WsfSensorModeList* GetModeList() const { return mModeListPtr.get(); }


   virtual int  GetActiveRequestCount() const;
   virtual int  GetActiveRequestCount(WsfStringId aModeNameId) const;
   virtual int  GetMaximumRequestCount() const;
   virtual int  GetMaximumRequestCount(WsfStringId aModeNameId) const;
   virtual bool HaveRequestFor(const WsfTrackId& aTrackId) const;
   virtual bool StartTracking(double aSimTime, const WsfTrack& aTrack, WsfStringId aModeNameId);
   virtual bool StopTracking(double aSimTime, const WsfTrackId& aRequestId);


   virtual int GetActiveTrackCount() const;
 
   virtual void GetActiveTrackList(WsfTrackList& aActiveTrackList) const;
 
   virtual int GetMaximumTrackCount() const;
 
   virtual void SendTrackCoastMessage(double aSimTime, const WsfTrack* aTrackPtr);
 
   virtual void SendTrackDropMessage(double aSimTime, const WsfTrack* aTrackPtr);
 
   virtual void SendTrackUpdateMessage(double aSimTime, const WsfTrack* aTrackPtr);
 
   virtual void SetMessageParameters(WsfStringId aModeNameId, WsfMessage& aMessage);
 
   virtual void TrackCoasted(double aSimTime, WsfTrack* aTrackPtr);
 
   virtual void TrackDropped(double aSimTime, WsfTrack* aTrackPtr);
 
   virtual void TrackUpdated(double aSimTime, WsfTrack* aTrackPtr);



   static double GetRequiredPd(const WsfSensorMode* aModePtr);



   bool IsSlave() const { return mIsSlave; }
 
   void SetIsSlave(double aSimTime, bool aIsSlave);



   WsfSensorScheduler* GetScheduler() const { return mSchedulerPtr.get(); }
 
   void                                SetScheduler(std::unique_ptr<WsfSensorScheduler> aSchedulerPtr);
   std::unique_ptr<WsfSensorScheduler> SwapScheduler(std::unique_ptr<WsfSensorScheduler> aSchedulerPtr);

   WsfSensorTracker* GetTracker() const { return mTrackerPtr.get(); }
 
   void                              SetTracker(std::unique_ptr<WsfSensorTracker> aTrackerPtr);
   std::unique_ptr<WsfSensorTracker> SwapTracker(std::unique_ptr<WsfSensorTracker> aTrackerPtr);

   //{@
   void SetUpdateInterval(double aUpdateInterval) override { mUpdateInterval = aUpdateInterval; }

   unsigned int GetUpdateEventEpoch() const { return mUpdateEventEpoch; }

   void IncrementUpdateEventEpoch() { ++mUpdateEventEpoch; }

   bool UpdateEventActive() const { return mUpdateEventActive; }

   void SetUpdateEventActive(bool aUpdateEventActive) { mUpdateEventActive = aUpdateEventActive; }
 
   void AdjustNextUpdateTime(double aNextUpdateTime);

   double GetNextUpdateTime() const { return mNextUpdateTime; }
 
   void SetNextUpdateTime(double aSimTime, double aNextUpdateTime);


   void GetMessageParameters(int& aMessageLength, int& aMessagePriority) const
   {
      aMessageLength   = mMessageLength;
      aMessagePriority = mMessagePriority;
   }

   WsfStringId GetZoneAttenuationModifier() const { return mZoneAttenuationModifier; }

   bool SendDis() { return mSendDis; }

   ut::Random& GetRandom() { return mRandom; }
 
   virtual bool GetFilteredDoppler() const { return true; }

   bool ScriptAllowDetection(double aSimTime, WsfPlatform* aTargetPtr, WsfSensorResult& aResult);

   class ModeChangeEvent : public WsfEvent
   {
   public:
      enum EventType
      {
         cSELECT,
         cDESELECT
      };
 
      ModeChangeEvent();
      ModeChangeEvent(double aSimTime, EventType aEventType, WsfSensor* aSensorPtr, WsfStringId aModeNameId);
 
      EventDisposition Execute() override;
 
   private:
      size_t      mPlatformIndex; 
      EventType   mEventType;     
      WsfSensor*  mSensorPtr;     
      WsfStringId mModeNameId;    
   };
 
protected:
   WsfSensor(const WsfSensor& aSrc);
   WsfSensor& operator=(const WsfSensor& aSrc) = delete;
 
   void SetClass(int aClass);
   void SetModeList(std::unique_ptr<WsfSensorModeList> aModeListPtr);
 
   UtScriptContext* GetScriptAccessibleContext() const override;
   void             SetPlatform(WsfPlatform* aPlatformPtr) override;

   bool mThreadSafe;
 
   std::unique_ptr<WsfSensorModeList>  mModeListPtr;
   std::unique_ptr<WsfSensorScheduler> mSchedulerPtr;
   std::unique_ptr<WsfSensorTracker>   mTrackerPtr;

   double mNextUpdateTime;

   int mMessageLength;

   int mMessagePriority;

   WsfStringId mZoneAttenuationModifier;

   WsfCategoryList mIgnoredCategories;

   std::vector<WsfStringId> mIgnoredSides;

   unsigned int mIgnoredDomains;

   bool mIgnoreSameSide;
 
private:
   ComponentList mComponents;

   std::vector<WsfSensorMode*> mSensorModeList;

   int mClass;

   double mUpdateInterval;

   unsigned int mUpdateEventEpoch;

   bool mUpdateEventActive;

   bool mIsSlave;

   bool mShowCalibrationData;

   bool mSendDis;
 
   ut::Random mRandom;

   WsfScriptContext mContext;
   UtScript*        mOnDetectionScriptPtr{nullptr};
 
   std::vector<WsfSingleSensorObserver*> mObservers;
};
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(WsfSensor, cWSF_COMPONENT_SENSOR)
 
#endif