WsfEM_XmtrRcvr.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 WSFEM_XMTRRCVR_HPP
#define WSFEM_XMTRRCVR_HPP
 
#include "wsf_export.h"
 
#include <array>
#include <vector>
 
class UtInput;
#include "UtScriptAccessible.hpp"
class WsfAntennaPattern;
class WsfArticulatedPart;
#include "WsfAuxDataEnabled.hpp"
class WsfEM_Antenna;
class WsfEM_Attenuation;
class WsfEM_Manager;
class WsfEM_Propagation;
#include "WsfEM_Types.hpp"
class WsfScenario;
class WsfMode;
class WsfPlatform;
class WsfPlatformPart;
class WsfSimulation;
#include "WsfStringId.hpp"
#include "WsfUniqueId.hpp"

class WSF_EXPORT WsfEM_XmtrRcvr : public UtScriptAccessible, public WsfUniqueId, public WsfAuxDataEnabled
{
public:
   using AntennaPatternList = std::vector<std::pair<WsfAntennaPattern*, double>>;
 
   WsfEM_XmtrRcvr(WsfEM_Antenna* aAntennaPtr = nullptr);
   WsfEM_XmtrRcvr(const WsfEM_XmtrRcvr& aSrc, WsfEM_Antenna* aAntennaPtr);
   virtual ~WsfEM_XmtrRcvr();
 
   WsfPlatform* GetPlatform() const;
 
   WsfArticulatedPart* GetArticulatedPart() const;
 
   virtual bool Initialize(WsfSimulation& aSimulation);
 
   virtual bool ProcessInput(UtInput& aInput);
 
   virtual void UpdatePosition(double aSimTime);
 
   const char* GetScriptClassName() const override { return "WsfEM_XmtrRcvr"; }

   WsfEM_Attenuation* GetAttenuationModel() const { return mAttenuationPtr; }
 
   void SetAttenuationModel(WsfEM_Attenuation* aAttenuationPtr);

   WsfStringId GetAttenuationModelType() const { return mAttenuationType; }

   void SetAttenuationModelType(WsfStringId aAttenuationType) { mAttenuationType = aAttenuationType; }

   WsfEM_Propagation* GetPropagationModel() const { return mPropagationPtr; }
 
   void SetPropagationModel(WsfEM_Propagation* aPropagationPtr);

   WsfStringId GetPropagationModelType() const { return mPropagationType; }

   void SetPropagationModelType(WsfStringId aPropagationType) { mPropagationType = aPropagationType; }



   WsfEM_Antenna* GetAntenna() const { return mAntennaPtr; }

   void SetAntenna(WsfEM_Antenna* aAntennaPtr) { mAntennaPtr = aAntennaPtr; }
 
   WsfAntennaPattern* GetAntennaPattern(WsfEM_Types::Polarization aPolarization, double aFrequency) const;
 
   bool SetAntennaPattern(WsfAntennaPattern* aAntennaPatternPtr, WsfEM_Types::Polarization aPolarization, double aFrequency);
 
   bool AddAntennaPattern(WsfAntennaPattern* aAntennaPatternPtr, WsfEM_Types::Polarization aPolarization, double aFrequency);
 
   const AntennaPatternList* GetAntennaPatternList(WsfEM_Types::Polarization aPolarization) const;

   double GetBeamTilt() const { return mBeamTilt; }

   void SetBeamTilt(double aBeamTilt) { mBeamTilt = aBeamTilt; }
 
   virtual double GetAntennaGain(WsfEM_Types::Polarization aPolarization,
                                 double                    aFrequency,
                                 double                    aTargetAz,
                                 double                    aTargetEl,
                                 double                    aEBS_Az,
                                 double                    aEBS_El);
 
   WSF_DEPRECATED virtual double GetAzimuthBeamwidth() const final { return GetAzimuthBeamwidth(0.0, 0.0); }
 
   virtual double GetAzimuthBeamwidth(double aEBS_Azimuth, double aEBS_Elevation) const;
 
   WSF_DEPRECATED virtual double GetElevationBeamwidth() const final { return GetElevationBeamwidth(0.0, 0.0); }
 
   virtual double GetElevationBeamwidth(double aEBS_Azimuth, double aEBS_Elevation) const;
 
   virtual double GetPeakAntennaGain() const;
 
   virtual double GetMinimumAntennaGain() const;
 
   virtual void SetAntennaBeamCount(unsigned int aBeamCount);




   bool DebugEnabled() const { return mDebugEnabled; }

   void SetDebugEnabled(bool aDebugEnabled) { mDebugEnabled = aDebugEnabled; }

 
   static void AssociateSystems(WsfEM_XmtrRcvr* aSystem1Ptr, WsfEM_XmtrRcvr* aSystem2Ptr);

   bool IsHorizonMaskingEnabled() const;

   bool IsTerrainMaskingEnabled() const;

   std::string MaskingMode() const;

   void SetMaskingMode(const std::string& aTerrainMaskingMode);

   bool CheckMasking() const { return mCheckMasking; }

   void SetCheckMasking(bool aCheckMasking) { mCheckMasking = aCheckMasking; }

   void DisableMaskingCheck() { mCheckMasking = false; }



   WsfMode* GetMode() const { return mModePtr; }

   void SetMode(WsfMode* aModePtr) { mModePtr = aModePtr; }

   size_t GetIndex() const { return mIndex; }

   void SetIndex(size_t aIndex) { mIndex = aIndex; }
 
   WsfSimulation* GetSimulation() const;
 
   WsfEM_Manager* GetEM_Manager() const;

   double GetEarthRadiusMultiplier() const { return mEarthRadiusMultiplier; }

   double GetFrequency() const { return mFrequency; }
 
   double GetWavelength() const;

   double GetBandwidth() const { return mBandwidth; }

   bool IsBandwidthExplicit() const { return mExplicitBandwidth; }

   double GetInternalLoss() const { return mInternalLoss; }

   WsfEM_Types::Polarization GetPolarization() const { return mPolarization; }

   void SetEarthRadiusMultiplier(double aMultiplier) { mEarthRadiusMultiplier = aMultiplier; }
 
   virtual void SetFrequency(double aFrequency);
 
   virtual void SetBandwidth(double aBandwidth);

   void SetInternalLoss(double aInternalLoss) { mInternalLoss = aInternalLoss; }
 
   virtual void SetPolarization(WsfEM_Types::Polarization aPolarization);



   void SetAttenuationInputEnabled(bool aEnabled) { mAttenuationInputEnabled = aEnabled; }
   void SetPropagationInputEnabled(bool aEnabled) { mPropagationInputEnabled = aEnabled; }
 
protected:
   WsfStringId mAttenuationType;

   WsfStringId mPropagationType;

   WsfEM_Attenuation* mAttenuationPtr;

   WsfEM_Propagation* mPropagationPtr;

   WsfMode* mModePtr;

   WsfEM_Antenna* mAntennaPtr;

   std::array<AntennaPatternList, WsfEM_Types::cPOL_COUNT> mPatternTables{};

   WsfEM_XmtrRcvr* mAssociatePtr;

   double mBeamTilt;
 
   double                    mEarthRadiusMultiplier;
   double                    mFrequency;
   double                    mBandwidth;
   double                    mInternalLoss;
   WsfEM_Types::Polarization mPolarization;

   size_t mIndex;

   std::array<bool, WsfEM_Types::cPOL_COUNT> mUsedExplicitPolarization{{false}};
 
   bool mDebugEnabled;
 
   unsigned int mTerrainMaskingMode; 
   bool         mCheckMasking;       
   bool         mExplicitBandwidth;  
 
private:
   void ClearAntennaPatterns();

   bool mAttenuationInputEnabled;
   bool mPropagationInputEnabled;
};
 
#endif