WsfRF_Jammer.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 WSFRF_JAMMER_HPP
#define WSFRF_JAMMER_HPP
 
#include "wsf_mil_export.h"
 
#include <map>
#include <memory>
#include <mutex>
 
#include "WsfEM_Antenna.hpp"
class WsfEM_Interaction;
class WsfEM_Rcvr;
#include "WsfEM_Xmtr.hpp"
class WsfEW_Effect;
#include "WsfRF_Repeater.hpp"
class WsfScenario;
#include "WsfSensor.hpp"
#include "WsfTrackId.hpp"
#include "WsfWeapon.hpp"

class WSF_MIL_EXPORT WsfRF_Jammer : public WsfWeapon
{
public:
   class JammerBeam;
   class JammerMode;
 
   class WSF_MIL_EXPORT TargetingData
   {
   public:
      size_t mTargetIndex{0};

      WsfTrackId mTargetTrackId = WsfTrackId();

      double mTargetedLocationWCS[3] = {0.0, 0.0, 0.0};

      bool mTargetedLocationValid{false};
   };
 
   using TargetingDataMap = std::map<int, TargetingData>;

   enum PowerDistribution
   {
      cAVERAGE_POWER, 
      cCONSTANT_POWER 
   };
 
   WsfRF_Jammer(const WsfScenario& aScenario);
 
   WsfRF_Jammer(const WsfRF_Jammer& aSrc);
 
   WsfRF_Jammer& operator=(const WsfRF_Jammer&) = delete;
 
   ~WsfRF_Jammer() override = default;


 
   WsfWeapon* Clone() const override;
 
   bool Initialize(double aSimTime) override;
 
   bool ProcessInput(UtInput& aInput) override;


   const int* GetComponentRoles() const override; 
   void*      QueryInterface(int aRole) override; 


 
   void TurnOff(double aSimTime) override;

   void TurnOn(double aSimTime) override;




   size_t GetEM_XmtrCount() const override;

   WsfEM_Xmtr& GetEM_Xmtr(size_t aIndex) override;

   size_t GetEM_XmtrCount(size_t aModeIndex) const override;

   WsfEM_Xmtr& GetEM_Xmtr(size_t aModeIndex, size_t aIndex) override;

   WsfEM_Xmtr& GetEM_Xmtr(size_t aModeIndex, size_t aBeamIndex, size_t aSpotIndex) override;

   WsfEM_Xmtr& GetMasterXmtr();

   WsfEM_Xmtr& GetJammerXmtr(double aSimTime, double aFrequency, double aBandwidth, size_t aBeamNumber, WsfTrackId aTrackId);


 
   double GetMinimumFrequency() const;
   double GetMaximumFrequency() const;



   bool StartJamming(double      aSimTime,
                     double      aFrequency,
                     double      aBandwidth,
                     size_t      aBeamNumber,
                     WsfStringId aTechniqueId,
                     WsfTrackId  aTrackId,
                     size_t      aTargetIndex) override;

   bool StartJammingTrack(double aSimTime, WsfStringId aTechniqueId, const WsfTrack* aTrackPtr) override;

   bool StopJamming(double aSimTime, double aFrequency, double aBandwidth, size_t aBeamNumber, WsfTrackId aTrackId) override;

   bool UpdateJamming(double      aSimTime,
                      size_t      aXmtrIndex,
                      double      aFrequency,
                      double      aBandwidth,
                      WsfStringId aTechniqueId,
                      WsfTrackId  aTrackId,
                      size_t      aTargetIndex) override;


   bool ProcessMessage(double aSimTime, const WsfMessage& aMessage) override;



   void SetTargetIndex(int aId, size_t aTargetIndex) override;

   size_t GetTargetIndex(int aId) const override;

   void SetTargetTrackId(int aId, const WsfTrackId& aTargetTrackId);

   WsfTrackId GetTargetTrackId(int aId) const;

   void SetTargetedLocationWCS(int aId, const double aTargetedLocationWCS[3]) override;

   void GetTargetedLocationWCS(int aId, double aTargetedLocationWCS[3]) const override;

   bool TargetedLocationValid(int aId) const override;
 



   bool SelectEA_Technique(double      aSimTime,
                           double      aFrequency,
                           double      aBandwidth,
                           size_t      aBeamNumber,
                           WsfStringId aTechniqueId,
                           WsfTrackId  aTrackId) override;

   bool DeselectEA_Technique(double      aSimTime,
                             double      aFrequency,
                             double      aBandwidth,
                             size_t      aBeamNumber,
                             WsfStringId aTechniqueId,
                             WsfTrackId  aTrackId) override;

   bool SetEA_DeltaGainTechnique(double      aSimTime,
                                 WsfStringId aTechniqueId,
                                 bool        aOnOff,
                                 WsfStringId aEffectId,
                                 double      aJammingDeltaGain_dB,
                                 WsfStringId aSystemTypeId,
                                 WsfStringId aFunctionTypeId) override;

   bool SetEA_DeltaGainTechnique(double      aSimTime,
                                 WsfStringId aTechniqueId,
                                 bool        aOnOff,
                                 WsfStringId aEffectId,
                                 double      aJammingDeltaGain_dB,
                                 WsfStringId aSystemTypeId,
                                 WsfStringId aSystemFunctionId,
                                 double      aFrequency,
                                 double      aBandwidth,
                                 size_t      aBeamNumber,
                                 WsfTrackId  aTrackId) override;



   static double ComputeJammerPower(double                   aSimTime,
                                    WsfEM_Xmtr*              aJammerXmtrPtr,
                                    const WsfEM_Interaction& aTargetInteraction,
                                    WsfEM_Interaction&       aJammerInteraction,
                                    WsfEW_Effect*            aProcessingEW_EffectPtr = nullptr);

   static double ComputeJammerPower(double                   aSimTime,
                                    WsfEM_Xmtr*              aJammerXmtrPtr,
                                    const WsfEM_Interaction& aTargetInteraction,
                                    WsfEW_Effect*            aProcessingEW_EffectPtr = nullptr);

   static void ComputeJammerPowers(double                   aSimTime,
                                   WsfEM_Xmtr*              aJammerXmtrPtr,
                                   const WsfEM_Interaction& aTargetInteraction,
                                   WsfEM_Interaction&       aJammerInteraction,
                                   double                   aJammerPowers[],
                                   WsfEW_Effect*            aProcessingEW_EffectPtr = nullptr);

   static void ComputeJammerPowers(double                   aSimTime,
                                   WsfEM_Xmtr*              aJammerXmtrPtr,
                                   const WsfEM_Interaction& aTargetInteraction,
                                   double                   aJammerPowers[],
                                   WsfEW_Effect*            aProcessingEW_EffectPtr = nullptr);

   static void ComputeSingleJammerEffect(double             aSimTime,
                                         WsfEM_Xmtr*        aJammerXmtrPtr,
                                         WsfEM_Interaction& aTargetInteraction,
                                         WsfEM_Interaction& aJammerInteraction,
                                         bool               aApplyEW_Effects);

   static void ComputeTotalJammerEffects(double aSimTime, WsfEM_Interaction& aTargetInteraction, bool aApplyEW_Effects);

   static double ComputeReceiverGains(WsfEM_Rcvr* aRcvrPtr);



 
   unsigned int GetActiveRequestCount() const override;
   unsigned int GetMaximumRequestCount() const override;
 
   double GetQuantityRemaining() const override;
 
   size_t GetActiveBeamCount() const override;
   size_t GetMaximumBeamCount() const override;
   size_t GetActiveSpotCount(size_t aBeamNumber) const override;
   size_t GetMaximumSpotCount(size_t aBeamNumber) const override;



 
   bool WithinFieldOfView(double aSimTime, WsfPlatform* aPlatformPtr) override;
   bool WithinFieldOfView(double aSimTime, WsfTrack* aTrackPtr) override;


   class WSF_MIL_EXPORT JammerXmtr : public WsfEM_Xmtr
   {
      friend class WsfRF_Jammer::JammerBeam;
      friend class WsfRF_Jammer::JammerMode;
 
   public:
      JammerXmtr(WsfEM_Antenna* aAntennaPtr);

      JammerXmtr(const JammerXmtr& aSrc, WsfEM_Antenna* aAntennaPtr);


      bool Initialize(WsfSimulation& aSimulation) override;
      bool ProcessInput(UtInput& aInput) override;

      bool AllowInteractionWith(WsfEM_Rcvr* aRcvrPtr) override;



      void GetFrequencyBand(double aFrequencyBand[2]) const;

 
   protected:
      WsfCategoryList mIgnoredCategories;

      std::vector<WsfStringId> mIgnoredSides;

      unsigned int mIgnoredDomains;

      bool mIgnoreSameSide;

      double mFrequencyBand[2];
   };
 
   // Search vector and map to find beam and spot indexes that meet a specified criteria.
   using SpotIndexVec     = std::vector<unsigned int>;
   using BeamSpotIndexMap = std::map<unsigned int, SpotIndexVec>;

   class WSF_MIL_EXPORT JammerBeam
   {
   public:
      friend class WsfRF_Jammer::JammerMode;

      using SpotVec = std::vector<JammerXmtr*>;

      using SpotTrackIdVec = std::vector<WsfTrackId>;

      JammerBeam() = delete;

      JammerBeam(unsigned int aBeamNumber);
 
      JammerBeam(const JammerBeam& aSrc, unsigned int aBeamNumber);
 
      ~JammerBeam();



      bool Initialize(WsfSimulation& aSimulation, JammerXmtr& aXmtr);

      bool ProcessInput(UtInput& aInput);



      void Deselect(double aSimTime);

      void Select(double aSimTime);

      void SetBeamNumber(unsigned int aBeamNumber) { mBeamNumber = aBeamNumber; }

      unsigned int GetBeamNumber() const { return mBeamNumber; }



      unsigned int GetActiveSpotCount() const;

      unsigned int GetAvailableSpotCount() const;

      bool GetActiveSpotIndex(double        aFrequency,
                              double        aBandwidth,
                              WsfTrackId    aTrackId,
                              WsfTrackId    aRawTrackId,
                              SpotIndexVec& aSpotIndexVec) const;

      unsigned int mBeamNumber;

      SpotVec mActiveSpotPtrs;

      SpotVec mAvailableSpotPtrs;

      SpotTrackIdVec mSpotTrackIds;

      unsigned int mMaxNumSpotsPerBeam;

      PowerDistribution mSpotPowerDistribution;
   };
 
   class WSF_MIL_EXPORT JammerMode : public WsfWeapon::WsfWeaponMode
   {
   public:
      using BeamMap = std::map<size_t, JammerBeam*>;
 

      using XmtrVec = std::vector<JammerXmtr*>;

      JammerMode(const WsfScenario& aScenario);

      JammerMode(const JammerMode& aSrc);

      JammerMode& operator=(const JammerMode&) = delete;
 
      ~JammerMode() override;



      WsfMode* Clone() const override;

      bool Initialize(double aSimTime, WsfWeapon* aWeaponPtr) override;

      bool ProcessInput(UtInput& aInput) override;

      void Deselect(double aSimTime) override;

      void Select(double aSimTime) override;

      void AdjustPowerDistribution(PowerDistribution aGroupPowerDistribution, unsigned int aActiveGroupCount);



      size_t GetActiveBeamCount() const;

      size_t GetAvailableBeamCount() const;

      JammerBeam* GetJammerBeam(size_t aBeamNumber, bool& aIsActive) const;

      bool GetActiveBeamSpotIndexes(double            aFrequency,
                                    double            aBandwidth,
                                    size_t            aBeamNumber,
                                    WsfTrackId        aTrackId,
                                    BeamSpotIndexMap& aBeamSpotIndexMap);

      JammerBeam* GetNextAssignableBeam(size_t aBeamNumber, bool& aIsActive) const;



      size_t GetActiveXmtrSpotCount() const { return mActiveXmtrSpotPtrs.size(); }

      unsigned int GetMaximumXmtrSpotCount() const { return mMaximumNumSpots; }

 
      // TODO - make data private and protect copy constructor



      bool AdjustFrequencyBandwidth(double& aFrequency, double& aBandwidth);

      std::unique_ptr<WsfEM_Antenna> mAntenna;

      std::unique_ptr<JammerXmtr> mXmtr;

      std::unique_ptr<JammerBeam> mBeam;



      BeamMap mActiveBeamPtrs;

      BeamMap mAvailableBeamPtrs;

      bool mBeamAllocationChanged;

      unsigned int mMaxNumBeams;

      PowerDistribution mBeamPowerDistribution;



      unsigned int mMaximumNumSpots;

      XmtrVec mActiveXmtrSpotPtrs;



      WsfRF_Repeater mRepeater;

      bool mUseRepeater;
   };
 
protected:
   const TargetingDataMap& GetTargetDataMap() const { return mTargetDataMap; }
 
private:
   std::recursive_mutex& GetMutex() { return mMutex; }



   static void ComputeJammerEffect(double                   aSimTime,
                                   WsfEM_Xmtr*              aXmtrPtr,
                                   const WsfEM_Interaction& aTargetInteraction,
                                   WsfEM_Interaction&       aJammerInteraction,
                                   bool                     aCalculateEW_Effects,
                                   bool                     aIntermediateCalculation,
                                   WsfEW_Effect*            aProcessingEW_EffectPtr = nullptr);

   bool SelectTarget(double aSimTime, WsfEM_Xmtr* aXmtrPtr);

   bool ClearTarget(WsfEM_Xmtr* aXmtrPtr);

   WsfLocalTrack* FindTargetTrack(const WsfTrackId& aTargetTrackId) const;


   void SensorTrackDropped(double aSimTime, WsfTrackId aTrackId, size_t aTargetIndex);
   void SensorTrackInitiated(double aSimTime, const WsfTrack* aTrackPtr);
   void SensorTrackUpdated(double aSimTime, const WsfTrack* aTrackPtr);

   static bool UpdateRepeaterResult(double                   aSimTime,
                                    WsfEM_Xmtr*              aXmtrPtr,
                                    WsfSensorResult&         aResult,
                                    WsfEM_Interaction&       aJammerInteraction,
                                    const WsfEM_Interaction& aTargetInteraction);



   void InitializeJammerGroup();

   unsigned int GetActiveGroupCount() const;

   using JammerGroup = std::vector<WsfWeapon*>;

   JammerGroup mJammerGroup;

   WsfStringId mJammerGroupNameId;

   PowerDistribution mGroupPowerDistribution;


   std::vector<JammerMode*> mJammerModeList;

   bool mJammerInitialized;

   TargetingDataMap mTargetDataMap;
 
   mutable std::recursive_mutex mMutex;
};
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(WsfRF_Jammer, cWSF_COMPONENT_RF_JAMMER)
 
#endif