WsfOTH_RadarSensor.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 WSFOTHRADARSENSOR_HPP
#define WSFOTHRADARSENSOR_HPP
 
#include "wsf_mil_export.h"
 
#include <memory>
#include <vector>
 
#include "TblLookup.hpp"
#include "WsfDetectionProbabilityTable.hpp"
#include "WsfEM_Antenna.hpp"
class WsfEM_Clutter;
#include "WsfEM_Noise.hpp"
#include "WsfEM_Rcvr.hpp"
#include "WsfEM_Xmtr.hpp"
#include "WsfMTI_TableManager.hpp"
#include "WsfMarcumSwerling.hpp"
#include "WsfSensor.hpp"
#include "WsfSensorBeam.hpp"
#include "WsfSensorMode.hpp"
#include "WsfSensorSignalProcessor.hpp"

class WSF_MIL_EXPORT WsfOTH_RadarSensor : public WsfSensor
{
public:
   WsfOTH_RadarSensor(WsfScenario& aScenario);
   WsfOTH_RadarSensor(const WsfOTH_RadarSensor& aSrc);
   WsfOTH_RadarSensor& operator=(const WsfOTH_RadarSensor&) = delete;
 
   WsfSensor* Clone() const override;
   bool       Initialize(double aSimTime) override;
   void       PlatformAdded(double aSimTime, WsfPlatform* aPlatformPtr) override;
   bool       ProcessInput(UtInput& aInput) override;
   void       Update(double aSimTime) override;
   void       PerformScheduledDetections(double aSimTime) override;
 
   size_t      GetEM_RcvrCount() const override;
   WsfEM_Rcvr& GetEM_Rcvr(size_t aIndex) const override;
   size_t      GetEM_RcvrCount(size_t aModeIndex) const override;
   WsfEM_Rcvr& GetEM_Rcvr(size_t aModeIndex, size_t aIndex) const override;
   size_t      GetEM_XmtrCount() const override;
   WsfEM_Xmtr& GetEM_Xmtr(size_t aIndex) const override;
   size_t      GetEM_XmtrCount(size_t aModeIndex) const override;
   WsfEM_Xmtr& GetEM_Xmtr(size_t aModeIndex, size_t aIndex) const override;
 
   void UpdateXmtrRcvrLists();
 
   // Some compilers require inner classes to be declared friends if they want to access outer class members
   class OTH_Beam;
   class OTH_Mode;
   friend class OTH_Beam;
   friend class OTH_Mode;

   class OTH_Beam : public WsfSensorBeam
   {
   public:
      OTH_Beam();
      OTH_Beam(const OTH_Beam& aSrc);
      OTH_Beam& operator=(const OTH_Beam&) = delete;
      ~OTH_Beam() override;
 
      // WsfSensorBeam methods.
      WsfEM_Rcvr* GetEM_Rcvr() override { return mRcvrPtr.get(); }
      WsfEM_Xmtr* GetEM_Xmtr() override { return mXmtrPtr.get(); }
 
      bool ProcessInput(UtInput& aInput) override;
 
      void AttemptToDetect(double aSimTime, WsfPlatform* aTargetPtr, Settings& aSettings, WsfSensorResult& aResult);
 
      double GetAdjustmentFactor() const { return mAdjustmentFactor; }
      double GetIntegrationGain() const override { return mIntegrationGain; }
      void   SetIntegrationGain(double aIntegrationGain) override { mIntegrationGain = aIntegrationGain; }
      int    GetNumberOfPulsesIntegrated() const override { return mNumberOfPulsesIntegrated; }
      bool   UsingDetector() const { return mUseDetector; }
 
      double GetDopplerResolution() const { return mDopplerResolution; }

      WsfMTI_TableManager::MTI_AdjustmentTable* GetMTI_AdjustmentTable() { return mMTI_AdjustmentTablePtr.get(); }
 
      bool AreIonosphericParametersValid();
 
      void ComputeIonosphericCharacteristics();
 
      void UpdateIonosphericCharacteristics();
 
      void GetReflectionLocationWCS(double aReflectionLocationWCS[]);
 
      bool GetIonosphericRangeConstrained() const { return mIonosphericCharacteristics.mRangeConstrained; }
 
      double GetMinUsableFrequency() const { return mIonosphericCharacteristics.mMinUsableFrequency; }
 
      void GetIonosphericRangeLimits(double& aMin, double& aMax);
 
      bool GetIonosphereChanged() const { return mIonosphereChanged; }
 
      void SetIonosphereChanged(bool aIonosphereChanged) { mIonosphereChanged = aIonosphereChanged; }
 
      void SetLoopGain(double aLoopGain) { mLoopGain = aLoopGain; }
 
      void SetClutterAttenuationFactor(double aFactor) { mClutterAttenuationFactor = aFactor; }
 
      // double ComputeClutterAttenuation();
 
      bool Initialize(double       aSimTime,
                      unsigned int aBeamIndex,
                      WsfSensor*   aSensorPtr,
                      OTH_Mode*    aModePtr,
                      bool         aCanTransmit,
                      bool         aCanReceive,
                      bool         aShowCalibrationData,
                      bool         aIsMultiBeam);
 
      void ReadTable(UtInput& aInput, WsfMTI_TableManager::MTI_AdjustmentTable& aMTI_AdjustmentTable);
 
      void ComputeMTI_Effects(WsfSensorResult& aResult, double& aClutterAttenuationFactor);
 
      WsfStringId    GetClutterType() const { return mClutterType; }
      WsfEM_Clutter* GetClutter() const override { return mClutterPtr; }
 
      std::unique_ptr<WsfEM_Antenna> mAntennaPtr;

      std::unique_ptr<WsfEM_Xmtr> mXmtrPtr;

      std::unique_ptr<WsfEM_Rcvr> mRcvrPtr;

      WsfEM_Clutter* mClutterPtr;

      WsfEM_Noise mNoise;

      double mErrorModelAzBeamwidth;       // radians
      double mErrorModelElBeamwidth;       // radians
      double mErrorModelPulseWidth;        // seconds
      double mErrorModelDopplerResolution; // m/s
 
   private:
      WsfPlatform* GetPlatform();
 
      void AttemptToDetect(double           aSimTime,
                           WsfPlatform*     aTargetPtr,
                           Settings&        aSettings,
                           WsfEM_Xmtr*      aXmtrPtr,
                           WsfSensorResult& aResult);
 
      void Calibrate(bool aPrint);
 
      void ComputeClutterAttenuationFactor(OTH_Mode& aMode);
 
      double ComputeIntegratedPulseCount(OTH_Mode& aMode);
 
      bool InitializeDetector(OTH_Mode& aMode);
      bool InitializeMTI(OTH_Mode& aMode);
 
      void ComputeBouncePathRanges(WsfSensorResult& aResult, double& aXmtrToTgt, double& aRcvrToTgt);
 
      bool CanBounceToTarget(WsfPlatform* aTargetPtr, WsfSensorResult& aResult);

      bool mCanTransmit;

      bool mUseDetector;

      double mDopplerResolution;

      double mOneM2DetectRange;

      double mLookDownFactor;

      double mPRF_Factor;

      double mPostLockonDetectionThresholdAdjustment;

      double mPostLockonAdjustmentDelayTime;

      double mLoopGain;

      double mAdjustmentFactor;

      double mIntegrationGain;

      int mNumberOfPulsesIntegrated;

      wsf::MarcumSwerling mDetector;

      std::shared_ptr<wsf::DetectionProbabilityTable> mProbabilityTablePtr;

      std::shared_ptr<WsfMTI_TableManager::MTI_AdjustmentTable> mMTI_AdjustmentTablePtr;

      // ! Not to be confused with the MTI processing specific variable
      double mMTI_TableMaxRange;

      double mClutterAttenuationFactor;

      WsfStringId mClutterType;


      double mMTI_MaxRange; 
      double mMTI_InterpulsePeriod_1;
      double mMTI_InterpulsePeriod_2;
      double mMTI_StabilityConstant;
      double mMTI_Weights[3];
      int    mMTI_NumberOfStages;
      bool   mPerformMTI_Processing; 
      bool   mMTI_ClutterLock;
      bool   mMTI_UpWind;

      struct OTH_Geometry
      {
         double mAngularExtent;
         double mReflectionLocWCS[3];
         double mReflectionHeight;
         double mGreatCircleDistance;
      };
 
      struct SolarCharacteristics
      {
         int    mDayOfYear = 1;
         int    mHourOfDay = 12;
         double mSolarAngRads;
         double mSolarDeclinationAngRads;
         double mSolarZenithAngRads;
      };
 
      struct IonosphereCharacteristics
      {
         double mElectronDensityAtMax = 4.0e11;
         double mElectronHeightAtMax  = 250000.0;
         double mReflectionHeight     = 300000.0;
         double mTemperatureAtMax     = 1540.0;
         bool   mRangeConstrained     = false;
 
         double mComputedElectronicDensity;
         double mMaxIncidenceAngleDegrees;
         double mMinRange;
         double mMaxRange;
         double mCriticalFrequency;
         double mMaxUsableFrequency;
         double mMinUsableFrequency;
      };
 
      // ionospheric variables
      SolarCharacteristics      mSolarCharacteristics;
      IonosphereCharacteristics mIonosphericCharacteristics;
      OTH_Geometry              mOTH_Geometry;
      bool                      mIonosphereChanged;
      bool                      mComputeAtmosphericNoise;
      bool                      mDebug;
   };

   class OTH_Mode : public WsfSensorMode
   {
   public:
      OTH_Mode();
      OTH_Mode(const OTH_Mode& aSrc);
      OTH_Mode& operator=(const OTH_Mode&) = delete;
      ~OTH_Mode() override;
 
      // WsfSensorMode methods.
      size_t         GetBeamCount() const override { return mBeamList.size(); }
      WsfSensorBeam* GetBeamEntry(size_t aBeamIndex) override { return mBeamList[aBeamIndex]; }
 
      WsfMode* Clone() const override;
      bool     Initialize(double aSimTime) override;
      bool     ProcessInput(UtInput& aInput) override;
 
      bool AttemptToDetect(double aSimTime, WsfPlatform* aTargetPtr, Settings& aSettings, WsfSensorResult& aResult) override;
 
      void UpdateTrack(double aSimTime, WsfTrack* aTrackPtr, WsfPlatform* aTargetPtr, WsfSensorResult& aResult) override;
 
      double GetAltFreqSelectDelay() const override { return mAltFreqSelectDelay; }
      void   ScheduleAltFreqChange(double aSimTime, int aAltFreqId = -1) override;
      bool   IsAltFreqChangeScheduled() const override { return mAltFreqChangeScheduled; }
      double GetLastAltFreqSelectTime() const override { return mLastAltFreqSelectTime; }
      bool   IsFrequencyAgile() const override { return mIsFrequencyAgile; }
 
      void Deselect(double aSimTime) override;
      void Select(double aSimTime) override;
 
      bool                   mOverrideMeasurementWithTruth;
      bool                   mCanTransmit;
      bool                   mCanReceive;
      bool                   mImplicitBeamUsed;
      bool                   mExplicitBeamUsed;
      std::vector<OTH_Beam*> mBeamList;
 
   protected:
      void SelectAlternateFrequency(double aSimTime, int aAltFreqId = -1) override;
 
      double mAltFreqSelectDelay;
      bool   mAltFreqChangeScheduled;
      double mLastAltFreqSelectTime;
      bool   mIsFrequencyAgile;
   };
 
private:
   std::vector<OTH_Mode*> mOTH_ModeList;

   std::vector<WsfEM_Xmtr*> mXmtrList;

   std::vector<WsfEM_Rcvr*> mRcvrList;

   bool mAnyModeCanTransmit;

   bool mAnyModeCanReceive;

   WsfPlatform* mTempGeometryPtr;
};
 
#endif