WsfATA_LaunchComputer.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 WSFATA_LAUNCHCOMPUTER_HPP
#define WSFATA_LAUNCHCOMPUTER_HPP
 
#include "wsf_mil_export.h"
 
#include <vector>
 
class UtInput;
class UtInputBlock;
#include "WsfLaunchComputer.hpp"

 
class WSF_MIL_EXPORT WsfATA_LaunchComputer : public WsfLaunchComputer
{
public:
   static std::string BaseTypeName() { return "WSF_ATA_LAUNCH_COMPUTER"; }
 
   WsfATA_LaunchComputer();
   WsfATA_LaunchComputer& operator=(const WsfATA_LaunchComputer&) = delete;
   ~WsfATA_LaunchComputer() override;
 
   WsfLaunchComputer* Clone() const override;
   bool               Initialize(double aSimTime, WsfWeapon* aWeaponPtr) override;
   bool               ProcessInput(UtInput& aInput) override;
 
   bool ToolOnlyInitialize(double aSimTime);
 
   double EstimatedTimeToIntercept(double aSimTime, const WsfTrack& aTrack, double aLaunchDelayTime) override;

   class WSF_MIL_EXPORT EvenlySpaced
   {
   public:
      EvenlySpaced() = default;
 
      void         SetNumBins(unsigned int aSize) { mBins = aSize; }
      unsigned int GetNumBins() const { return mBins; }
      void         SetDelta(double aValue) { mDelta = aValue; }
      double       Delta() const { return mDelta; }
      void         SetMin(double aValue) { mMin = aValue; }
      double       Min() const { return mMin; }
      double       Max() const { return mMin + mBins * mDelta; }
      bool         BinCenter(unsigned int aIndex, double& aValue) const;
      bool         BinLower(unsigned int aIndex, double& aValue) const;
      bool         BinUpper(unsigned int aIndex, double& aValue) const;
      bool         GetIndex(double aValue, unsigned int& aIndex) const;
 
   private:
      double       mMin{0.0};
      double       mDelta{0.0};
      unsigned int mBins{0};
   };

   class WSF_MIL_EXPORT NotEvenlySpaced
   {
   public:
      void         SetNumBins(unsigned int aSize) { mValues.resize(aSize + 1, 0.0); }
      unsigned int GetNumBins() const { return static_cast<unsigned int>(mValues.size() - 1); }
      bool         SetValue(unsigned int aIndex, double aValue);
      bool         Delta(unsigned int aIndex, double& aValue) const;
      double       Min() const { return mValues[0]; }
      double       Max() const { return mValues[mValues.size() - 1]; }
      bool         BinCenter(unsigned int aIndex, double& aValue) const;
      bool         BinLower(unsigned int aIndex, double& aValue) const;
      bool         BinUpper(unsigned int aIndex, double& aValue) const;
      bool         GetIndex(double aValue, unsigned int& aIndex) const;
 
   private:
      std::vector<double> mValues;
   };


 
   void AllocateResults(unsigned int aSize);
   void ResetAllIndices();
   void SetResult(double aValue);
   bool IncrementRange();

   const EvenlySpaced& Aspects() { return mTableShotAspects; }
   const EvenlySpaced& Azimuths() { return mTableTargetAzimuths; }
   const EvenlySpaced& Elevations() { return mTableTargetElevations; }
   const EvenlySpaced& RangeRates() { return mTableRangeRates; }
   const NotEvenlySpaced& Ranges() { return mTableRanges; }

   unsigned int RangeIndex() const { return mRangeIndex; }

   unsigned int SizeOfResults() const { return SizeOfAspectsSet(); }
 
   unsigned int SizeOfAspectsSet() const;
   unsigned int SizeOfAzimuthsSet() const;
   unsigned int SizeOfElevationsSet() const;
   unsigned int SizeOfRangeRatesSet() const;
   unsigned int SizeOfRangeBinsSet() const;

   bool TableLookUpUsed() const { return !mTOFResults.empty(); }
   double GetResult() const { return mTOFResults.empty() ? 0.0 : mTOFResults[mIterIndex]; }
 
   double TableTargetRange() const;
   double TableTargetRangeRate() const;
   double TableTargetAspect() const;
   double TableTargetAzimuth() const;
   double TableTargetElevation() const;
 
   bool TableTargetRange(unsigned int aIndex, double& aValue) const;
   bool TableTargetRangeRate(unsigned int aIndex, double& aValue) const;
   bool TableTargetRelHeading(unsigned int aIndex, double& aValue) const;
   bool TableTargetAzimuth(unsigned int aIndex, double& aValue) const;
   bool TableTargetElevation(unsigned int aIndex, double& aValue) const;

   double TableMinRange() const { return mTableRanges.Min(); }
   double TableMaxRange() const { return mTableRanges.Max(); }
   double TableRange(unsigned int aIndex) const
   {
      double value;
      mTableRanges.BinCenter(aIndex, value);
      return value;
   }

   unsigned int RangeRateIndex() const { return mRangeRateIndex; }
   unsigned int TargetElIndex() const { return mTargetElIndex; }
   unsigned int TargetAzIndex() const { return mTargetAzIndex; }
   unsigned int ShotAspectIndex() const { return mTableShotAspectIndex; }

 
protected:
   WsfATA_LaunchComputer(const WsfATA_LaunchComputer& aSrc);
 
   void ProcessInterceptBlock(UtInputBlock& aInputBlock);
   void ProcessGenerateBlock(UtInputBlock& aInputBlock);
   bool CheckRanges();
 
   bool InitializeTTIData() override;
 
   double GetTOF(double aAspect, double aAzimuth, double aElevation, double aRangeRate, double aRange);
 
private:
   void SetIterIndex();
   bool IncrementRangeRate();
   bool IncrementTargetElevation();
   bool IncrementTargetAzimuth();
   bool IncrementShotAspect();
 
   unsigned int mTableShotAspectIndex;
   unsigned int mTargetAzIndex;
   unsigned int mTargetElIndex;
   unsigned int mRangeRateIndex;
   unsigned int mRangeIndex;
   unsigned int mIterIndex;
 
   EvenlySpaced    mTableShotAspects;
   EvenlySpaced    mTableTargetAzimuths;
   EvenlySpaced    mTableTargetElevations;
   EvenlySpaced    mTableRangeRates;
   NotEvenlySpaced mTableRanges;
 
   std::vector<double> mTOFResults;
};
 
#endif