WsfEM_Rcvr.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_RCVR_HPP
#define WSFEM_RCVR_HPP
 
#include "wsf_export.h"
 
#include <string>
#include <vector>
 
class UtInput;
class WsfAntennaPattern;
class WsfArticulatedPart;
#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;

class WSF_EXPORT WsfEM_RcvrComponent : public WsfComponentT<WsfEM_Rcvr>
{
public:


   virtual void AddInteractor(WsfEM_Xmtr* aXmtrPtr);
   virtual void RemoveInteractor(WsfEM_Xmtr* aXmtrPtr);
};

class WSF_EXPORT WsfEM_Rcvr : public WsfEM_XmtrRcvr
{
public:


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

   enum RcvrFunction
   {
      cRF_UNDEFINED,      
      cRF_COMM,           
      cRF_SENSOR,         
      cRF_PASSIVE_SENSOR, 
      cRF_INTERFERER      
   };
 
   WsfEM_Rcvr(RcvrFunction aFunction, WsfEM_Antenna* aAntennaPtr = nullptr);
 
   WsfEM_Rcvr(const WsfEM_Rcvr& aSrc, WsfEM_Antenna* aAntennaPtr = nullptr);
 
   ~WsfEM_Rcvr() override;

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

   ComponentList&       GetComponents() { return mComponents; }
   const ComponentList& GetComponents() const { return mComponents; }
 
   const char* GetScriptClassName() const override { return "WsfEM_Rcvr"; }
 
   void Activate();
 
   virtual void Deactivate();
 
   virtual double ComputeReceivedPower(double                    aSourceAz,
                                       double                    aSourceEl,
                                       double                    aEBS_Az,
                                       double                    aEBS_El,
                                       double                    aReceivedPowerDensity,
                                       WsfEM_Types::Polarization aPolarization,
                                       double                    aFrequency,
                                       double&                   aAntennaGain);
 
   virtual double ComputeSignalToNoise(double aReceivedSignalPower, double aClutterPower, double aReceivedInterferencePower);
 
   bool Initialize(WsfSimulation& aSimulation) override;
 
   bool ProcessInput(UtInput& aInput) override;
 
   virtual bool ProcessInputBlock(UtInput& aInput);
 
   double GetBandwidthEffect(double aSignalFreq, double aSignalBW) const;

   double GetDetectionThreshold() const { return mDetectionThreshold; }

   RcvrFunction GetFunction() const { return mFunction; }

   double GetInstantaneousBandwidth() const { return mInstantaneousBandwidth; }

   double GetNoisePower() const { return mNoisePower; }

   bool IsNoisePowerExplicit() const { return mExplicitNoisePower; }

   double GetNoiseFigure() const { return mNoiseFigure; }

   double GetNoiseMultiplier() const { return mNoiseMultiplier; }

   void SetNoiseMultiplier(double aNoiseMultiplier) { mNoiseMultiplier = aNoiseMultiplier; }
 
   double GetPolarizationEffect(WsfEM_Types::Polarization aPolarization) const;
 
   void SetAntennaOhmicLoss(double aAntennaOhmicLoss);
 
   double GetAntennaOhmicLoss() { return mAntennaOhmicLoss; }

   void SetDetectionThreshold(double aDetectionThreshold) { mDetectionThreshold = aDetectionThreshold; }
 
   void SetBandwidth(double aBandwidth) override;
 
   void SetFrequency(double aFrequency) override;
 
   void SetInstantaneousBandwidth(double aInstantaneousBandwidth);
 
   void SetNoiseFigure(double aNoiseFigure);
 
   void SetNoisePower(double aNoisePower);
 
   void SetPolarization(WsfEM_Types::Polarization aPolarization) override;
 
   void SetPolarizationEffect(WsfEM_Types::Polarization aPolarization, double aFraction);
 
   void SetReceiveLineLoss(double aReceiveLineLoss);
 
   double GetReceiveLineLoss() const { return mReceiveLineLoss; }


 
   virtual bool CanInteractWith(WsfEM_Xmtr* aXmtrPtr);
 
   virtual void UpdateInteractions(WsfEM_Xmtr* aXmtrPtr);
 
   virtual bool AddInteractor(WsfEM_Xmtr* aXmtrPtr);
 
   virtual bool RemoveInteractor(WsfEM_Xmtr* aXmtrPtr);

   size_t GetCommInteractorCount() const { return mCommInteractors.size(); }

   WsfEM_Xmtr* GetCommInteractorEntry(unsigned int aIndex) const { return mCommInteractors[aIndex]; }

   size_t GetInterferenceInteractorCount() const { return mInterferenceInteractors.size(); }

   WsfEM_Xmtr* GetInterferenceInteractorEntry(size_t aIndex) const { return mInterferenceInteractors[aIndex]; }

   size_t GetSensorInteractorCount() const { return mSensorInteractors.size(); }

   WsfEM_Xmtr* GetSensorInteractorEntry(size_t aIndex) const { return mSensorInteractors[aIndex]; }

   unsigned int GetInteractorCount() const { return mTotalInteractors; }

   WsfEM_Xmtr* GetInteractorEntry(unsigned int aIndex) const;
 
   virtual void EmitterActiveCallback(double aSimTime, WsfEM_Interaction& aResult);
   virtual void SignalChangeCallback(double aSimTime, size_t aTargetIndex);


   void UpdateNoisePower(double aPulseWidth = 0.0);
 
   static double ComputeSystemNoiseTemperature(double aElevation,
                                               double aAntennaOhmicLoss,
                                               double aReceiveLineLoss,
                                               double aNoiseFigure,
                                               double aFrequency);

   bool CheckXmtrMasking() { return mCheckXmtrMasking && CheckMasking(); }
 
protected:
   void UpdateIndices();
 
   using InteractorList = std::vector<WsfEM_Xmtr*>;

   InteractorList mCommInteractors;
   InteractorList mSensorInteractors;
   InteractorList mInterferenceInteractors;
 
private:
   void UpdatePolarizationEffects();

   ComponentList mComponents;

   WsfEM_Manager* mEM_ManagerPtr;


   unsigned int mTotalInteractors;
   unsigned int mCommBaseIndex;
   unsigned int mSensorBaseIndex;
   unsigned int mInterferenceBaseIndex;
 
   RcvrFunction mFunction;
   double       mPolarizationEffects[WsfEM_Types::cPOL_COUNT];
   double       mExplicitPolarizationEffects[WsfEM_Types::cPOL_COUNT];
   double       mInstantaneousBandwidth;
   double       mNoisePower;
   double       mNoiseFigure;
   double       mNoiseMultiplier;
   double       mAntennaOhmicLoss;
   double       mReceiveLineLoss;
   double       mDetectionThreshold;
   bool         mExplicitInstantaneousBandwidth;
   bool         mExplicitNoisePower;
 
   bool mCheckXmtrMasking;
};
 
#endif