WsfESA_AntennaPattern.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 WSFESAANTENNAPATTERN_HPP
#define WSFESAANTENNAPATTERN_HPP
 
#include "wsf_mil_export.h"
 
#include <vector>
 
class UtInput;
#include "UtRandom.hpp"
#include "UtVec2.hpp"
#include "UtVec3.hpp"
#include "WsfAntennaPattern.hpp"
#include "WsfObject.hpp"

 
class WSF_MIL_EXPORT WsfESA_AntennaPattern : public WsfAntennaPattern
{
public:
   enum LatticeType
   {
      cLT_RECTANGLULAR,
      cLT_TRIANGLULAR
   };
 
   enum WeightingFun
   {
      cWT_None    = 0,
      cWT_Taylor  = 1,
      cWT_Uniform = 2
   };
 
   struct Element
   {
      Element()
         : mWeight(1.0)
      {
         mLocation.Set(0.0);
         mNormal.Set(0.0);
      }
 
      UtVec3d mLocation; 
      double  mWeight;   
      UtVec2d mNormal;   
   };
 
   using ElementVec = std::vector<Element>;
   using WeightVec  = std::vector<double>;
 
   class WSF_MIL_EXPORT ESA_Data : public WsfAntennaPattern::BaseData
   {
   public:
      struct TaylorWeightingData
      {
         double mSidelobeLevelX; 
         double mSidelobeLevelY; 

         int mN_BarX;

         int mN_BarY;
 
         void Clear()
         {
            mSidelobeLevelX = 0.0;
            mSidelobeLevelY = 0.0;
            mN_BarX         = 0;
            mN_BarY         = 0;
         }
      };
 
      ESA_Data();
      ESA_Data(const ESA_Data& aSrc) = default;
      ~ESA_Data() override           = default;
 
      bool ProcessInput(WsfAntennaPattern& aPattern, UtInput& aInput) override;
      bool Initialize(WsfAntennaPattern& aAntennaPattern) override;
 
      double mdX;      
      double mdY;      
      double mLengthX; 
      double mLengthY; 
      int    mNX;      
      int    mNY;      
 
      bool mBackBaffled; 
 
      double mFailedRatio; 
 
      WeightingFun mDistribution; 
 
      TaylorWeightingData mTaylorData; 

      double mScanExponentX; 
      double mScanExponentY; 
 
      int mPhaseNumBits; 
      int mAmpNumBits;   
 
      LatticeType mLatticeType; 
 
      WsfStringId mElementPatternTypeId; 
 
      bool mDebug; 
 
   private:
      void ProcessTaylorWeightingInput(UtInput& aInput);
   };
 
   WsfESA_AntennaPattern(ESA_Data* aEsaData = nullptr);
   ~WsfESA_AntennaPattern() override;
 
   static WsfAntennaPattern* ObjectFactory(const std::string& aTypeName);
 
   WsfAntennaPattern* Clone() const override;
 
   bool Initialize(WsfSimulation* aSimulationPtr) override;
 
   double GetGain(double aFrequency, double aTargetAz, double aTargetEl, double aEBS_Az, double aEBS_EL) override;
 
   double GetAzimuthBeamwidth(double aFrequency, double aEBS_Azimuth, double aEBS_Elevation) const override;
   double GetElevationBeamwidth(double aFrequency, double aEBS_Azimuth, double aEBS_Elevation) const override;
   double GetPeakGain(double aFrequency) const override;

   double GetElementSpacingX() const { return mESA_DataPtr->mdX; }
   double GetElementSpacingY() const { return mESA_DataPtr->mdY; }
   int    GetNumberElementsX() const { return mESA_DataPtr->mNX; }
   int    GetNumberElementsY() const { return mESA_DataPtr->mNY; }
   bool   IsDistributionTaylor() const { return mESA_DataPtr->mDistribution == cWT_Taylor; }
   bool   IsDistributionUniform() const { return mESA_DataPtr->mDistribution == cWT_Uniform; }
   double GetTaylorDataSidelobeLevelX() const { return mESA_DataPtr->mTaylorData.mSidelobeLevelX; }
   double GetTaylorDataSidelobeLevelY() const { return mESA_DataPtr->mTaylorData.mSidelobeLevelY; }
   double GetTaylorDataN_BarX() const { return mESA_DataPtr->mTaylorData.mN_BarX; }
   double GetTaylorDataN_BarY() const { return mESA_DataPtr->mTaylorData.mN_BarY; }
   int    GetPhaseNumBits() const { return mESA_DataPtr->mPhaseNumBits; }
   int    GetAmpNumBits() const { return mESA_DataPtr->mAmpNumBits; }
 
protected:
   WsfESA_AntennaPattern(const WsfESA_AntennaPattern& aSrc);

   WsfESA_AntennaPattern& operator=(const WsfESA_AntennaPattern& aRhs) = delete;
 
   ESA_Data* GetData() const { return mESA_DataPtr; }
 
   virtual double ComputeDirectivityGain(double aFrequency, double aEBS_Az, double aEBS_El) const;
 
   virtual double ComputeElementGain(double aFrequency, double aAzAngle, double aElAngle) const;
 
   virtual double ComputeElementFactor(double aFrequency, double aEBS_Az, double aEBS_El, double aAzAngle, double aElAngle) const;
 
   void SetESA_DataPtr(ESA_Data* aESA_DataPtr) { mESA_DataPtr = aESA_DataPtr; }
 
   virtual void ResizeArray();
   virtual void AdjustApertureElements(ut::Random& aRandom);
   virtual void AdjustElementLocations();
 
   void ComputeFailedModulesWeights(ut::Random& aRandom);

   ElementVec mElements; 
   double     mLengthX;  
   double     mLengthY;  
   int        mNX;       
   int        mNY;       
 
   WeightVec mWeightVecX;
   WeightVec mWeightVecY;

   double mApertureEff;
 
   double mApertureEffX;
   double mApertureEffY;
 
   WsfAntennaPattern* mElementPatternPtr;
 
private:
   double ComputeArrayFactor(double aFrequency, double aEBS_Az, double aEBS_El, double aAzAngle, double aElAngle) const;
 
   void           ComputeDistributionWeights();
   virtual double ComputeApertureEfficiency();
   double         ComputeQuantizationError(int aNumBits, double aRangePerBit, double aValue) const;
 
   double ComputeGain(double aFrequency, double aAzAngle, double aElAngle, double aEBS_Az, double aEBS_El) const;

   ESA_Data* mESA_DataPtr;
};
 
#endif