WsfEM_Xmtr.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_XMTR_HPP
#define WSFEM_XMTR_HPP
 
#include "wsf_export.h"
 
#include <map>
#include <vector>
 
class WsfAntennaPattern;
#include "WsfComponent.hpp"
#include "WsfComponentList.hpp"
class WsfEM_Antenna;
class WsfEM_Interaction;
class WsfEM_Rcvr;
#include "WsfEM_Types.hpp"
class WsfEM_Xmtr;
#include "WsfEM_XmtrRcvr.hpp"
class WsfPlatform;
#include "WsfStringId.hpp"

using WsfEM_XmtrComponent = WsfComponentT<WsfEM_Xmtr>;

class WSF_EXPORT WsfEM_Xmtr : public WsfEM_XmtrRcvr
{
public:


   using Component     = WsfEM_XmtrComponent;
   using ComponentList = WsfComponentListT<WsfEM_XmtrComponent>;

   using PowerList = std::vector<std::pair<double, double>>;

   enum XmtrFunction
   {
      cXF_UNDEFINED, 
      cXF_COMM,      
      cXF_SENSOR,    
      cXF_INTERFERER 
   };
 
   WsfEM_Xmtr(XmtrFunction aFunction, WsfEM_Antenna* aAntennaPtr = nullptr);
   WsfEM_Xmtr(const WsfEM_Xmtr& aSrc, WsfEM_Antenna* aAntennaPtr = nullptr);
   ~WsfEM_Xmtr() override;
   WsfEM_Xmtr& operator=(const WsfEM_Xmtr&) = delete;

   std::string GetName() const { return "transmitter"; }

   ComponentList&       GetComponents() { return mComponents; }
   const ComponentList& GetComponents() const { return mComponents; }
 
   const char* GetScriptClassName() const override { return "WsfEM_Xmtr"; }
 
   void Activate();
   void Deactivate();
 
   virtual bool AllowInteractionWith(WsfEM_Rcvr* aRcvrPtr);
 
   virtual double ComputeRadiatedPower(double  aTargetAz,
                                       double  aTargetEl,
                                       double  aEBS_Az,
                                       double  aEBS_El,
                                       double  aFrequency,
                                       double& aAntennaGain);
 
   bool Initialize(WsfSimulation& aSimulation) override;
 
   bool ProcessInput(UtInput& aInput) override;
 
   virtual bool ProcessInputBlock(UtInput& aInput);
 
   bool AllowZeroFrequencyInput() const { return mAllowZeroFrequencyInput; }
   void AllowZeroFrequencyInput(bool val) { mAllowZeroFrequencyInput = val; }

   WsfEM_Rcvr* GetLinkedReceiver() const { return mLinkedRcvrPtr; }

   int GetAlternateFrequencyCount() const { return static_cast<int>(mAlternateFrequencyList.size()); }

   using FrequencyList = std::map<size_t, double>;
   const FrequencyList& GetAlternateFrequencies() { return mAlternateFrequencyList; }
 
   int GetCurrentAlternateFrequencyId() const { return mCurrentAltFreqId; }
 
   double GetAlternateFrequency(unsigned int aId) const;
 
   bool ExplicitFrequencyList() const { return mExplicitFrequencyList; }

   XmtrFunction GetFunction() const { return mFunction; }


   double GetPeakPower(double aFrequency = 0.0) const;
   double GetAveragePower(double aFrequency = 0.0) const;
   double GetPower(double aFrequency = 0.0) const;

   double GetPulseCompressionRatio() const { return mPulseCompressionRatio; }

   int GetPulseRepetitionFrequencyCount() const { return static_cast<int>(mPulseRepetitionFrequencies.size() - 1); }

   double GetPulseRepetitionFrequency(size_t aIndex = 0) const;

   std::vector<double> GetPulseRepetitionFrequencies() const;

   int GetPulseRepetitionIntervalCount() const { return static_cast<int>(mPulseRepetitionIntervals.size() - 1); }

   double GetPulseRepetitionInterval(size_t aIndex = 0) const;

   std::vector<double> GetPulseRepetitionIntervals() const;

   double GetPulseWidth() const { return mPulseWidth; }

   double GetDutyCycle() const { return mDutyCycle; }

   bool IsUsingPeakPower() const { return mUsePeakPower; }
 
   void SetLinkedReceiver(WsfEM_Rcvr* aRcvrPtr);
 
   void SetBandwidth(double aBandwidth) override;
 
   void SetFrequency(double aFrequency) override;
 
   void SelectAlternateFrequency(unsigned int aId);
 
   bool UseDefaultFrequency() { return mUseDefaultFrequency; }
   void UseDefaultFrequency(bool aUseDefaultFrequency) { mUseDefaultFrequency = aUseDefaultFrequency; }
 
   void SetPolarization(WsfEM_Types::Polarization aPolarization) override;
 
   void SetPower(double aPower);
   bool SetPower(double aPower, double aFrequency);
 
   void SetPulseCompressionRatio(double aPulseCompressionRatio);
 
   void SetPulseRepetitionFrequency(double aPulseRepetitionFrequency, size_t aPRF_Num = 1);
 
   void SetPulseRepetitionInterval(double aPulseRepetitionInterval, size_t aPRF_Num = 1);
 
   void SetPulseWidth(double aPulseWidth);
 
   void SetDutyCycle(double aDutyCycle);


   virtual bool AddListener(WsfEM_Rcvr* aRcvrPtr);
 
   virtual bool RemoveListener(WsfEM_Rcvr* aRcvrPtr);
 
   virtual void NotifyListeners(double aSimTime, WsfEM_Interaction& aResult);

   virtual bool HasListeners() const { return (!mListeners.empty()); }
 
   virtual bool AddChangeListener(WsfEM_Rcvr* aRcvrPtr);
 
   virtual bool RemoveChangeListener(WsfEM_Rcvr* aRcvrPtr);
 
   virtual void NotifyChangeListeners(double aSimTime, size_t aTargetIndex);

   virtual bool HasChangeListeners() const { return (!mListeners.empty()); }



   double GetTransmissionEndTime() const { return mTransmissionEndTime; }

   void SetTransmissionEndTime(double aTransmissionEndTime) { mTransmissionEndTime = aTransmissionEndTime; }

 
private:
   ComponentList mComponents;

   WsfEM_Manager* mEM_ManagerPtr;

   WsfEM_Rcvr* mLinkedRcvrPtr;

   FrequencyList mAlternateFrequencyList;
 
   PowerList           mPowerList;
   double              mPulseCompressionRatio;
   std::vector<double> mPulseRepetitionFrequencies; 
   std::vector<double> mPulseRepetitionIntervals;   
   double              mPulseWidth;
   double              mDutyCycle;

   double mTransmissionEndTime;
 
   using Listeners = std::vector<WsfEM_Rcvr*>;
   Listeners mListeners;
   Listeners mChangeListeners;
 
   XmtrFunction mFunction;

   unsigned int mCurrentAltFreqId;

   bool mExplicitFrequencyList;

   // in the frequency list and ignore the alternate list.
   bool mUseDefaultFrequency;
 
   bool mAllowZeroFrequencyInput;

   bool mUsePeakPower;
};
 
#endif