WsfALARM_AntennaPattern.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI//REL TO USA ONLY
//
// 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 WSFALARM_ANTENNAPATTERN_HPP
#define WSFALARM_ANTENNAPATTERN_HPP
 
#include <iosfwd>
#include <map>
#include <string>
#include <vector>
 
#include "WsfAntennaPattern.hpp"
#include "WsfEM_Types.hpp"
class WsfScenario;

class WsfALARM_AntennaPattern : public WsfAntennaPattern
{
public:
   enum ApertureShape
   {
      cAS_UNKNOWN     = 0,
      cAS_CIRCULAR    = 1,
      cAS_ELLIPTICAL  = 2,
      cAS_RECTANGULAR = 3,
      cAS_SQUARE      = 4
   };

   class ALARM_Data : public WsfAntennaPattern::BaseData
   {
   public:
      struct PatternData
      {
         PatternData()
            : mPeakGain()
            , mInputAzBeamwidth(0.0)
            , mInputElBeamwidth(0.0)
            , mAzBeamwidth(0.0)
            , mElBeamwidth(0.0)
            , mAzAngles()
            , mAzGains()
            , mAzMin(0.0)
            , mAzMax(0.0)
            , mElAngles()
            , mElGains()
            , mElMin(0.0)
            , mElMax(0.0)
         {
         }
 
 
         double mPeakGain;
         double mInputAzBeamwidth;
         double mInputElBeamwidth;
         double mAzBeamwidth;
         double mElBeamwidth;
 
         std::vector<double> mAzAngles;
         std::vector<double> mAzGains;
         double              mAzMin; 
         double              mAzMax; 
 
         std::vector<double> mElAngles;
         std::vector<double> mElGains;
         double              mElMin; 
         double              mElMax; 
      };
      using PatternMap = std::map<WsfEM_Types::Polarization, PatternData>;
 
      ALARM_Data();
      ~ALARM_Data() override = default;
      ;
 
      bool ProcessInput(WsfAntennaPattern& aPattern, UtInput& aInput) override;
      bool Initialize(WsfAntennaPattern& aAntennaPattern) override;
 
      double GetGain(double aFrequency, double aTargetAz, double aTargetEl, double aEBS_Az, double aEBS_El) override;
 
      virtual void ReadPattern(WsfScenario& aScenario, const std::string& aFileName);
 
      bool InitializeBase();
 
      std::string mFileName;
 
      ApertureShape mApertureShape;
 
      double mMinGain;
 
      WsfEM_Types::Polarization              mSetPolarization; 
      std::vector<WsfEM_Types::Polarization> mPolarizations;   
 
      PatternMap mPatternMap;
 
      double mOneMinusE_2; 
 
      double mGainCorrection;
 
      std::string mTitle;
      std::string mClassification;
      double      mWavelength;
 
      bool mInputIs2D;
      bool mInputIsDB;
 
   protected:
      std::vector<double>::size_type GetIndex(const std::vector<double>& aTable, double aValue) const;
 
      double GetCircularApertureGain(double aAzLook, double aElLook);
      double GetEllipticalApertureGain(double aAzLook, double aElLook);
      double GetRectangularApertureGain(double aAzLook, double aElLook);
 
   private:
      void ConvertValue(const std::string& aString, double& aValue) const;
      void ConvertValue(const std::string& aString, int& aValue) const;
 
      void ParseLine(const std::string& aLine, std::vector<std::string>& aWords) const;
      void Read2D_File(std::istream& aIn, WsfEM_Types::Polarization aPolarization);
      void ReadLine(std::istream& aIn, std::string& aLine);
   };
 
   WsfALARM_AntennaPattern(ALARM_Data* aBaseDataPtr);
 
   static WsfAntennaPattern* ObjectFactory(const std::string& aTypeName);
 
   WsfAntennaPattern* Clone() const 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;
 
   using Table      = std::vector<double>;
   using TableIndex = std::vector<double>::size_type;


   virtual const std::vector<double>& GetAzAngles() const
   {
      return AlarmData()->mPatternMap[AlarmData()->mSetPolarization].mAzAngles;
   }
   virtual const std::vector<double>& GetAzGains() const
   {
      return AlarmData()->mPatternMap[AlarmData()->mSetPolarization].mAzGains;
   }
   virtual const std::vector<double>& GetElAngles() const
   {
      return AlarmData()->mPatternMap[AlarmData()->mSetPolarization].mElAngles;
   }
   virtual const std::vector<double>& GetElGains() const
   {
      return AlarmData()->mPatternMap[AlarmData()->mSetPolarization].mElGains;
   }
   virtual ApertureShape GetApertureShape() const { return AlarmData()->mApertureShape; }
   virtual double        GetMinGain() const { return AlarmData()->mMinGain; }
   virtual double        GetGainCorrection() const { return AlarmData()->mGainCorrection; }
   virtual double        GetInputAzimuthBeamwidth() const
   {
      return AlarmData()->mPatternMap[AlarmData()->mSetPolarization].mInputAzBeamwidth;
   }
   virtual double GetInputElevationBeamwidth() const
   {
      return AlarmData()->mPatternMap[AlarmData()->mSetPolarization].mInputElBeamwidth;
   }

 
protected:
   ALARM_Data* AlarmData() const { return dynamic_cast<ALARM_Data*>(mSharedDataPtr); }
 
   WsfALARM_AntennaPattern(const WsfALARM_AntennaPattern& aSrc) = default;
   WsfALARM_AntennaPattern operator=(const WsfALARM_AntennaPattern& aRhs) const = delete;
};
 
#endif