WsfRadarMTI_AdjSignalProcessor.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 WSFRADARMTI_ADJSIGNALPROCESSOR
#define WSFRADARMTI_ADJSIGNALPROCESSOR
 
#include "wsf_export.h"
 
#include "UtTable.hpp"
#include "WsfMTI_TableManager.hpp"
#include "WsfSensor.hpp"
#include "WsfSensorSignalProcessor.hpp"
 
class RadarMode;
class Result;

 
class WSF_EXPORT WsfRadarMTI_AdjSignalProcessor : public WsfSensorSignalProcessor
{
public:
   enum MTI_Type
   {
      cMTIT_DATA_TABLE,       
      cMTIT_ADJUSTMENT_TABLE, 
      cMTIT_PROCESSOR         
   };
 
   WsfRadarMTI_AdjSignalProcessor(MTI_Type aMTI_Type);
   WsfRadarMTI_AdjSignalProcessor(const WsfRadarMTI_AdjSignalProcessor&) = default;
   WsfRadarMTI_AdjSignalProcessor& operator=(const WsfRadarMTI_AdjSignalProcessor&) = default;
   ~WsfRadarMTI_AdjSignalProcessor() override                                       = default;
 
   static WsfSensorSignalProcessor* ObjectFactory(const std::string& aTypeName);
 
   WsfSensorSignalProcessor* Clone() const override;
 
   bool Initialize(double aSimTime, WsfSensor* aSensorPtr, WsfSensorMode* aModePtr, size_t aBeamIndex = 0) override;
 
   bool ProcessInput(UtInput& aInput) override;
 
   void Execute(double aSimTime, WsfSensorResult& aResult) override;
 
private:
   WsfRadarMTI_AdjSignalProcessor();
 
   bool ProcessDataTableInput(UtInput& aInput);
   bool ProcessAdjustmentTableInput(UtInput& aInput);
   bool ProcessMTI_ProcessorInput(UtInput& aInput);

   double ComputeMTI_Response(WsfSensorResult& aResult, const int aTypeFlag);

   double GetTableResponse(const double aSlantRange);

   WsfMTI_TableManager::MTI_AdjustmentTable* GetMTI_AdjustmentTable() { return mMTI_AdjustmentTablePtr.get(); }
 
   void ReadTable(UtInput& aInput, WsfMTI_TableManager::MTI_AdjustmentTable& aMTI_AdjustmentTable);
 
   double ComputeMTI_Effects(WsfSensorResult& aResult, const int aTypeFlag);
 
   // bool InitializeMTI(WsfSensorMode& aMode);
 
   // void ComputeClutterAttenuationFactor(WsfSensorMode& aMode);

   bool mFilterOwnshipFromDoppler;

   MTI_Type mMTI_Type;

   double mMTI_MinResponse; // dB

   // std::vector<double>    mMTI_MinRanges;      // meters

   // std::vector<double>    mMTI_MaxRanges;      // meters

   // std::vector<double>    mMTI_MinAngles;      // radians

   // std::vector<double>    mMTI_MaxAngles;      // radians

   UtTable::Curve mResponseTable; // future implementation



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

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


   double mMTI_MaxRange; 
   double mMTI_InterpulsePeriod_1;
   double mMTI_InterpulsePeriod_2;
   double mMTI_StabilityConstant;
   double mMTI_Weights[3];
   int    mMTI_NumberOfStages;
   bool   mMTI_ClutterLock;
   bool   mMTI_UpWind;
   double mClutterAttenuationFactor;
   double mInputClutterAttenuationFactor;
};
 
#endif