WsfBeamDirector.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 WSFBEAMDIRECTOR_HPP
#define WSFBEAMDIRECTOR_HPP
 
#include "wsf_mil_export.h"
 
#include <set>
 
#include "WsfEM_Antenna.hpp"
#include "WsfEM_Rcvr.hpp"
#include "WsfEM_Xmtr.hpp"
#include "WsfEvent.hpp"
#include "WsfImage.hpp"
#include "WsfLocalTrack.hpp"
#include "WsfSensor.hpp"
#include "WsfSensorMode.hpp"
#include "WsfSensorModeList.hpp"
#include "WsfStringId.hpp"
#include "WsfWeapon.hpp"

class WSF_MIL_EXPORT WsfBeamDirector : public WsfSensor
{
public:
   WsfBeamDirector(WsfScenario& aScenario);
   WsfBeamDirector(const WsfBeamDirector& aSrc) = default;
   WsfBeamDirector& operator=(const WsfBeamDirector&) = delete;
   ~WsfBeamDirector() override                        = default;
 
   WsfSensor* Clone() const override;
 
   bool ProcessInput(UtInput& aInput) override;
   bool Initialize(double aSimTime) override;
   void Update(double aSimTime) override;
 
   void TurnOff(double aSimTime) override;
   void TurnOn(double aSimTime) override;
 
   void PointAtTarget(double aSimTime, const WsfWeapon::FireTarget& aTarget);

   const WsfTrack& GetCue() const { return mCue; }

   WsfStringId GetTargetOffset() const { return mTargetOffset; }

   void SetCue(const WsfTrack& aTrack) { mCue = aTrack; }
 
   size_t      GetEM_XmtrCount() const override { return 1; }
   WsfEM_Xmtr& GetEM_Xmtr() const { return GetCurrentMode()->GetEM_Xmtr(); }
   WsfEM_Xmtr& GetEM_Xmtr(size_t aIndex) const override { return GetCurrentMode()->GetEM_Xmtr(); }
 
   size_t      GetEM_RcvrCount() const override { return 1; };
   WsfEM_Rcvr& GetEM_Rcvr() const { return GetCurrentMode()->GetEM_Rcvr(); }
   WsfEM_Rcvr& GetEM_Rcvr(size_t aIndex) const override { return GetCurrentMode()->GetEM_Rcvr(); };
 
   double GetMaxRange() const { return GetCurrentMode()->GetMaxRange(); }
 
   void GetAzFOV(double& aMinAzFOV, double& aMaxAzFOV) const
   {
      return GetEM_Xmtr().GetAntenna()->GetAzimuthFieldOfView(aMinAzFOV, aMaxAzFOV);
   }
 
   void GetElFOV(double& aMinElFOV, double& aMaxElFOV) const
   {
      return GetEM_Xmtr().GetAntenna()->GetElevationFieldOfView(aMinElFOV, aMaxElFOV);
   }
 
   // void UpdateSlewRatesAndGimbalAngles(double aDeltaTime,
   //                                     double aTargetVecWCS[3]);
 
   void PointAtWCS(double aSimTime, double aPointAtWCS[3]);

   int GetTrackingState() const { return GetCurrentMode()->GetType(); }
 
   bool IsTracking() const { return GetCurrentMode()->IsTracking(); }
 
   bool IsImaging() const { return GetCurrentMode()->IsImaging(); }

   const std::set<WsfStringId>& GetTargetsInFOV() const { return GetCurrentMode()->GetTargetsInFOV(); }
 
   bool IsInFOR(WsfPlatform* aTargetPtr);
 
   class WsfBeamDirectorMode : public WsfSensorMode
   {
   public:
      enum Type
      {
         cSCANNING               = 0,
         cLOCKED                 = 1,
         cLOCKED_WAITING_FOR_CUE = 2,
         cCUED                   = 3,
         cBREAKLOCK              = 4,
         cNUM_STATES             = 5,
         cUNDEFINED              = 999
      };
 
      WsfBeamDirectorMode() = default;
      WsfBeamDirectorMode(const WsfBeamDirectorMode& aSrc);
      WsfBeamDirectorMode& operator=(const WsfBeamDirectorMode&) = delete;
      ~WsfBeamDirectorMode() override;
 
      WsfSensorMode* Clone() const override { return new WsfBeamDirectorMode(*this); }
      bool           ProcessInput(UtInput& aInput) override;
      bool           Initialize(double aSimTime) override;
 
      void SetTrack(const WsfTrack& aTrack) { mTrack = aTrack; }
 
      bool IsImaging() const { return ((mType == cLOCKED) || (mType == cLOCKED_WAITING_FOR_CUE) || (mType == cCUED)); }
      bool IsTracking() const { return ((mType != cSCANNING) && (mType != cBREAKLOCK)); }
 
      WsfTrack& GetTrack() { return mTrack; }
 
      int GetType() const { return mType; }
 
      void PointAtTargetUpdate(double aSimTime);
 
      const std::set<WsfStringId>& GetTargetsInFOV() const { return mTargetsInFOV; }
 
      bool AttemptToDetect(double               aSimTime,
                           WsfPlatform*         aTargetPtr,
                           WsfSensor::Settings& aSettings,
                           WsfSensorResult&     aResult) override;
 
      void Deselect(double aSimTime) override;
      void Select(double aSimTime) override;
 
      const WsfImage& GetImage();
 
      const WsfImage::Object* GetImageObject() const
      {
         const WsfImage::Object* objectPtr = nullptr;
         if (!mImagePtr->GetObjects().empty())
         {
            objectPtr = &mImagePtr->GetObjects()[0];
         }
         return objectPtr;
      }
 
      const WsfTrack& GetTrack() const { return mTrack; }
 
      void Update(double aSimTime);

      double GetMaxRange() const { return mXcvrAntenna.GetMaximumRange(); }
 
      WsfEM_Xmtr& GetEM_Xmtr() { return mTransmitter; }
      WsfEM_Xmtr& GetEM_Xmtr(unsigned int aIndex) { return mTransmitter; }
 
      WsfEM_Rcvr& GetEM_Rcvr() { return mReceiver; }
      WsfEM_Rcvr& GetEM_Rcvr(unsigned int aIndex) { return mReceiver; }
 
   protected:
      void PointAtWCS(double aSimTime, double aPointAtWCS[3]);
 
      void CreateTrackFromResult(double                 aSimTime,
                                 const WsfSensorResult& aResult, // in
                                 WsfPlatform*           aTargetPtr);
 
      void CreateImageFromResult(double                 aSimTime,
                                 const WsfSensorResult& aResult, // in
                                 WsfPlatform*           aTargetPtr);
 
      WsfEM_Xmtr    mTransmitter = WsfEM_Xmtr(WsfEM_Xmtr::cXF_SENSOR);
      WsfEM_Antenna mXcvrAntenna = WsfEM_Antenna();
      WsfEM_Rcvr    mReceiver    = WsfEM_Rcvr(WsfEM_Rcvr::cRF_SENSOR);
 
   private:
      Type                  mType               = cUNDEFINED;
      double                mLastUpdateTime     = 0.0;
      double                mAngularResolution  = 3.0e-5;
      double                mScanFOV_Az[2]      = {-UtMath::cPI, UtMath::cPI};
      double                mScanFOV_El[2]      = {-UtMath::cPI_OVER_2, UtMath::cPI_OVER_2};
      double                mTargetRadialExtent = 10.0;
      WsfTrack              mTrack              = WsfTrack();
      WsfImage*             mImagePtr           = nullptr;
      int                   mMinPixelsForCue    = 0;
      bool                  mPerfectCorrelation = false;
      std::set<WsfStringId> mTargetsInFOV       = std::set<WsfStringId>(); // Used in API
 
   }; // WsfBeamDirectorMode
 
private:
   void AcquireTarget(double aSimTime, const WsfTrack& aTrack);
 
   WsfBeamDirectorMode* GetCurrentMode() const override
   {
      return mWsfBeamDirectorModeList[mModeListPtr->GetCurrentMode()];
   }
 
   // Mode-independent variables
   WsfTrack                  mCue;
   WsfStringId               mTargetOffset;
   bool                      mCommentsEnabled;
   WsfBeamDirectorMode::Type mLastModeType;

   std::vector<WsfBeamDirectorMode*> mWsfBeamDirectorModeList;
}; // WsfBeamDirector
 
#endif