WsfSAR_Sensor.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 WSFSAR_SENSOR_HPP
#define WSFSAR_SENSOR_HPP
 
#include "wsf_mil_export.h"
 
#include <memory>
#include <vector>
 
#include "UtCloneablePtr.hpp"
#include "UtMatrix.hpp"
#include "WsfEM_Antenna.hpp"
#include "WsfEM_Rcvr.hpp"
#include "WsfEM_Xmtr.hpp"
#include "WsfPlatform.hpp"
#include "WsfSensor.hpp"
#include "WsfSensorBeam.hpp"
#include "WsfSensorMode.hpp"
#include "WsfStandardSensorErrorModel.hpp"
#include "script/WsfScriptSensorClass.hpp"

class WSF_MIL_EXPORT WsfSAR_Sensor : public WsfSensor
{
public:
   WsfSAR_Sensor(WsfScenario& aScenario);
   ~WsfSAR_Sensor() override;
 
   bool AttemptToDetect(double aSimTime, WsfPlatform* aTargetPtr, Settings& aSettings, WsfSensorResult& aResult) override;
   WsfSensor* Clone() const override;
   bool       Initialize(double aSimTime) override;
   void       PlatformAdded(double aSimTime, WsfPlatform* aPlatformPtr) override;
   void       PlatformDeleted(WsfPlatform* aPlatformPtr) override;
   bool       ProcessInput(UtInput& aInput) override;
   void       TurnOff(double aSimTime) override;
   void       TurnOn(double aSimTime) override;
   void       Update(double aSimTime) override;
 
   size_t      GetEM_RcvrCount() const override;
   WsfEM_Rcvr& GetEM_Rcvr(size_t aIndex) const override;
   size_t      GetEM_XmtrCount() const override;
   WsfEM_Xmtr& GetEM_Xmtr(size_t aIndex) const override;
 
   const char* GetScriptClassName() const override { return "WsfSAR_Sensor"; }
 
   static std::unique_ptr<UtScriptClass> CreateScriptClass(const std::string& aClassName, UtScriptTypes* aScriptTypesPtr);
 
   enum FailureReasons
   {
      cFR_FIELD_OF_VIEW_EXCEEDED        = 1,  
      cFR_BEYOND_HORIZON                = 2,  
      cFR_DWELL_TIME_LIMIT_EXCEEDED     = 4,  
      cFR_AMBIGUOUS_RANGE               = 8,  
      cFR_DOPPLER_FOLDOVER              = 16, 
      cFR_INSUFFICIENT_CLUTTER_TO_NOISE = 32, 
      cFR_INSUFFICIENT_RESOLUTION       = 64  
   };
 
   bool CanImageNow(double  aSimTime,
                    double& aDwellTime,
                    double& aResolution,
                    double& aCNR,
                    double& aDopplerMargin,
                    int&    aFailureReasons);
 
   double GetDwellTime() const;
   void   SetDwellTime(double aDwellTime);
 
   double GetResolution() const;
   void   SetResolution(double aResolution);

   double GetAchievedCNR() const { return mAchievedCNR; }

   double GetAchievedResolution() const { return mAchievedAzimuthResolution; }

   unsigned int GetTurnOffEventNumber() const { return mTurnOffEventNumber; }
 
   double GetBackscatterCoefficient() const { return mBackscatterCoefficient; }
 
   // Some compilers require inner classes to be declared friends if they want to access outer class members
   class SAR_Chance;
   friend class SAR_Chance;
   class SAR_Mode;
   friend class SAR_Mode;

   struct Geometry
   {
      double mGroundSpeed;

      double mAltitude;

      double mSlantRange;

      double mDepressionAngle;

      double mSquintAngle;

      double mTotalAngle;

      double mGrazingAngle;

      double mScanAngle;
   };

   class SAR_Chance
   {
   public:
      SAR_Chance(WsfPlatform* aTargetPtr);
      ~SAR_Chance();
 
      WsfTrack*    mTrackPtr;
      double       mSignalSum;
      double       mAreaSum;
      double       mLocationWCS[3];
      double       mComputedRangeError;
      double       mComputedDopplerError;
      size_t       mTargetIndex;
      unsigned int mNumberOfDetections;
      bool         mNowDetecting;
   };

   class SAR_Mode : public WsfSensorMode, public WsfSensorBeam
   {
   public:
      enum OperatingMode
      {
         cOM_SPOT,
         cOM_STRIP
      };
 
      SAR_Mode();
      SAR_Mode(const SAR_Mode& aSrc);
      ~SAR_Mode() override = default;
      SAR_Mode& operator=(const SAR_Mode&) = delete;
 
      // WsfSensorMode methods.
      size_t         GetBeamCount() const override { return 1; }
      WsfSensorBeam* GetBeamEntry(size_t /* aBeamIndex */) override { return this; }
 
      // WsfSensorBeam methods.
      WsfEM_Rcvr* GetEM_Rcvr() override { return mRcvrPtr.get(); }
      WsfEM_Xmtr* GetEM_Xmtr() override { return mXmtrPtr.get(); }
 
      bool AttemptToDetect(double aSimTime, WsfPlatform* aTargetPtr, Settings& aSettings, WsfSensorResult& aResult) override;
 
      void Deselect(double aSimTime) override;
      void Select(double aSimTime) override;
 
      WsfMode* Clone() const override;
      bool     Initialize(double aSimTime) override;
      bool     ProcessInput(UtInput& aInput) override;
 
      void Calibrate();
 
      class SAR_ErrorModel : public wsf::StandardSensorErrorModel
      {
      public:
         SAR_ErrorModel();
         SAR_ErrorModel(const SAR_ErrorModel& aSrc);
         ~SAR_ErrorModel() override = default;
 
         bool            ProcessInput(UtInput& aInput) override;
         bool            Initialize(WsfSensorMode* aSensorModePtr) override;
         SAR_ErrorModel* Clone() const override { return new SAR_ErrorModel(); }
 
         std::unique_ptr<wsf::SphericalMeasurementErrors> ComputeMeasurementErrors(WsfSensorResult& aResult) const override;
         void ApplyMeasurementErrors(const wsf::SphericalMeasurementErrors& aErrors, WsfSensorResult& aResult) override;
         void ApplySAR_MeasurementErrors(const wsf::SphericalMeasurementErrors& aErrors, SAR_Chance& aChance);
         const UtMatrixd* GetErrorCovarianceMatrix() const { return &mCovarianceMatrix; }
 
      private:
         void ApplyRangeDopplerErrors(WsfEM_Antenna* aAntennaPtr, WsfPlatform* aTargetPtr, SAR_Chance* aChancePtr);
 
         void ComputeRangeDopplerErrors(double             aSimTime,
                                        const WsfPlatform* aTargetPtr,
                                        double&            aRangeError,
                                        double&            aDopplerError) const;

         bool mComputeRangeDopplerErrors{false};
         double mSAR_Errors[15];

         bool mSAR_ErrorsSet[15];
 
         mutable UtMatrixd                     mErrorsSqrd;
         mutable UtMatrixd                     mCovarianceMatrix;
         mutable ut::CloneablePtr<WsfPlatform> mTempPlatformPtr{nullptr};
         WsfEM_Antenna*                        mAntennaPtr{nullptr};
      };
 
      void ComputeGeometry(double aSimTime, Geometry& aGeometry);
 
      double ComputeCNR(const Geometry& aGeometry, double aPRF, double aDwellTime, double aResolution);
 
      double ComputeDwellTime(const Geometry& aGeometry, double aResolution);
 
      // double ComputePixelCount(double aRange,
      //                          double aOpticalCrossSection);
 
      double ComputePRF(const Geometry& aGeometry);
 
      double ComputeAzimuthResolution(const Geometry& aGeometry, double aDwellTime);
 
      double ComputeGroundRangeResolution(const Geometry& aGeometry);
 
      bool ComputeImageCenter(double aLocationWCS_1[3], double aLocationWCS_2[3], bool aFirstPass = false);
 
      void ComputeFOV(const Geometry& aGeometry);
 
      double ComputeSlantRange(double aAltitude, double aDepressionAngle, double& aGrazingAngle);
 
      double ComputeSquintAngle(WsfPlatform* aTargetPtr, double& aSlantRange);
 
      void ComputeUpdateInterval(double aSimTime);
 
      void PredictPerformance(const Geometry& aGeometry,
                              double&         aPRF,
                              double&         aDwellTime,
                              double&         aAzimuthResolution,
                              double&         aCNR,
                              double&         aMinimumPRF);
 
      bool WithinUnambiguousRange(WsfSensorResult& aResult);
 
      void SetIntegrationGain(double aIntegrationGain) override { mIntegrationGain = aIntegrationGain; }

      WsfSAR_Sensor* mSAR_SensorPtr;

      SAR_ErrorModel* mSAR_ErrorModelPtr;

      OperatingMode mOperatingMode;

      std::unique_ptr<WsfEM_Antenna> mAntennaPtr;

      std::unique_ptr<WsfEM_Xmtr> mXmtrPtr;

      std::unique_ptr<WsfEM_Rcvr> mRcvrPtr;

      double mKa;

      double mKd;

      double mResolution;

      double mDwellTime;

      double mMaximumDwellTime;

      double mMinimumCNR;

      double mMaxDetectableSpeed;

      double mCurrentAzimuthResolution;

      double mCurrentGroundRangeResolution;



      double mAngularResolution;

      double mIntegrationGain;

      double mAdjustmentFactor;

      double mOneM2DetectRange;

      bool mComputeDwellTime;

      bool mComputePRF;

      bool mAutomaticTurnOff;

      bool mInhibitSubstandardCollection;

      double mImageHeight;
      double mImageWidth;

      double mImageCenterWCS[3];
   };
 
private:
   WsfSAR_Sensor(const WsfSAR_Sensor& aSrc);
   WsfSAR_Sensor& operator=(const WsfSAR_Sensor&) = delete;
 
   void BuildAndSendImage(double aSimTime, SAR_Mode& aMode);
 
   void ClearSensingChances();
 
   void AddSensingChance(double aSimTime, const SAR_Mode& aMode, const Geometry& aGeometry, WsfPlatform* aTargetPtr);
 
   void ProcessModeChange(double aSimTime, size_t aOldModeIndex, size_t aNewModeIndex);
 
   void SpotModeBegin(double aSimTime, SAR_Mode& aMode, Geometry& aGeometry);
 
   void SpotModeEnd(double aSimTime, SAR_Mode& aMode);
 
   void SpotModeUpdate(double aSimTime, Settings& aSettings);
 
   void StripModeBegin(double aSimTime, SAR_Mode& aMode, Geometry& aGeometry);
 
   void StripModeEnd(double aSimTime, SAR_Mode& aMode);
 
   void StripModeUpdate(double aSimTime, Settings& aSettings);
 
   void NotifyObservers(double aSimTime, SAR_Mode* aModePtr, SAR_Chance* aChancePtr, WsfSensorResult& aResult, bool aDetected);

   std::vector<SAR_Mode*> mSAR_ModeList;

   using Chances = std::vector<std::unique_ptr<SAR_Chance>>;
   Chances mChances;

   unsigned int mStreamNumber;

   unsigned int mFrameNumber;

   double mBackscatterCoefficient;

   double mIntensityMin;

   double mIntensityMax;

   double mIntensityRange;

   double mLastUpdateTime;

   double mModeStartTime;

   size_t mLastModeIndex;

   unsigned int mTurnOffEventNumber;

   bool mRescaleSubstandardImage;

   bool mAutomaticTurnOff;

   bool mSAR_ConstraintPlotting;

   bool mShowStatus;

   bool mCallSensorTrackObservers;

   Geometry mGeometry;

   double mAchievedCNR;

   double mAchievedAzimuthResolution;

   double mAchievedGroundRangeResolution;

   WsfPlatform mTempPlatform;
};
 
// Script Accessor Class
class WSF_MIL_EXPORT WsfScriptSAR_SensorClass : public WsfScriptSensorClass
{
public:
   WsfScriptSAR_SensorClass(const std::string& aClassName, UtScriptTypes* aScriptTypesPtr);
 
   UT_DECLARE_SCRIPT_METHOD(GetDwellTime_1);
   UT_DECLARE_SCRIPT_METHOD(GetDwellTime_2);
   UT_DECLARE_SCRIPT_METHOD(SetDwellTime_1);
   UT_DECLARE_SCRIPT_METHOD(SetDwellTime_2);
 
   UT_DECLARE_SCRIPT_METHOD(GetResolution_1);
   UT_DECLARE_SCRIPT_METHOD(GetResolution_2);
   UT_DECLARE_SCRIPT_METHOD(SetResolution_1);
   UT_DECLARE_SCRIPT_METHOD(SetResolution_2);
};
 
#endif