WsfEM_Antenna.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.
// ****************************************************************************
// ****************************************************************************
// Updated by Infoscitex, a DCS Company.
// ****************************************************************************
 
#ifndef WSFEM_ANTENNA_HPP
#define WSFEM_ANTENNA_HPP
 
#include "wsf_export.h"
 
#include <memory>
 
#include "UtCloneablePtr.hpp"
 
class UtInput;
#include "UtScriptAccessible.hpp"
class WsfArticulatedPart;
class WsfEM_XmtrRcvr;
class WsfFieldOfView;
class WsfPlatform;
#include "WsfSinglePlatformObserver.hpp"

class WSF_EXPORT WsfEM_Antenna : public UtScriptAccessible, public WsfSinglePlatformObserver
{
public:
   enum ScanMode
   {
      cSCAN_FIXED = 0, //<! The beam is fixed
      cSCAN_AZ    = 1, //<! The beam scans only is azimuth
      cSCAN_EL    = 2, //<! The beam scans only in elevation
      cSCAN_AZ_EL = 3  //<! The beam can scan in both azimuth and elevation
   };

   enum EBS_Mode
   {
      cEBS_NONE      = 0, 
      cEBS_AZIMUTH   = 1, 
      cEBS_ELEVATION = 2, 
      cEBS_BOTH      = 3  
   };

   enum ScanStabilization
   {
      cSS_NONE  = 0, 
      cSS_PITCH = 1, 
      cSS_ROLL  = 2, 
      cSS_BOTH  = 3  
   };
 
 
   WsfEM_Antenna();
   WsfEM_Antenna(const WsfEM_Antenna& aSrc);
   WsfEM_Antenna& operator=(const WsfEM_Antenna& aRhs);
   ~WsfEM_Antenna() override;
 
   WsfArticulatedPart* GetArticulatedPart() const { return mArticulatedPartPtr; }
 
   WsfPlatform* GetPlatform() const;
 
   virtual bool Initialize(WsfArticulatedPart* aArticulatedPartPtr);
 
   virtual bool ProcessInput(UtInput& aInput);
 
   virtual void UpdatePosition(double aSimTime);
 
   const char* GetScriptClassName() const override { return "WsfEM_Antenna"; }



   double GetHeight() const { return -mOffset[2]; }
 
   void SetHeight(double aHeight);

   double GetPitch() const { return mPitch; }
 
   void SetPitch(double aPitch);
 
   void SetFieldOfView(std::unique_ptr<WsfFieldOfView> aFieldOfViewPtr);

   void GetAzimuthFieldOfView(double& aMinAzFOV, double& aMaxAzFOV) const;
 
   void SetAzimuthFieldOfView(double aMinAzFOV, double aMaxAzFOV);

   void GetElevationFieldOfView(double& aMinElFOV, double& aMaxElFOV) const;
 
   void SetElevationFieldOfView(double aMinElFOV, double aMaxElFOV);

   void GetRangeLimits(double& aMinRange, double& aMaxRange) const
   {
      aMinRange = mMinRange;
      aMaxRange = mMaxRange;
   }

   double GetMaximumRange() const { return mMaxRange; }

   double GetMinimumRange() const { return mMinRange; }
 
   void SetRangeLimits(double aMinRange, double aMaxRange);
 
   void SetMaximumRange(double aMaxRange) { mMaxRange = aMaxRange; }
 
   void SetMinimumRange(double aMinRange) { mMinRange = aMinRange; }

   void GetAltitudeLimits(double& aMinAlt, double& aMaxAlt) const
   {
      aMinAlt = mMinAlt;
      aMaxAlt = mMaxAlt;
   }

   double GetMaximumAltitude() const { return mMaxAlt; }

   double GetMinimumAltitude() const { return mMinAlt; }
 
   void SetAltitudeLimits(double aMinAlt, double aMaxAlt);
 
   void SetMaximumAltitude(double aMaxAltitude) { mMaxAlt = aMaxAltitude; }
 
   void SetMinimumAltitude(double aMinAltitude) { mMinAlt = aMinAltitude; }

   EBS_Mode GetEBS_Mode() const { return mEBS_Mode; }

   void SetEBS_Mode(EBS_Mode aEBS_Mode) { mEBS_Mode = aEBS_Mode; }

   double GetEBS_AzLossExponent() const { return mEBS_AzLossExponent; }

   double GetEBS_ElLossExponent() const { return mEBS_ElLossExponent; }

   void SetEBS_AzLossExponent(double aEBS_LossExponentAz) { mEBS_AzLossExponent = aEBS_LossExponentAz; }

   void SetEBS_ElLossExponent(double aEBS_LossExponentEl) { mEBS_ElLossExponent = aEBS_LossExponentEl; }

   double GetEBS_AzCosSteeringLimit() const { return mEBS_AzCosSteeringLimit; }
   double GetEBS_ElCosSteeringLimit() const { return mEBS_ElCosSteeringLimit; }

   void SetEBS_AzCosSteeringLimit(double aEBS_AzCosSteeringLimit) { mEBS_AzCosSteeringLimit = aEBS_AzCosSteeringLimit; }
   void SetEBS_ElCosSteeringLimit(double aEBS_ElCosSteeringLimit) { mEBS_ElCosSteeringLimit = aEBS_ElCosSteeringLimit; }

   ScanMode GetScanMode() const { return mScanMode; }

   void SetScanMode(ScanMode aScanMode) { mScanMode = aScanMode; }

   ScanStabilization GetScanStabilization() const { return mScanStabilization; }

   void SetScanStabilization(ScanStabilization aScanStabilization) { mScanStabilization = aScanStabilization; }

   void GetAzimuthScanLimits(double& aMinAzScan, double& aMaxAzScan) const
   {
      aMinAzScan = mMinAzScan;
      aMaxAzScan = mMaxAzScan;
   }

   double GetMinimumAzimuthScanLimit() const { return mMinAzScan; }

   double GetMaximumAzimuthScanLimit() const { return mMaxAzScan; }
 
   void SetAzimuthScanLimits(double aMinAzScan, double aMaxAzScan);
 
   void SetMaximumAzimuthScanLimit(double aMaxAzScan) { mMaxAzScan = aMaxAzScan; }
   void SetMinimumAzimuthScanLimit(double aMinAzScan) { mMinAzScan = aMinAzScan; }

   void GetElevationScanLimits(double& aMinElScan, double& aMaxElScan) const
   {
      aMinElScan = mMinElScan;
      aMaxElScan = mMaxElScan;
   }

   double GetMinimumElevationScanLimit() const { return mMinElScan; }

   double GetMaximumElevationScanLimit() const { return mMaxElScan; }
 
   void SetElevationScanLimits(double aMinElScan, double aMaxElScan);
 
   void SetMaximumElevationScanLimit(double aMaxElScan) { mMaxElScan = aMaxElScan; }
   void SetMinimumElevationScanLimit(double aMinElScan) { mMinElScan = aMinElScan; }



 
   void ComputeAspect(const double aThisToTgtLocWCS[3], double& aThisToTgtAz, double& aThisToTgtEl);
 
   void ComputeBeamAspect(const double aWCS_ToBeamTransform[3][3],
                          const double aThisToTgtWCS[3],
                          double&      aBeamToTgtAz,
                          double&      aBeamToTgtEl) const;
 
   void ComputeBeamPosition(WsfEM_XmtrRcvr* aXmtrRcvrPtr,
                            double          aThisToTgtAz,
                            double          aThisToTgtEl,
                            double          aWCS_ToBeamTransform[3][3],
                            double&         aEBS_Az,
                            double&         aEBS_El);
 
   double ComputeBeamSteeringLoss(double aEBS_Az, double aEBS_El);
 
   void ConvertWCS_ToACS(const double aLocationWCS[3], double aLocationACS[3]);
 
   void ConvertWCS_ToNED(const double aLocationWCS[3], double aLocationNED[3]);
 
   void ConvertNED_ToWCS(const double aLocationNED[3], double aLocationWCS[3]);
 
   void ConvertWCS_VectorToACS(const double aVectorWCS[3], double aVectorACS[3]);
 
   void ConvertWCS_VectorToNED(const double aVectorWCS[3], double aVectorNED[3]);
 
   void ConvertNED_VectorToWCS(const double aVectorNED[3], double aVectorWCS[3]);
 
   void GetLocationLLA(double& aLat, double& aLon, double& aAlt);
 
   void GetLocationWCS(double aLocationWCS[3]);
 
   void GetLocationWCS(const double aThisToTgtLocWCS[3], double aTgtLocWCS[3]);
 
   void GetRelativeLocationNED(WsfPlatform* aTargetPtr, double aLocationNED[3]);
 
   void GetRelativeLocationNED(const double aTgtLocWCS[3], double aLocationNED[3]);
 
   void GetRelativeLocationWCS(double aThisToTgtAz, double aThisToTgtEl, double aThisToTgtRange, double aThisToTgtLocWCS[3]);
 
   void GetRelativeLocationWCS(const double aTgtLocWCS[3], double aThisToTgtLocWCS[3]);
 
   void GetRelativeLocationWCS(WsfPlatform* aTargetPtr, double aThisToTgtLocWCS[3]);



 
   bool WithinAltitude(double aTgtAlt);
 
   bool WithinFieldOfView(double aThisToTgtAz, double aThisToTgtEl);
 
   bool WithinFieldOfView(WsfPlatform* aTargetPtr,
                          double       aEarthRadiusMultiplier,
                          double&      aTrueThisToTgtAz,
                          double&      aTrueThisToTgtEl,
                          double       aApparentThisToTgtLocWCS[3],
                          double&      aApparentThisToTgtAz,
                          double&      aApparentThisToTgtEl,
                          double       aApparentTgtToThisLocWCS[3]);
 
   bool WithinFieldOfView(WsfArticulatedPart* aTargetPtr,
                          double              aEarthRadiusMultiplier,
                          double&             aTrueThisToTgtAz,
                          double&             aTrueThisToTgtEl,
                          double              aApparentThisToTgtLocWCS[3],
                          double&             aApparentThisToTgtAz,
                          double&             aApparentThisToTgtEl,
                          double              aApparentTgtToThisLocWCS[3]);
 
   bool WithinFieldOfView(double  aTgtLocWCS[3],
                          double  aEarthRadiusMultiplier,
                          double& aTrueThisToTgtAz,
                          double& aTrueThisToTgtEl,
                          double  aApparentThisToTgtLocWCS[3],
                          double& aApparentThisToTgtAz,
                          double& aApparentThisToTgtEl,
                          double  aApparentTgtToThisLocWCS[3]);
 
   const WsfFieldOfView* GetFieldOfView() const { return mFieldOfViewPtr; }
   bool                  DefaultFieldOfView() const { return mDefaultFieldOfView; }

   // during simulation.
   void IndicateNondefaultFieldOfView() { mDefaultFieldOfView = false; }

   bool WithinRange(double aTgtRange) const { return ((aTgtRange >= mMinRange) && (aTgtRange <= mMaxRange)); }
 
protected:
   void ConvertAnglesFromPCS_ToSSCS(double& aAz, double& aEl);
   void ConvertAnglesFromSSCS_ToPCS(double& aAz, double& aEl);
   void OnPlatformUpdated(double aSimTime, WsfPlatform* aPlatformPtr) override;
   void UpdateLocationLLA();
   void UpdateLocationWCS();
   void UpdateWCS_ToACS_Transform();
   void UpdateWCS_ToNED_Transform();
   void UpdateWCS_ToSSCS_Transform();
 
   WsfArticulatedPart* mArticulatedPartPtr;

   double mOffset[3];

   double mPitch;

   double mEBS_AzCosSteeringLimit;

   double mEBS_ElCosSteeringLimit;

   double mEBS_AzLossExponent;

   double mEBS_ElLossExponent;

   EBS_Mode mEBS_Mode;



   ScanMode mScanMode;
   ScanStabilization mScanStabilization;
   double            mMinAzScan; // radians
   double            mMaxAzScan; // radians
   double            mMinElScan; // radians
   double            mMaxElScan; // radians


   ut::CloneablePtr<WsfFieldOfView> mFieldOfViewPtr;

   bool mDefaultFieldOfView;
 
   double mMinRange; // meters
   double mMaxRange; // meters
   double mMinAlt;   // meters
   double mMaxAlt;   // meters



   double mLocationWCS[3];

   double mOffsetWCS[3];
   double mLat;
   double mLon;
   double mAlt;

   double mPartYaw;
   double mPartPitch;
   double mPartRoll;

   double mECS_ToACS_Transform[3][3];
   double mWCS_ToACS_Transform[3][3];
   double mWCS_ToNED_Transform[3][3];
   double mWCS_ToSSCS_Transform[3][3];

   bool mLocationWCS_IsValid;
   bool mLocationLLA_IsValid;
 
   bool mECS_ToACS_TransformIsValid;
   bool mWCS_ToACS_TransformIsValid;
   bool mWCS_ToNED_TransformIsValid;
   bool mWCS_ToSSCS_TransformIsValid;
};
 
#endif