WsfRadarSensor.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 WSFRADARSENSOR_HPP
#define WSFRADARSENSOR_HPP
 
#include "wsf_export.h"
 
#include <memory>
#include <vector>
 
#include "TblLookup.hpp"
#include "WsfDetectionProbabilityTable.hpp"
#include "WsfEM_Antenna.hpp"
class WsfEM_Clutter;
#include "WsfEM_Rcvr.hpp"
#include "WsfEM_Xmtr.hpp"
#include "WsfMarcumSwerling.hpp"
#include "WsfSensor.hpp"
#include "WsfSensorBeam.hpp"
#include "WsfSensorMode.hpp"
#include "WsfSensorResult.hpp"

class WSF_EXPORT WsfRadarSensor : public WsfSensor
{
public:
   WsfRadarSensor(WsfScenario& aScenario);
   WsfRadarSensor(const WsfRadarSensor& aSrc);
   WsfRadarSensor& operator=(const WsfRadarSensor&) = 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 RadarBeam;
   class RadarMode;
   friend class RadarBeam;
   friend class RadarMode;

   class WSF_EXPORT RadarBeam : public WsfSensorBeam
   {
   public:
      RadarBeam();
      RadarBeam(const RadarBeam& aSrc);
      RadarBeam& operator=(const RadarBeam& aRhs);
      ~RadarBeam() override;
 
      // WsfSensorBeam methods
      WsfEM_Rcvr* GetEM_Rcvr() override { return mRcvrPtr.get(); }
      WsfEM_Xmtr* GetEM_Xmtr() override { return mXmtrPtr.get(); }
 
      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; }
      wsf::MarcumSwerling& GetDetector() { return mDetector; }

      std::shared_ptr<wsf::DetectionProbabilityTable>& GetProbabilityTable() { return mProbabilityTablePtr; }
 
      double         GetDopplerResolution() const { return mDopplerResolution; }
      WsfEM_Clutter* GetClutter() const override { return mClutterPtr; }
      double         GetClutterAttenuationFactor() const { return mClutterAttenuationFactor; }
 
      bool Initialize(double       aSimTime,
                      unsigned int aBeamIndex,
                      WsfSensor*   aSensorPtr,
                      RadarMode*   aModePtr,
                      bool         aCanTransmit,
                      bool         aCanReceive,
                      bool         aShowCalibrationData,
                      bool         aIsMultiBeam);
 
      bool ProcessInput(UtInput& aInput) override;
 
      WsfStringId GetClutterType() const { return mClutterType; }
 
      std::unique_ptr<WsfEM_Antenna> mAntennaPtr;

      std::unique_ptr<WsfEM_Xmtr> mXmtrPtr;

      std::unique_ptr<WsfEM_Rcvr> mRcvrPtr;

      WsfEM_Clutter* mClutterPtr;

      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);
 
      double ComputeIntegratedPulseCount(RadarMode& aMode);
 
      bool InitializeDetector(RadarMode& aMode);

      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;

      double mClutterAttenuationFactor;

      WsfStringId mClutterType;
   };

   class WSF_EXPORT RadarMode : public WsfSensorMode
   {
   public:
      RadarMode();
      RadarMode(const RadarMode& aSrc);
      RadarMode& operator=(const RadarMode& aRhs);
      ~RadarMode() override;
 
      // WsfSensorMode methods.
      size_t         GetBeamCount() const override { return mBeamList.size(); }
      WsfSensorBeam* GetBeamEntry(size_t aIndex) override { return mBeamList[aIndex]; }
 
      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;
 
      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                    mCanTransmit;
      bool                    mCanReceive;
      bool                    mImplicitBeamUsed;
      bool                    mExplicitBeamUsed;
      std::vector<RadarBeam*> mBeamList;
 
   protected:
      void SelectAlternateFrequency(double aSimTime, int aAltFreqId = -1) override;
 
      double mAltFreqSelectDelay;
      bool   mAltFreqChangeScheduled;
      double mLastAltFreqSelectTime;
      bool   mIsFrequencyAgile;
   };
 
private:
   std::vector<RadarMode*> mRadarModeList;

   std::vector<WsfEM_Xmtr*> mXmtrList;

   std::vector<WsfEM_Rcvr*> mRcvrList;

   bool mAnyModeCanTransmit;

   bool mAnyModeCanReceive;

   WsfPlatform* mTempGeometryPtr;
};
 
#endif