WsfEW_Effect.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 WSFEW_EFFECT_HPP
#define WSFEW_EFFECT_HPP
 
#include "wsf_mil_export.h"
 
#include <set>
 
class UtInput;
class UtInputBlock;
#include "UtLog.hpp"
#include "UtOptional.hpp"
#include "UtRandom.hpp"
#include "WsfEM_Rcvr.hpp"
#include "WsfEM_Xmtr.hpp"
class WsfEW_EA;
class WsfEW_EA_EP;
class WsfEW_EP;
class WsfEW_Effects;
#include "WsfEW_Types.hpp"
#include "WsfObject.hpp"
class WsfPlatform;
class WsfEW_Technique;
class WsfEM_Interaction;
 

 
class WSF_MIL_EXPORT WsfEW_Effect : public WsfObject
{
public:
   enum Behavior
   {
      cEB_UNDEFINED           = 1,
      cEB_DROP_TRACK          = cEB_UNDEFINED << 1,  
      cEB_MAINTAIN_TRACK      = cEB_UNDEFINED << 2,  
      cEB_TRACK_ERROR         = cEB_UNDEFINED << 3,  
      cEB_DROP_MESSAGE        = cEB_UNDEFINED << 4,  
      cEB_MAINTAIN_MESSAGE    = cEB_UNDEFINED << 5,  
      cEB_MESSAGE_ERROR       = cEB_UNDEFINED << 6,  
      cEB_JAMMER_POWER_EFFECT = cEB_UNDEFINED << 7,  
      cEB_SIGNAL_POWER_EFFECT = cEB_UNDEFINED << 8,  
      cEB_SLC_DEGRADE_EFFECT  = cEB_UNDEFINED << 9,  
      cEB_FALSE_TARGET_EFFECT = cEB_UNDEFINED << 10, 
      cEB_PULSE_EFFECT        = cEB_UNDEFINED << 11, 
      cEB_AGILITY_EFFECT      = cEB_UNDEFINED << 12, 
      cEB_REPEATER_EFFECT     = cEB_UNDEFINED << 13, 
      cEB_REPEATER_UPDATE     = cEB_UNDEFINED << 14, 
      cEB_FLOODED_BLOCKED = cEB_UNDEFINED << 15, 
      cEB_FLOODED_MAINTAINED = cEB_UNDEFINED << 16, 
      cEB_JAM_STROBE_EFFECT  = cEB_UNDEFINED << 17, 
      cEB_TARGET_REJECT_EFFECT = cEB_UNDEFINED << 18, 
      cEB_NEXT_FREE_MASK = cEB_UNDEFINED << 19 
   };

   enum Coherency
   {
      cEC_NONE              = 1,
      cEC_NONCOHERENT       = cEC_NONE << 1,
      cEC_COHERENT          = cEC_NONE << 2,
      cEC_NONCOHERENT_PULSE = cEC_NONE << 3,
      cEC_COHERENT_PULSE    = cEC_NONE << 4
   };

   enum ModulationType
   {
      cEM_NONE        = 1,
      cEM_CW          = cEM_NONE << 1,
      cEM_COHPULSE    = cEM_NONE << 2,
      cEM_NONCOHPULSE = cEM_NONE << 3,
      cEM_LINEARFM    = cEM_NONE << 4,
      cEM_NONLINEARFM = cEM_NONE << 5,
      cEM_PHASEKEY    = cEM_NONE << 6,
      cEM_PHASEMOD    = cEM_NONE << 7,
      cEM_PHASECODE   = cEM_NONE << 8,
      cEM_ASK         = cEM_NONE << 9,
      cEM_FSK         = cEM_NONE << 10,
      cEM_PSK         = cEM_NONE << 11,
      cEM_BPSK        = cEM_NONE << 12,
      cEM_QPSK        = cEM_NONE << 13,
      cEM_DPSK        = cEM_NONE << 14,
      cEM_QAM         = cEM_NONE << 15
   };

   enum TargetProtectionType
   {
      cTP_ALL,
      cTP_NON_SELF_PROTECT,
      cTP_SELF_PROTECT
   };

   enum SystemFunction
   {
      cES_UNDEFINED      = 1,
      cES_COMM           = cES_UNDEFINED << 1, 
      cES_SENSOR         = cES_UNDEFINED << 2, 
      cES_JAMMER         = cES_UNDEFINED << 3, 
      cES_NEXT_FREE_MASK = cES_UNDEFINED << 4  
   };
 
   WsfEW_Effect()        = default;
   WsfEW_Effect& operator=(const WsfEW_Effect&) = delete;
   ~WsfEW_Effect() override;



   WsfEW_Effect* Clone() const override = 0;
 
   virtual bool Initialize(WsfSimulation& aSimulation);
   bool         ProcessInput(UtInput& aInput) override;


   // =================================================================================================
   virtual void ProcessUnmitigatedEffect(double                                 aSimTime,
                                         const WsfEM_Interaction&               aTargetInteraction,
                                         const WsfEM_Interaction&               aJammerToTgtInteraction,
                                         const ut::optional<WsfEM_Interaction>& aTgtToJammerInteraction,
                                         WsfEW_Effects&                         aEW_Effects);
 
   // =================================================================================================
   virtual void ProcessMitigatedEffect(double                                 aSimTime,
                                       const WsfEM_Interaction&               aTargetInteraction,
                                       const WsfEM_Interaction&               aJammerToTgtInteraction,
                                       const ut::optional<WsfEM_Interaction>& aTgtToJammerInteraction,
                                       WsfEW_Effects&                         aEW_Effects,
                                       WsfEW_Effect*                          aEW_EffectPtr = nullptr);


   virtual void ApplyUnmitigatedEffect(WsfEW_Effects& aEW_Effects) const = 0;
 
   virtual void ApplyMitigatedEffect(WsfEW_Effect* aEW_EffectPtr, WsfEW_Effects& aEW_Effects) const = 0;
 
   // =================================================================================================
   virtual void UpdateEffects(double                                 aSimTime,
                              const WsfEM_Interaction&               aTargetInteraction,
                              const WsfEM_Interaction&               aJammerToTgtInteraction,
                              const ut::optional<WsfEM_Interaction>& aTgtToJammerInteraction,
                              WsfEW_Effects&                         aEW_Effects,
                              WsfEW_Effect*                          aEW_EffectPtr = nullptr);


 
   virtual void RemoveJammerXmtr(unsigned int aXmtrId);
   virtual void RemoveJammerXmtr(WsfEM_Xmtr* aJammerXmtrPtr);



   void SetSystemFunctionMask(SystemFunction aSystemFunction) { mSystemFunctionMask = aSystemFunction; }
   void SetSystemFunctionMask(const std::string& aSystemFunctionId);

   void AddSystemFunctionMask(SystemFunction aSystemFunction) { mSystemFunctionMask |= aSystemFunction; }
   void AddSystemFunctionMask(const std::string& aSystemFunctionId);

   unsigned int GetSystemFunctionMask() const { return mSystemFunctionMask; }
 
   static WsfEW_Effect::SystemFunction ConvertToEW_SystemFunction(WsfEM_Rcvr::RcvrFunction aRcvrFunction);
   static WsfEW_Effect::SystemFunction ConvertToEW_SystemFunction(WsfEM_Xmtr::XmtrFunction aXmtrFunction);



   void SetCoherencyMask(Coherency aCoherency) { mCoherencyMask = aCoherency; }

   void AddCoherencyMask(Coherency aCoherency) { mCoherencyMask |= aCoherency; }

   unsigned int GetCoherencyMask() const { return mCoherencyMask; }
 
   static unsigned int ConvertCoherencyIdToMask(WsfStringId aCoherencyId);
 



   void SetBehavior(Behavior aBehavior) { mBehavior = aBehavior; }

   Behavior GetBehavior() const { return mBehavior; }



   void SetDebug(bool aDebug) { mDebug = aDebug; }

   bool DebugEnabled() const { return mDebug; }



   void SetEA_EP_Ptr(WsfEW_EA_EP* aPtr) { mEA_EP_Ptr = aPtr; }

   WsfEW_EA_EP* GetEA_EP_Ptr() const { return mEA_EP_Ptr; }

   WsfEW_EA* GetEA_Ptr() const;

   WsfEW_EP* GetEP_Ptr() const;

   WsfEW_Technique* GetTechniquePtr() const { return mTechniquePtr; }

   void SetTechniquePtr(WsfEW_Technique* aPtr) { mTechniquePtr = aPtr; }

   virtual double GetJammingPulseDensity() const { return 1.0; }
   virtual double GetJammingPulseDensity(WsfEM_Xmtr* aXmtrPtr) const { return 1.0; }
 
   virtual bool AllowTarget(WsfPlatform* aXmtrPlatform, WsfPlatform* aTargetPlatform) const;


 
   virtual void UpdateCurrentIds(WsfEM_Rcvr* aRcvrPtr, WsfEM_Xmtr* aXmtrPtr, WsfPlatform* aTargetPtr);
 
   WsfSimulation* GetSimulation() const;
 
   ut::Random& GetRandom() { return mRandom; }
 
protected:
   class WSF_MIL_EXPORT EffectData : public WsfEW_Types::EW_EffectData
   {
   public:
      EffectData()        = default;
      EffectData& operator=(const EffectData&) = delete;
      ~EffectData() override                   = default;
 
      bool ProcessInput(UtInput& aInput) override;
      bool Initialize(WsfSimulation& aSimulation) override;
 
      EW_EffectData* Clone() const override;
 
      void Reset() override;
 
      WsfEW_Effect* GetEffectPtr() { return mEffectPtr; }
      void          SetEffectPtr(WsfEW_Effect* aEffectPtr) { mEffectPtr = aEffectPtr; }
 
   protected:
      EffectData(const EffectData& aSrc);
 
   private:
      WsfEW_Effect* mEffectPtr{nullptr}; 
   };
 
   WsfEW_Effect(const WsfEW_Effect& aSrc);

   virtual void PrintUpdateMessage(ut::log::MessageStream& aStream, double aSimTime, WsfEW_Effect* aEW_EffectPtr = nullptr);
 
   void ResetProtectionTypeFlag(WsfEM_Xmtr* aXmtrPtr, const WsfEM_Interaction& aTargetInteraction, WsfEW_Effects& aEW_Effects);


   bool                ProcessEffectDataBlock(UtInputBlock& aInputBlock, WsfStringId aSystemTypeId);
   virtual EffectData& GetEffectData(WsfStringId aSystemTypeId);
   void                ResetEffectData(WsfStringId aSystemTypeId){};
   bool                EffectDataExists(WsfStringId aSystemTypeId) const;
   virtual EffectData* NewEffectData() { return new EffectData(); }
   void                InsertNewEffectData(WsfStringId aSystemTypeId, WsfEW_Types::EW_EffectData* aEffectPtr);

   virtual EffectData* PropagateEffectDataPtr(WsfStringId aSystemTypeId);
 
 
   unsigned int mSystemFunctionMask{cES_UNDEFINED}; 
   Behavior     mBehavior{cEB_UNDEFINED};           
   unsigned int mCoherencyMask{cEC_NONE};           
   bool         mDebug{false};                      
 
   // The below values change after each call to UpdateEffects and anytime the UpdateCurrentIds is called.
   WsfStringId mCurrentTargetId{nullptr};       
   WsfStringId mCurrentXmtrPlatformId{nullptr}; 
   WsfStringId mCurrentRcvrPlatformId{nullptr}; 
   int         mCurrentXmtrUniqueId{0};         
   int         mCurrentRcvrUniqueId{0};         

   WsfStringId mEffectedSystemId{nullptr};

   WsfStringId mEffectingSystemId{nullptr};

   bool mUpdatingEffect{true}; // set to true initially to prevent updates before initialization
 
   using EffectDataMap = std::map<WsfStringId, EffectData*>; // Main effect data map.

   EffectDataMap mEffectDataMap;
 
private:
   using TargetAllowRejectSet = std::set<WsfStringId>;
 
   WsfEW_Technique* mTechniquePtr{nullptr}; 
   WsfEW_EA_EP*     mEA_EP_Ptr{nullptr};    
 
   TargetProtectionType mProtectionType{
      cTP_ALL}; 
   TargetAllowRejectSet mAllowedTargetSet;  
   TargetAllowRejectSet mRejectedTargetSet; 
 
   ut::Random mRandom;
};
 
#endif