WsfFalseTargetScreener.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 WSFFALSETARGETSCREENER_HPP
#define WSFFALSETARGETSCREENER_HPP
 
#include "wsf_mil_export.h"
 
#include <map>
#include <vector>
 
#include "UtCloneablePtr.hpp"
class UtInput;
class UtInputBlock;
#include "UtRandom.hpp"
 
class WsfEM_Xmtr;
class WsfEM_Interaction;
class WsfEW_FalseTargetEffect;
#include "WsfFalseTarget.hpp"
#include "WsfObject.hpp"
#include "WsfPlatform.hpp"
#include "WsfSensor.hpp"
class WsfSensorMode;
class WsfTrack;
#include "WsfTrackId.hpp"

class WSF_MIL_EXPORT WsfFalseTargetScreener : public WsfObject
{
public:
   using FT_JammerPair      = std::pair<WsfFalseTarget*, WsfEM_Xmtr*>;
   using FT_JammerIdPair    = std::pair<WsfStringId, unsigned int>;
   using FT_JammerVec       = std::vector<FT_JammerPair>;
   using FT_Result          = std::map<unsigned int, WsfEM_Interaction*>;
   using BlipAlloc          = std::map<WsfFalseTarget::BlipBehavior, int>;
   using BlipIdFTJammerList = std::vector<std::pair<size_t, FT_JammerPair>>;
   using TargetIds          = std::vector<size_t>;
   using RR_Map             = std::map<WsfFalseTarget::BlipBehavior, double>; // rejection ratio
   using RR_MapPair         = std::pair<WsfFalseTarget::BlipBehavior, double>;
   using TrackIdMap         = std::map<size_t, WsfTrackId>;
 
   struct ForceData
   {
      ForceData(double aAzimuth, double aRange, double aSNR)
         : mAzimuth(aAzimuth)
         , mRange(aRange)
         , mSNR(aSNR)
      {
      }
 
      double mAzimuth;
      double mRange;
      double mSNR;
   };
   using BlipIdToForceDataMap = std::map<size_t, ForceData>;

   enum OutputType
   {
      cPLOT,    
      cTRACKS,  
      cOVERLOAD 
   };

   enum Picture
   {
      cPERFECT,    
      cDEGRADED,   
      cINEFFECTIVE 
   };

   enum RangeForceType
   {
      cFORCE_NEITHER = 0, //<! The part cannot be slewed
      cFORCE_INSIDE  = 1, //<! The part can be slewed only in azimuth
      cFORCE_OUTSIDE = 2, //<! The part can be slewed only in elevation
      cFORCE_IN_OUT  = 3  //<! The part can be slewed in both azimuth and elevation
   };
 
   static WsfFalseTargetScreener* Find(const WsfSensorMode& aSensorMode);
 
   explicit WsfFalseTargetScreener(const WsfScenario& aScenario);
   WsfFalseTargetScreener(const WsfFalseTargetScreener& aSrc);
   WsfFalseTargetScreener& operator=(const WsfFalseTargetScreener&) = delete;
   ~WsfFalseTargetScreener() override;
   WsfFalseTargetScreener* Clone() const override;
 
   virtual bool Initialize(double aSimTime, WsfSensorMode* aSensorModePtr, bool aReportsSignalToNoise);
   bool         ProcessInput(UtInput& aInput) override;
   void         ProcessInputBlock(UtInputBlock& aInputBlock);
 
   bool NeedsUpdated(double aSimTime);
   void Update(double aSimTime, WsfSensor::Settings& aSettings);
   void Reset();
   void PrintScreenerState(double aSimTime);
 
   void           SetSensorModePtr(WsfSensorMode* aSensorModePtr) { mSensorModePtr = aSensorModePtr; }
   WsfSensorMode* GetSensorModePtr() { return mSensorModePtr; }
 
   bool ReportsSNR() const { return mReportsSignalToNoise; }
 
   OutputType GetScreenerOutputType() const { return mOutputType; }


   bool GetDebugEnabled() const { return mDebugEnabled; }
   bool GetScreenerValid() { return mScreenerValid; }


   int    GetPlotCapacity() const { return mPlotCapacity; }
   int    GetTrackCapacity() const { return mTrackCapacity; }
   int    GetTransferCapacity() const { return mTransferCapacity; }
   int    GetRangeForceType() const { return mRangeForceType; }
   double GetForceSectorArc() const { return mForceSectorArc; }
   double GetForceRange() const { return mForceRange; }
   int    GetForceCountPerRangeSector() const { return mForceCountPerRangeSector; }
   double GetForceJtoSDeltaThreshold() const { return mForceJtoSDeltaThreshold; }


   bool                  FindTrackableBlip(size_t aBlipId);
   BlipIdFTJammerList&   GetTrackableBlipIds() { return mTrackableBlipIds; }
   WsfFalseTarget::Blip* GetTrackableBlip(size_t aBlipId);
 
   bool                  FindBlockedBlip(size_t aBlipId);
   BlipIdFTJammerList&   GetBlockedBlipIds() { return mBlockedBlipIds; }
   WsfFalseTarget::Blip* GetBlockedBlip(size_t aBlipId);
 
   bool                  FindUndetectedBlip(size_t aBlipId);
   BlipIdFTJammerList&   GetUndetectedBlipIds() { return mUndetectedBlipIds; }
   WsfFalseTarget::Blip* GetUndetectedBlip(size_t aBlipId);
 
   WsfFalseTarget* GetFalseTarget(const std::string& aName, WsfEM_Xmtr* aJammerXmtrPtr) const;
 
   bool AddFalseTarget(FT_JammerPair aFT_JammerPair);
   bool RemoveFalseTarget(FT_JammerPair aFT_JammerPair);
   bool RemoveFalseTargets(WsfFalseTarget* aFalseTargetPtr);
   bool FindFalseTarget(FT_JammerPair aFT_JammerPair);
 
   WsfEM_Xmtr* GetJammerXmtr(WsfFalseTarget* aFalseTargetPtr) const;
   bool        RemoveJammerXmtr(WsfEM_Xmtr* aJammerXmtrPtr);
 
   TrackIdMap GetActiveTargetTracks() const;
   TrackIdMap GetBlockedTargets() { return mBlockedTargetTrackIds; }


   // TODO - see about refactoring some of these into WsfDefaultSensorTracker
   void       AddFalseTargetTrack(size_t aBlipId, WsfTrackId aTrackId);
   void       DropFalseTargetTrack(size_t aBlipId);
   bool       FindFalseTargetTrack(size_t aBlipId);
   TrackIdMap GetFalseTargetTracks() { return mFalseTargetTrackIds; };
 
   bool IsRequestBasedTracking() const { return mRequestBasedTracking; }
   bool OnlyScreenFT_TrackRequests() const { return mOnlyScreenFT_Requests; }
 
   inline void AddTargetTrack(WsfStringInt aObjectId, WsfTrack* aValidTrackPtr)
   {
      return UpdateTargetTrack(aObjectId, aValidTrackPtr);
   }
 
   void UpdateTargetTrack(size_t aObjectId, WsfTrack* aValidTrackPtr);
   void DropTargetTrack(size_t aObjectId);
   bool AllowTargetTrack(double aSimTime, size_t aObjectId, WsfTrack* aTrackPtr, const WsfSensorResult& aResult);
   bool AllowTrackReporting(size_t aObjectId, const WsfTrack* aTrackPtr);
   void TracksTransfered();
   bool TrackExists(size_t aObjectId);
 
   bool IsRadarModeTurnedOn();


 
   int GetPassedFalseTargetNumber() const { return mPassedFalseTargetNumber; }
   int GetPassedRealTargetNumber() const { return mPassedRealTargetNumber; }
   int GetFalseTargetNumber() const { return (int)mTrackableBlipIds.size(); }
   int GetRealTargetNumber() const { return (int)(mActiveTargetTrackIds.size() + mForcedTargetTrackIds.size()); }
 
   WsfPlatform*   GetTempPlatform() { return mTempPlatformPtr.get(); }
   WsfSimulation* GetSimulation() const;
 
protected:
   TrackIdMap mReportingTrackIds;

   FT_JammerVec mFalseTargetsJammers;



   TrackIdMap mActiveTargetTrackIds;

   TrackIdMap mBlockedTargetTrackIds;

   TrackIdMap mForcedTargetTrackIds;

   TrackIdMap mNullTargetTrackIds;
 
   bool mTargetsAdjusted;
   bool mTargetsInvalid;

   double mLastUpdate;



   BlipIdFTJammerList mBlockedBlipIds;

   BlipIdFTJammerList mUndetectedBlipIds;

   BlipIdFTJammerList mTrackableBlipIds;
 
   bool mBlipsAdjusted;
   bool mBlipsInvalid;
 
   int GetAllowedRealTargetNumber() const { return mAllowedRealTargetNumber; }
 
   void CheckFT_Toggle();
 
   void RemoveBlips(WsfFalseTarget* aFalseTargetPtr, WsfEM_Xmtr* aJammerXmtrPtr);
 
   void AdjustTargetsAndBlips(double aSimTime);
   bool ForceTargetTrack(double aRadar2TargetRange, double aRadar2TargetAzimuth, double aTargetSNR);
 
private:
   void SetScreenerValid(bool aBoolValue) { mScreenerValid = aBoolValue; }
 
   bool CreateBlips(WsfFalseTarget* aFalseTargetPtr, WsfEM_Xmtr* aJammerXmtrPtr);
   void RemoveBlockedBlips(WsfFalseTarget* aFalseTargetPtr, WsfEM_Xmtr* aJammerXmtr);
   void RemoveUndetectedBlips(WsfFalseTarget* aFalseTargetPtr, WsfEM_Xmtr* aJammerXmtr);
   void RemoveTrackableBlips(WsfFalseTarget* aFalseTargetPtr, WsfEM_Xmtr* aJammerXmtr);
   void UpdateBlips(double aSimTime, WsfSensor::Settings& aSettings);
   void UpdateFalseTargetJammers(double aSimTime);
 
   size_t PruneTargetTracks(size_t aPruneQuantity);
 
   size_t AddTrackableBlips(size_t aAddQuantity);
   size_t PruneTrackableBlips(size_t aPruneQuantity);
 
   bool RejectBlips(double aSimTime);

   WsfSensorMode* mSensorModePtr;

   bool mReportsSignalToNoise;
 
   bool mDebugEnabled;
   bool mScreenerValid;
 
   ut::Random mRandom;
 
   BlipAlloc mBlipsAllocation;

   RR_Map mInitialRejectionRatios;

   RR_Map mRejectionRatios;

   OutputType mOutputType;

   bool mTrackReportingWhenFlooded;

   bool mProduceOutputPlot;

   bool mRequestBasedTracking;

   bool mOnlyScreenFT_Requests;
 
   Picture mPicture;
 
   //@name Maximum capacity variables.

   int mPlotCapacity;

   int mTrackCapacity;

   int mTransferCapacity;

   bool mFT_JammerStatusChange;

   double mLastBlipUpdate;


   int    mForceCountPerRangeSector;
   double mForceJtoSDeltaThreshold;
   double mForceSectorArc;
   double mForceRange;
 
   RangeForceType mRangeForceType;

   // Used to force target detections and tracks if the target range is less than this value.
   double mMinimumBlipRange;

   // Used to force target detections and tracks if the target range is less than this value.
   double mMaximumBlipRange;

   BlipIdToForceDataMap mBlipIdToForceDataMap;

   int mPassedFalseTargetNumber;

   int mPassedRealTargetNumber;

   int mAllowedFalseTargetNumber;

   int mAllowedRealTargetNumber;

   TrackIdMap mFalseTargetTrackIds;

   ut::CloneablePtr<WsfPlatform> mTempPlatformPtr;
};
 
#endif