WsfSensorMode.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 WSFSENSORMODE_HPP
#define WSFSENSORMODE_HPP
 
#include "wsf_export.h"
 
#include <memory>
 
#include "UtCloneablePtr.hpp"
#include "WsfMode.hpp"
#include "WsfSensor.hpp"
class WsfSensorBeam;
class WsfSensorErrorModelBase;
class WsfSensorModeList;
class WsfSensorResult;
#include "WsfStringId.hpp"
class WsfTrack;

class WSF_EXPORT WsfSensorMode : public WsfMode
{
   friend class WsfSensorModeList;
 
public:
   WsfSensorMode();
   WsfSensorMode(const WsfSensorMode& aSrc);
   WsfSensorMode& operator=(const WsfSensorMode& aRhs);
   ~WsfSensorMode() override;

   WsfPlatform* GetPlatform() const { return mPlatformPtr; }

   WsfSensor* GetSensor() const { return mSensorPtr; }
 
   const WsfScenario& GetScenario() const;
 
   WsfSimulation* GetSimulation() const;

   WsfMode* Clone() const override = 0;
 
   virtual bool Initialize(double aSimTime);
 
   bool ProcessInput(UtInput& aInput) override;


   virtual size_t         GetBeamCount() const;
   virtual WsfSensorBeam* GetBeamEntry(size_t aIndex);

   virtual bool AttemptToDetect(double               aSimTime,
                                WsfPlatform*         aTargetPtr,
                                WsfSensor::Settings& aSettings,
                                WsfSensorResult&     aResult) = 0;
 
   virtual double GetAltFreqSelectDelay() const { return -1.0; }
   virtual void   ScheduleAltFreqChange(double aSimTime, int aAltFreqId = -1) {}
   virtual bool   IsAltFreqChangeScheduled() const { return false; }
   virtual double GetLastAltFreqSelectTime() const { return 0.0; }
 
   virtual bool IsFrequencyAgile() const { return false; }

   void Deselect(double aSimTime) override = 0;

   void Select(double aSimTime) override = 0;
 
   virtual void ApplyMeasurementErrors(WsfSensorResult& aResult);
 
   WSF_DEPRECATED virtual void ComputeMeasurementErrors(WsfSensorResult& aResult,
                                                        double&          aAzError,
                                                        double&          aElError,
                                                        double&          aRangeError,
                                                        double&          aRangeRateError) final;
 
   virtual void InitializeTrack(double aSimTime, WsfTrack*& aTrackPtr);
 
   virtual void UpdateSensorCueingLimits();
 
   virtual void UpdateTrack(double aSimTime, WsfTrack* aTrackPtr, WsfPlatform* aTargetPtr, WsfSensorResult& aResult);
 
   virtual void UpdateTrackReportingFlags(double aSimTime, WsfTrack* aTrackPtr);
 
   virtual bool WithinDetectionRange(double aSimTime, WsfPlatform* aTargetPtr);

   double GetMaximumRange() const { return mMaximumRange; }

   int GetMaximumRequestCount() const { return mMaximumRequestCount; }

   bool DisablesSearch() const { return mDisablesSearch; }

   bool CanSearchWhileTrack() const { return mCanSearchWhileTrack; }
 
   double GetFrameTime() const { return mFrameTime; }
   void   SetFrameTime(double aFrameTime) { mFrameTime = aFrameTime; }
   double GetRevisitTime() const { return mRevisitTime; }
   double GetDwellTime() const { return mDwellTime; }

   double GetRequiredPd() const { return mRequiredPd; }

   double EstablishTrackProbability() const { return mEstablishTrackProbability; }

   double MaintainTrackProbability() const { return mMaintainTrackProbability; }

   int HitsToEstablishTrack() const { return mHitsToEstablishTrack; }

   int EstablishTrackWindow() const { return mEstablishTrackWindow; }

   int HitsToMaintainTrack() const { return mHitsToMaintainTrack; }

   int MaintainTrackWindow() const { return mMaintainTrackWindow; }

   unsigned int EstablishTrackMask() const { return mEstablishTrackMask; }

   unsigned int MaintainTrackMask() const { return mMaintainTrackMask; }
 
   double GetTrackQuality() const { return mTrackQuality; }


   unsigned int GetReportingFlags() const { return mReportingFlags.mFlags; }
 
   bool ReportsLocation() const { return mReportingFlags.mReportsLocation; }
   bool ReportsVelocity() const { return mReportingFlags.mReportsVelocity; }
   bool ReportsRange() const { return mReportingFlags.mReportsRange; }
   bool ReportsBearing() const { return mReportingFlags.mReportsBearing; }
   bool ReportsElevation() const { return mReportingFlags.mReportsElevation; }
   bool ReportsRangeRate() const { return mReportingFlags.mReportsRangeRate; }
   bool ReportsSide() const { return mReportingFlags.mReportsSide; }
   bool ReportsType() const { return mReportingFlags.mReportsType; }
   bool ReportsIFF_Status() const { return mReportingFlags.mReportsIFF_Status; }
   bool ReportsSignalToNoise() const { return mReportingFlags.mReportsSignalToNoise; }
   bool ReportsFrequency() const { return mReportingFlags.mReportsFrequency; }
   bool ReportsPulseWidth() const { return mReportingFlags.mReportsPulseWidth; }
   bool ReportsPulseRepititionInterval() const { return mReportingFlags.mReportsPulseRepititionInterval; }


   const wsf::SensorErrorModelBase* GetErrorModel() const { return mErrorModelPtr.get(); }
   wsf::SensorErrorModelBase*       GetErrorModel() { return mErrorModelPtr.get(); }
   void                             SetErrorModel(std::unique_ptr<wsf::SensorErrorModelBase> aErrorModelPtr)
   {
      mErrorModelPtr = std::move(aErrorModelPtr);
   }



   WSF_DEPRECATED virtual double GetAzErrorStdDev() final { return mAzErrorStdDev; }
   WSF_DEPRECATED virtual double GetElErrorStdDev() final { return mElErrorStdDev; }
   WSF_DEPRECATED virtual double GetRangeErrorStdDev() final { return mRangeErrorStdDev; }
   WSF_DEPRECATED virtual double GetRangeRateErrorStdDev() final { return mRangeRateErrorStdDev; }
   WSF_DEPRECATED virtual void   SetAzErrorStdDev(double aAzErrorStdDev) final;
   WSF_DEPRECATED virtual void   SetElErrorStdDev(double aElErrorStdDev) final;
   WSF_DEPRECATED virtual void   SetRangeErrorStdDev(double aRangeErrorStdDev) final;
   WSF_DEPRECATED virtual void   SetRangeRateErrorStdDev(double aRangeRateErrorStdDev) final;



   size_t GetOnSuccessModeIndex() const { return mOnSuccessModeIndex; }

   size_t GetOnFailureModeIndex() const { return mOnFailureModeIndex; }

   int GetMessageLength() const { return mMessageLength; }

   int GetMessagePriority() const { return mMessagePriority; }
 
   // This was formerly protected but needed to be made accessible to sensor components.
   void UpdateTrackPosition(WsfTrack* aTrackPtr, WsfSensorResult& aResult, const double aTgtLocationWCS[3]);
 
   WsfSensor::SlewMode GetCueMode() const { return mCueMode; }
 
protected:
   class WSF_EXPORT AltFrequencyChangeEvent : public WsfEvent
   {
   public:
      AltFrequencyChangeEvent(double aSimTime, WsfSensorMode* aSensorModePtr, int aAltFrequencyId = -1);
 
      EventDisposition Execute() override;
 
   private:
      size_t         mPlatformIndex;  
      WsfSensorMode* mSensorModePtr;  
      int            mAltFrequencyId; 
                                      // TODO-UNUSED unsigned int   mUpdateEventEpoch;
   };
 
   bool InitializeReporting();
 
   virtual void SelectAlternateFrequency(double aSimTime, int aAltFreqId = -1) {}

   WsfSensor* mSensorPtr;
   WsfPlatform* mPlatformPtr;

   double mMaximumRange;


   double              mAzCueRate;
   double              mElCueRate;
   double              mMinAzCue;
   double              mMaxAzCue;
   double              mMinElCue;
   double              mMaxElCue;
   WsfSensor::SlewMode mCueMode;

   int mMaximumRequestCount;

   bool mCanSearchWhileTrack;

   bool mDisablesSearch;
 
   double mFrameTime;
   double mRevisitTime;
   double mDwellTime;

   double mRequiredPd;



   double mEstablishTrackProbability;

   double mMaintainTrackProbability;

   int mHitsToEstablishTrack;
   int mEstablishTrackWindow;
   unsigned int mEstablishTrackMask;

   int mHitsToMaintainTrack;
   int mMaintainTrackWindow;
   unsigned int mMaintainTrackMask;


   double mTrackQuality;



   double mAzErrorStdDev;
   double mElErrorStdDev;
   double mRangeErrorStdDev;
   double mRangeRateErrorStdDev;


   ut::CloneablePtr<wsf::SensorErrorModelBase> mErrorModelPtr{nullptr};

   WsfStringId mOnSuccessModeName;
   size_t      mOnSuccessModeIndex;

   WsfStringId mOnFailureModeName;
   size_t      mOnFailureModeIndex;

   int mMessageLength;
   int mMessagePriority;

   WsfSpatialDomain mReportsSpatialDomain;

   //{@
   static const unsigned int cNONE                      = 0;
   static const unsigned int cLOCATION                  = 1;
   static const unsigned int cVELOCITY                  = 2;
   static const unsigned int cRANGE                     = 4;
   static const unsigned int cBEARING                   = 8;
   static const unsigned int cELEVATION                 = 16;
   static const unsigned int cRANGE_RATE                = 32;
   static const unsigned int cSIDE                      = 64;
   static const unsigned int cTYPE                      = 128;
   static const unsigned int cIFF_STATUS                = 256;
   static const unsigned int cSIGNAL_TO_NOISE           = 512;
   static const unsigned int cFREQUENCY                 = 1024;
   static const unsigned int cPULSEWIDTH                = 2048;
   static const unsigned int cPULSE_REPITITION_INTERVAL = 4096;
   static const unsigned int cSTATE_COVARIANCE          = 8192;
   static const unsigned int cOTHER                     = 16384; 
   static const unsigned int cALL                       = 0xFFFFFFFF;
 
   struct ReportingFlags
   {
      ReportingFlags(unsigned int aReportingFlags)
         : mFlags(aReportingFlags)
      {
      }
      ReportingFlags()
         : mFlags(cALL)
      {
      }
 
      void Set(unsigned int aFlags) { mFlags = aFlags; }
 
      unsigned int Get() const { return mFlags; }
 
      union
      {
         struct
         {
            bool mReportsLocation : 1;
            bool mReportsVelocity : 1;
            bool mReportsRange : 1;
            bool mReportsBearing : 1;
            bool mReportsElevation : 1;
            bool mReportsRangeRate : 1;
            bool mReportsSide : 1;
            bool mReportsType : 1;
            bool mReportsIFF_Status : 1;
            bool mReportsSignalToNoise : 1;
            bool mReportsFrequency : 1;
            bool mReportsPulseWidth : 1;
            bool mReportsPulseRepititionInterval : 1;
            // Catch-all for anything other than the above.
            // Note:  A derived class must set this flag if none of the other flags apply.
            bool mReportsOther : 1;
         };
         unsigned int mFlags;
      };
   };
 
   void SetCapabilities(unsigned int aFlags) { mCapabilitiesFlags = aFlags; }
   void SetReportingFlags(unsigned int aFlags) { mReportingFlags = aFlags; }
 
   ReportingFlags mReportingFlags;
   ReportingFlags mCapabilitiesFlags;
};
 
#endif