WsfSA_Processor.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI//REL TO USA ONLY
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2020 Infoscitex, a DCS 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 WSFSA_PROCESSOR_HPP
#define WSFSA_PROCESSOR_HPP
 
#include <map>
#include <set>
#include <stack>
#include <string>
#include <vector>
 
class UtInput;
class WsfAirMover;
class WsfBrawlerFuel;
class WsfBrawlerMover;
class WsfExplicitWeapon;
class WsfFuel;
class WsfLocalTrack;
class WsfP6DOF_Mover;
 
#include "WsfTrackList.hpp"
 
namespace wsf
{
namespace six_dof
{
class Mover;
}
} // namespace wsf
 
class WsfPlatform;
class WsfSA_Assess;
class WsfSA_EntityMessage;
class WsfSA_Perceive;
class WsfSA_Predict;
class WsfTrackManager;
class WsfTrackProcessor;
 
#include "wsf_air_combat_export.h"
 
#include "UtCallbackHolder.hpp"
#include "WsfEvent.hpp"
#include "WsfSA_EntityPerception.hpp"
#include "script/WsfScriptProcessor.hpp"
#include "script/WsfScriptProcessorClass.hpp"
 
// The WsfSA_Processor provides a collection of capabilities for situation awareness,
// including perception, assessment, and prediction modules.
 
class WSF_AIR_COMBAT_EXPORT WsfSA_Processor : public WsfScriptProcessor
{
public:
   enum EntityPerceptionType
   {
      TRUTH           = 0,
      STATUS_MESSAGES = 1
   };
 
   struct SA_EngagedTarget
   {
      bool   isValid          = false;
      size_t platformIndex    = 0;
      float  rangeMax         = 0.0;
      float  rangeNe          = 0.0;
      float  rangeMin         = 0.0;
      float  rangeCurrent     = 0.0;
      float  rangeClosureRate = 0.0;
      float  timeToIntercept  = 0.0;
      float  timeToActive     = 0.0;
      float  targetKTAS       = 0.0;
      float  targetAspect     = 0.0;
      float  targetAz         = 0.0;
      float  targetEl         = 0.0;
   };
 
   struct PerceiveData
   {
      // Assets
      std::vector<WsfSA_EntityPerception*> mPerceivedAssets;         
      std::vector<WsfSA_EntityPerception*> mPerceivedAircraftAssets; 
      std::vector<WsfSA_EntityPerception*> mPerceivedMissileAssets;  
 
      EntityPerceptionType  mAssetPerception{TRUTH}; 
      std::map<size_t, int> mImportantAssets;        
      std::map<WsfStringId, int> mImportantAssetTypes; 
      std::map<size_t, int> mUnimportantAssets; 
      std::map<WsfStringId, int> mUnimportantAssetTypes;     
      bool                       mPerceiveSelfStatus{false}; 
      std::map<size_t, WsfSA_EntityPerception*> mReceivedAssetStatus; 
      bool         mReportingOthersStatus{false}; 
      bool         mReportingSelfStatus{true};    
      unsigned int mAssetTruthPerceptionMask{
         0}; 
      WsfCategoryList mIgnoredAssetCategories; 
 
      // Bogies and Bandits
      std::vector<WsfSA_EntityPerception*> mPerceivedBogies;          
      std::vector<WsfSA_EntityPerception*> mPerceivedAircraftBogies;  
      std::vector<WsfSA_EntityPerception*> mPerceivedMissileBogies;   
      std::vector<WsfSA_EntityPerception*> mPerceivedBandits;         
      std::vector<WsfSA_EntityPerception*> mPerceivedAircraftBandits; 
      std::vector<WsfSA_EntityPerception*> mPerceivedMissileBandits;  
 
      std::map<size_t, int> mImportantThreats; 
      std::map<WsfStringId, int> mImportantThreatTypes; 
      std::map<size_t, int> mUnimportantThreats; 
      std::map<WsfStringId, int> mUnimportantThreatTypes;       
      bool                       mFilterAssetsFromBogies{true}; 
 
      std::list<WsfSA_Group*> mCurrentlyPerceivedGroups; 
 
      // Custom Script Support
      UtScript* mAssetConsiderationScoringScriptPtr{nullptr}; 
      UtScript* mBogieBanditConsiderationScoringScriptPtr{
         nullptr}; 
      UtScript* mMissileConsiderationScoringScriptPtr{nullptr}; 
      UtScript* mUnfocusedGroupConsiderationScoringScriptPtr{
         nullptr};                          
      UtScript* mPruningScriptPtr{nullptr}; 
 
      UtScriptClass* mSA_EntityPerceptionClassPtr{nullptr}; 
      UtScriptClass* mSA_GroupClassPtr{nullptr};            
      UtScriptClass* mSA_PerceivedItemClassPtr{nullptr};    
      UtScriptClass* mTrackClassPtr{nullptr};               
 
      // Cognitive Parameters
      std::vector<double> mExtraCognitiveDelaysAssets;  
      std::vector<double> mExtraCognitiveDelaysThreats; 
      int    mMaxAssetLoad{-1};         
      int    mMaxAssetLoadInitial{-1};  
      int    mMaxThreatLoad{-1}; 
      int    mMaxThreatLoadInitial{-1}; 
      double mAssetCoastTime{0.0}; 
      double mBanditCoastTime{0.0}; 
      double mBogeyCoastTime{0.0};  
 
      // Weapons Data
      WsfSA_Processor::SA_EngagedTarget mEngagedTarget{};         
      WsfExplicitWeapon*                mSelectedWeapon{nullptr}; 
      std::vector<WsfExplicitWeapon*>   mWeaponList;              
      bool mShootCueActive{false};   
      bool mShootCueBlinking{false}; 
      bool mWeaponBayDoorsAreOpen{false}; 
      bool mMasterArm{false};             
 
      // Warnings and Cautions
      bool mMasterWarningActive{false}; 
      bool mMasterCautionActive{false}; 
      bool mJammingDetected{
         false}; 
 
      // Expendable Countermeasures (CM)
      WsfExplicitWeapon* mChaffDispenser{nullptr}; 
      bool               mUseSimpleCM{false};      
      size_t             mNumSimpleChaff{0};       
      size_t             mNumSimpleFlare{0};       
      size_t             mNumSimpleDecoy{0};       
   };
 
   // This enumeration identifies the various SA processor updates and is used as an argument
   // in methods and as an index to the mUpdateMgmtData vector.  Note that cUPDATE_TYPE_COUNT
   // is the number of UpdateType entries, but is outside the enumeration so that each UpdateType
   // is a valid vector index.
   enum UpdateType : size_t
   {
      cSTATUS                       = 0,
      cENGAGEMENT_DATA              = 1,
      cFLIGHT_DATA                  = 2,
      cFUEL_DATA                    = 3,
      cNAV_DATA                     = 4,
      cCONTROLS_DATA                = 5,
      cWEAPONS_DATA                 = 6,
      cTRACK_DATA                   = 7,
      cASSETS_DATA                  = 8,
      cPERCEIVED_ITEM_DATA          = 9,
      cPRIORITIZED_ITEM_DATA        = 10,
      cPERCEIVED_ITEM_CALCULATION   = 11,
      cPRIORITIZED_ITEM_CALCULATION = 12,
      cBEHAVIOR_CALCULATION         = 13
   };
   static const size_t cUPDATE_TYPE_COUNT{14}; // number of entries in WsfSA_Processor::UpdateType enum

   static const std::vector<UpdateType> GetCognitiveUpdateGroup()
   {
      return std::vector<UpdateType>{cASSETS_DATA, cENGAGEMENT_DATA, cPERCEIVED_ITEM_DATA, cPRIORITIZED_ITEM_DATA};
   }

   static const std::vector<UpdateType> GetPlatformUpdateGroup()
   {
      return std::vector<UpdateType>{cSTATUS, cFLIGHT_DATA, cFUEL_DATA, cNAV_DATA, cCONTROLS_DATA, cWEAPONS_DATA, cTRACK_DATA};
   }

   static const std::vector<UpdateType> GetUniversalUpdateGroup()
   {
      return std::vector<UpdateType>{cSTATUS,
                                     cENGAGEMENT_DATA,
                                     cFLIGHT_DATA,
                                     cFUEL_DATA,
                                     cNAV_DATA,
                                     cCONTROLS_DATA,
                                     cWEAPONS_DATA,
                                     cTRACK_DATA,
                                     cASSETS_DATA,
                                     cPERCEIVED_ITEM_DATA,
                                     cPRIORITIZED_ITEM_DATA};
   }
 
   WsfSA_Processor(const WsfScenario& aScenario);
   WsfSA_Processor& operator=(const WsfSA_Processor&) = delete;
   ~WsfSA_Processor() override;
   WsfSA_Processor* Clone() const override { return new WsfSA_Processor(*this); }

   static WsfSA_Processor* CreateSA_Processor(double aSimTime, WsfPlatform& aPlatform);

   static WsfSA_Processor* GetSA_Processor(const WsfPlatform& aPlatform);

   bool ProcessInput(UtInput& aInput) override;

   bool Initialize(double aSimTime) override;

   bool Initialize2(double aSimTime) override;

   void Update(double aSimTime) override;

   void HandleSA_ProcessorUpdates(double aSimTime);

   WsfSA_Perceive* Perceive() const { return mPerceivePtr.get(); }

   WsfSA_Assess* Assess() const { return mAssessPtr.get(); }

   WsfSA_Predict* Predict() const { return mPredictPtr.get(); }

   const WsfSA_Processor::PerceiveData* GetData() const { return &mData; }

   WsfP6DOF_Mover* GetP6DofMover() { return mP6DofMover; }

   wsf::six_dof::Mover* GetSixDOF_Mover() { return mSixDOF_Mover; }

   WsfBrawlerMover* GetBrawlerMover() { return mBrawlerMover; }

   WsfBrawlerFuel* GetBrawlerFuel() { return mBrawlerFuel; }

   WsfAirMover* GetAirMover() { return mAirMover; }

   WsfFuel* GetAirMoverFuel() { return mAirMoverFuel; }

   double GetUpdateInterval(UpdateType aUpdateType) const { return mUpdateMgmtData[aUpdateType].activeInterval; }

   double GetStartupInterval(UpdateType aUpdateType) const { return mUpdateMgmtData[aUpdateType].startupInterval; }

   bool SetUpdateInterval(UpdateType aUpdateType, double aUpdateInterval);

   void ResetUpdateInterval(UpdateType aUpdateType);

   double GetLastUpdateTime(UpdateType aUpdateType) const { return mUpdateMgmtData[aUpdateType].lastUpdateTime; }

   bool SetLastUpdateTime(UpdateType aUpdateType, double aSimTime);

   double GetNextUpdateTime(UpdateType aUpdateType) { return mUpdateMgmtData[aUpdateType].nextUpdateTime; }

   bool SetNextUpdateTime(UpdateType aUpdateType, double aSimTime);

   std::string GetUpdateTypeString(const UpdateType aUpdateType);

   double GetAssetDataPurgeLifetime() const { return mAssetDataPurgeLifetime; }

   bool SetAssetDataPurgeLifetime(double aPurgeLifetime);

   void ResetAssetDataPurgeLifetime() { mAssetDataPurgeLifetime = mStartupAssetDataPurgeLifetime; }

   static double RoundToBaseRateMultiple(double aNumToRound, double aMultiple);

   double GetVisualPerceptionDelay() { return mVisualPerceptionDelay; }

   double GetDisplayPerceptionDelay() { return mDisplayPerceptionDelay; }

   bool SetVisualPerceptionDelay(double aDelayTime);

   bool SetDisplayPerceptionDelay(double aDelayTime);
   WsfTrackProcessor* GetTrackProcessor(const std::string& aProcessorName);

   std::vector<WsfTrackProcessor*> GetTrackProcessors() { return mTrackProcessorList; }

   bool EntityIsInAssetGroup(const WsfSA_EntityPerception* aEntity) const;

   bool EntityIsInAssetGroup(size_t aEntityIndex) const;

   static const std::vector<WsfSA_EntityPerception*>& GetPlatformPerceivedAssets(const WsfPlatform& aPlatform,
                                                                                 double             aSimTime);

   static const std::vector<WsfSA_EntityPerception*>& GetPlatformPerceivedBogies(const WsfPlatform& aPlatform,
                                                                                 double             aSimTime);

   static const std::vector<WsfSA_EntityPerception*>& GetPlatformPerceivedBandits(const WsfPlatform& aPlatform,
                                                                                  double             aSimTime);

   const char* GetScriptClassName() const override { return "WsfSA_Processor"; }

   UtScriptClass* CreateScriptClass(const std::string& aClassName, UtScriptTypes* aScriptTypesPtr);

   void TrackManagerChanged(double aSimTime, WsfTrackManager* aNewManagerPtr);

   bool ProcessMessage(double aSimTime, const WsfMessage& aMessage) override;

   void SendMessage(double aSimTime, const WsfSA_EntityMessage& aStatusMessage);

   void LocalTrackDropped(double aSimTime, const WsfLocalTrack* aLocalTrackPtr);

   bool HasExternalLinks() const { return mExternalLinks.HasLinks(); }

   static void CheckForFrequencyUnits(double& aValue, UtInput& aInput);


   void PlatformAdded(double aSimTime, WsfPlatform* aPlatform) override;

   void PlatformDeleted(WsfPlatform* aPlatform) override;


   std::string GetSelectedWeapon() const;

   const WsfExplicitWeapon* SelectedWeapon() const;

   int QuantityOfSelectedWeapon() const;

   bool SetSelectedWeapon(std::string aWeaponName);

   const std::vector<WsfExplicitWeapon*> GetWeaponList() const;

   int GetInitialWeaponsQuantity() { return mInitialWeaponsQuantity; }

   void SetMasterArm(bool aArmed);

   bool GetMasterArm() const;

   bool MasterWarningActive() const;

   bool MasterCautionActive() const;

   bool WeaponBayDoorsAreOpen() const;

   bool SupportingWeapon() const;

   bool ShootCueActive() const;

   bool ShootCueBlinking() const;

   bool JammingDetected() const;


   bool EngagedTargetValid() const;

   SA_EngagedTarget GetEngagedTarget() const;

   void SetEngagedTarget(SA_EngagedTarget aTarget);


   int QuantityOfChaff() const;

   int QuantityOfFlares() const;

   int QuantityOfDecoys() const;

   bool DispenseChaff(double aSimTime);

   bool DispenseFlare(double aSimTime);

   bool DispenseDecoy(double aSimTime);


   static bool PlatformContainsSA_Processor(WsfPlatform* aPlatform);

   static const WsfSA_Processor* GetPlatformSA_Processor(const WsfPlatform* aPlatform);

   const std::vector<size_t> GetFilteredPlatformIdList() const { return mFilteredPlatformIdList; }

   bool IsEnemySide(const std::string& aSide) const;

   bool IsFriendlySide(const std::string& aSide) const;

   bool IsNeutralSide(const std::string& aSide) const;

   bool IsEnemyType(const std::string& aType) const;

   bool IsFriendlyType(const std::string& aType) const;

   bool IsNeutralType(const std::string& aType) const;

   bool IsMissileType(const std::string& aType) const;

   const WsfTrackProcessor* GetMWS_Processor() const;

   bool PlatformInTrackListMWS(const WsfPlatform* aPlatform) const;

   bool UseIFF() const { return mUseIFF; }

   bool UseSimpleIdByType() const { return mUseSimpleIdByType; }

   double MaxRangeForPerceivedAssets() const { return mMaxRangeForPerceivedAssets; }

   double MaxRangeForPerceivedBogiesAndBandits() const { return mMaxRangeForPerceivedBogiesAndBandits; }

   bool UseMaxRangeFilterForPerceivedAssets() const { return mUseMaxRangeFilterForPerceivedAssets; }

   bool UseMaxRangeFilterForPerceivedBogiesAndBandits() const { return mUseMaxRangeFilterForPerceivedBogiesAndBandits; }

   double MaxRangeForEngagementData() const { return mMaxRangeForEngagementData; }

   bool UseMaxRangeForEngagementData() const { return mUseMaxRangeForEngagementData; }

   double AssumedRangeForAngleOnlyTargets() const { return mAssumedRangeForAngleOnlyTargets; }

   std::uint16_t FlightId() { return mFlightId; }

   std::string IdFlag() { return mIdFlag; }

   void SetFlightId(std::uint16_t aFlightId) { mFlightId = aFlightId; }

   void SetIdFlag(const std::string& aIdFlag) { mIdFlag = aIdFlag; }

   const std::string& ESM_TrackProcessor() const { return mESM_TrackProcessor; }

   const std::string& MWS_TrackProcessor() const { return mMWS_TrackProcessor; }

   const std::string& RadarTrackProcessor() const { return mRadarTrackProcessor; }

   const std::string& IRST_TrackProcessor() const { return mIRST_TrackProcessor; }

   const std::string& DAS_TrackProcessor() const { return mDAS_TrackProcessor; }

   const std::string& FLIR_TrackProcessor() const { return mFLIR_TrackProcessor; }

   const std::string& EyesTrackProcessor() const { return mEyesTrackProcessor; }

   std::string PerceptionMasterTrackProcessor() const { return mPerceptionMasterTrackProcessorStr; }

   bool UsingPerceptionMasterTrackProcessor() const { return mUsingPerceptionMasterTrackProcessor; }

   WsfTrackProcessor* GetPerceptionMasterTrackProcessor() const { return mPerceptionMasterTrackProcessorPtr; }

   WsfLocalTrackList* GetPerceptionMasterTrackProcessorTrackList() const;
 
   // Flight Kinematics Data
   struct SA_AircraftKinematics
   {
      double      lat_deg{0.0};
      double      lon_deg{0.0};
      float       kcas{0.0f};
      float       ktas{0.0f};
      float       mach{0.0f};
      float       altBaro_ft{0.0f};
      float       altRadar_ft{0.0f};
      float       vertSpd_fpm{0.0f};
      float       alpha_deg{0.0f};
      float       beta_deg{0.0f};
      float       gLoad{0.0f};
      float       gAvail{0.0f};
      float       heading_deg{0.0f};
      float       pitch_deg{0.0f};
      float       roll_deg{0.0f};
      float       gX{0.0f};
      float       gY{0.0f};
      std::string pilotType{""};
      bool        afterburnerOn{false};
      bool        contrailing{false};
      bool        stallWarning{false};
      bool        alphaValid{false};
      bool        betaValid{false};
      bool        kcasValid{false};
      bool        nxValid{false};
      bool        nyValid{false};
      bool        nzValid{false};
      bool        gAvailValid{false};
   };

   const SA_AircraftKinematics& GetAircraftKinematics() const { return mAircraftKinematicsData; }

   void SetAircraftKinematics(const SA_AircraftKinematics& aFlightData) { mAircraftKinematicsData = aFlightData; }
 
   // Fuel Data
   struct SA_FuelSystemData
   {
      float   fuelInternal_lbs{0.0f};
      float   fuelExternal_lbs{0.0f};
      float   fuelCapInt_lbs{0.0f};
      float   fuelCapExt_lbs{0.0f};
      float   grossWgt_lbs{0.0f};
      float   joker_lbs{0.0f};
      float   bingo_lbs{0.0f};
      float   fuelFlow_pph{0.0f};
      float   normalizedFuelQty{0.0f};
      uint8_t numExtTanks{0};
      bool    dropTanksPresent{false};
      bool    fuelValid{false};
   };

   const SA_FuelSystemData& GetFuelSystemData() const { return mFuelSystemData; }

   void SetFuelSystemData(const SA_FuelSystemData& aData) { mFuelSystemData = aData; }
 
   // Nav Data
   struct SA_NavigationLatLon
   {
      float lat_deg{0.0f};
      float lon_deg{0.0f};
   };
 
   struct SA_NavigationDataSummary
   {
      bool                             dataValid{false};
      uint8_t                          numWaypoints{0};
      uint8_t                          currentWaypoint{0};
      float                            headingBug_deg{0.0f};
      float                            distanceToWaypoint_nm{0.0f};
      float                            timeToWaypoint_sec{0.0f};
      std::vector<SA_NavigationLatLon> waypoints;
   };

   const SA_NavigationDataSummary& GetNavigationDataSummary() const { return mNavigationDataSummary; }

   void SetNavigationDataSummary(const SA_NavigationDataSummary& aData) { mNavigationDataSummary = aData; }
 
   // Flight Controls Data
   struct SA_FlightControlsDataSummary
   {
      float stickRgtInput{0.0f};
      float stickBackInput{0.0f};
      float rudderRgtInput{0.0f};
      float speedBrakeInput{0.0f};
      float throttleInput{0.0f};
      float aileronRgtNormalized{0.0f};
      float aileronLftNormalized{0.0f};
      float flapRgtNormalized{0.0f};
      float flapLftNormalized{0.0f};
      float stabilizerRgtNormalized{0.0f};
      float stabilizerLftNormalized{0.0f};
      float rudderRgtNormalized{0.0f};
      float rudderLftNormalized{0.0f};
      float rudderNormalized{0.0f};
      float speedBrakeNormalized{0.0f};
      float thrustNormalized{0.0f};
      float landingGear{0.0f};
      bool  throttleValid{false};
      bool  aileronsValid{false};
      bool  flapsValid{false};
      bool  twinRuddersValid{false};
      bool  singleRudderValid{false};
   };

   const SA_FlightControlsDataSummary& GetFlightControlsDataSummary() const { return mFlightControlsDataSummary; }

   void SetFlightControlsDataSummary(const SA_FlightControlsDataSummary& aData) { mFlightControlsDataSummary = aData; }
 
   struct SA_WeaponNameQtyPair
   {
      std::string weaponName{""};
      uint16_t    quantity{0};
   };
 
   struct SA_WeaponEngagedTarget
   {
      unsigned int targetIndex{0};
      float        rangeMax_nm{0.0f};
      float        rangeNe_nm{0.0f};
      float        rangeMin_nm{0.0f};
      float        rangeCurrent_nm{0.0f};
      float        rangeClosureRate_kts{0.0f};
      float        timeToIntercept_sec{0.0f};
      float        timeToActive_sec{0.0f};
      float        targetKTAS{0.0f};
      float        targetAspect_deg{0.0f};
      float        targetAz_deg{0.0f};
      float        targetEl_deg{0.0f};
   };
 
   struct SA_WeaponsDataSummary
   {
      unsigned int                        platformIndex{0};
      std::vector<SA_WeaponNameQtyPair>   weaponList{};
      std::string                         selectedWeapon{""};
      uint16_t                            numSelectedWeapon{0};
      uint16_t                            initialNumWeapons{0};
      std::vector<SA_WeaponEngagedTarget> engagedTargetList{};
      uint8_t                             numChaff{0};
      uint8_t                             numFlares{0};
      uint8_t                             numDecoys{0};
 
      bool weaponBayDoorsOpen{false};
      bool supportingWeapon{false};
      bool masterWarning{false};
      bool masterCaution{false};
      bool shootCueActive{false};
      bool shootCueBlink{false};
      bool masterArmActive{false};
      bool jammingDetected{false};
   };

   const SA_WeaponsDataSummary GetWeaponsDataSummary() const { return mWeaponsDataSummary; }

   void SetWeaponsDataSummary(const SA_WeaponsDataSummary& aData) { mWeaponsDataSummary = aData; }
 
   enum SA_Identification
   {
      ID_UNKNOWN  = 0,
      ID_FRIENDLY = 1,
      ID_NEUTRAL  = 2,
      ID_BOGIE    = 3,
      ID_BANDIT   = 4
   };
 
   // Track Data
   struct SA_TrackEntryData
   {
      unsigned int      targetPlatformIndex{0};
      double            lat_deg{0.0};
      double            lon_deg{0.0};
      float             altitude_ft{0.0f};
      float             bearing_deg{0.0f};
      float             elevation_deg{0.0f};
      float             range_nm{0.0f};
      float             rangeRate_kts{0.0f};
      float             targetSpeed_kts{0.0f};
      float             targetHdg_deg{0.0f};
      float             targetAspect_deg{0.0f};
      std::string       idString{""};
      std::string       tgtPlatformName{""};
      std::string       tgtTypeName{""};
      SA_Identification identification{ID_UNKNOWN};
      bool              latLonValid{false};
      bool              altitudeValid{false};
      bool              bearingValid{false};
      bool              elevationValid{false};
      bool              rangeValid{false};
      bool              rangeRateValid{false};
      bool              targetSpeedValid{false};
      bool              targetHdgValid{false};
      bool              targetAspectValid{false};
      bool              idIffValid{false};
      bool              idAuxValid{false};
      bool              idSideValid{false};
      bool              idTypeValid{false};
      bool              isMissile{false};
   };
 
   // Track manager Data
   struct SA_TrackManagerData
   {
      std::string                    name;
      bool                           isMasterProcessor = false;
      std::vector<SA_TrackEntryData> trackList;
   };

   const std::vector<SA_TrackManagerData>& GetTrackManagerList() const { return mTrackManagerDataList; }

   void SetTrackManagerList(const std::vector<SA_TrackManagerData>& aData) { mTrackManagerDataList = aData; }

   double TryUpdateFlightKinematics(double aSimTime);

   double TryUpdateFuel(double aSimTime);

   double TryUpdateNav(double aSimTime);

   double TryUpdateFlightControls(double aSimTime);

   double TryUpdateWeapons(double aSimTime);

   double TryUpdateTracks(double aSimTime);

   double TryUpdateBehaviorCalculation(double aSimTime);

   void UpdateFlightKinematics(double aSimTime);

   void UpdateFuel(double aSimTime);

   void UpdateNav(double aSimTime);

   void UpdateFlightControls(double aSimTime);

   void UpdateWeapons(double aSimTime);

   void UpdateTracks(double aSimTime);

   void UpdateFlightKinematicsData(double aSimTime);

   void UpdateFuelData(double aSimTime);

   void UpdateNavData(double aSimTime);

   void UpdateFlightControlsData(double aSimTime);

   void UpdateWeaponsData(double aSimTime);

   void UpdateTrackData(double aSimTime);

   void UpdateBehaviorCalculation(double aSimTime);

   bool AfterburnerOn() const { return mAircraftKinematicsData.afterburnerOn; }

   bool IsContrailing() const { return mAircraftKinematicsData.contrailing; }

   void CalculateObservables();

   void CalculateEmissions();
 
   // These functions support "RF emissions" related calculations

   bool RadarEmitting() const { return mRadarEmitting; }

   bool JammerEmitting() const { return mJammerEmitting; }

   bool OtherSystemsEmitting() const { return mOtherSystemsEmitting; }

   bool FuelStateBingoReached() const;

   bool FuelStateJokerReached() const;

   double FuelStateNormalized() const;

   double TimeToJoker() const;

   double TimeToBingo() const;

   double TimeToEmpty() const;
 
protected:
   WsfSA_Processor(const WsfSA_Processor& aSrc);

   void CallScript(double aSimTime, const std::string& aScriptName);

   double CallScriptReturnDouble(double aSimTime, const std::string& aScriptName);

   bool ScriptExists(const std::string& aScriptName);

   void DebugTestOutput(double aSimTime);
 
private:
   UtCallbackHolder mCallbacks; 
 
   // The platform carrying this SA Processor
   WsfPlatform* mPlatform{nullptr}; 
 
   // Possible mover (and fuel) objects
   bool                 mMoverPresent{false};   
   WsfP6DOF_Mover*      mP6DofMover{nullptr};   
   wsf::six_dof::Mover* mSixDOF_Mover{nullptr}; 
   WsfBrawlerMover*     mBrawlerMover{nullptr}; 
   WsfBrawlerFuel*      mBrawlerFuel{nullptr};  
   WsfAirMover*         mAirMover{nullptr};     
   WsfFuel*             mAirMoverFuel{nullptr}; 
 
   // Master track processor (track manager) and track processors
   WsfTrackManager* mMasterTrackProcessor{nullptr}; 
   std::vector<WsfTrackProcessor*> mTrackProcessorList; 
 
   // Track Data - Includes data for each track processor on the platform
   std::vector<SA_TrackManagerData> mTrackManagerDataList; 
   bool mFilterAssetsFromTracks{true};                     
 
   // Weapons Data -- Includes the number/types of weapons, countermeasures, and warnings/flags
   SA_WeaponsDataSummary mWeaponsDataSummary;        
   int                   mInitialWeaponsQuantity{0}; 
 
   // Modules - Perceive, Assess, and Predict
   std::unique_ptr<WsfSA_Perceive> mPerceivePtr; 
   std::unique_ptr<WsfSA_Assess>   mAssessPtr;   
   std::unique_ptr<WsfSA_Predict>  mPredictPtr;  
 
   // Enemy/friendly sides/types
   std::vector<std::string> mEnemySidesList;    
   std::vector<std::string> mFriendlySidesList; 
   std::vector<std::string> mNeutralSidesList;  
   std::vector<std::string> mEnemyTypesList;    
   std::vector<std::string> mFriendlyTypesList; 
   std::vector<std::string> mNeutralTypesList;  
   std::vector<std::string> mMissileTypesList;  
 
   // Identification
   bool mUseIFF{false};            
   bool mUseSimpleIdByType{false}; 
 
   // Range settings
   double mMaxRangeForPerceivedAssets{0.0}; 
   double mMaxRangeForPerceivedBogiesAndBandits{
      0.0}; 
   bool mUseMaxRangeFilterForPerceivedAssets{false}; 
   bool mUseMaxRangeFilterForPerceivedBogiesAndBandits{
      false};                                    
   double mMaxRangeForEngagementData{0.0};       
   bool   mUseMaxRangeForEngagementData{false};  
   double mAssumedRangeForAngleOnlyTargets{0.0}; 

   std::vector<size_t> mFilteredPlatformIdList;
 
   // Filters for monitored platforms, used for engagement assessment
   bool mFilterRequiresSameSide{false};            
   bool mFilterRequiresNotSameSide{false};         
   bool mFilterRequiresAirDomain{false};           
   bool mFilterRequiresNotAirDomain{false};        
   bool mFilterRequiresLandOrSurfaceDomain{false}; 
   bool mFilterRequiresNotSubsurfaceDomain{false}; 
   bool mFilterRequiresNotSpaceDomain{false};      
   bool mFilterRequiresSA_Processor{false};        
 
   // Missile identification filters
   bool mMissileSpeedAnyAlt{false};     
   bool mMissileAltAnySpeed{false};     
   bool mMissileSpeedWithAlt{false};    
   bool mMissileAltWithSpeed{false};    
   bool mMissileNoseAngle{false};       
   bool mMissileTimeToIntercept{false}; 
   bool mMissileDistance{false};        
 
   double mMissileSpeedAnyAltValue{0.0};     
   double mMissileAltAnySpeedValue{0.0};     
   double mMissileSpeedWithAltValue{0.0};    
   double mMissileAltWithSpeedValue{0.0};    
   double mMissileNoseAngleValue{0.0};       
   double mMissileTimeToInterceptValue{0.0}; 
   double mMissileDistanceValue{0.0};        
 
   // Flight ID, provides common means of identifying "flights" (typically two or four aircraft). Each flight should use
   // a unique number.
   std::uint16_t mFlightId{0}; 
   std::string   mIdFlag{""};  
 
   // Flight, fuel, navigation, and controls data
   double mBingoFuel_lbs{0.0}; 
   double mJokerFuel_lbs{0.0}; 
   SA_AircraftKinematics        mAircraftKinematicsData;    
   SA_FuelSystemData            mFuelSystemData;            
   SA_NavigationDataSummary     mNavigationDataSummary;     
   SA_FlightControlsDataSummary mFlightControlsDataSummary; 
 
   // Optional Track Processor Names
   std::string mESM_TrackProcessor{""};  
   std::string mMWS_TrackProcessor{""};  
   std::string mRadarTrackProcessor{""}; 
   std::string mIRST_TrackProcessor{""}; 
   std::string mDAS_TrackProcessor{""};  
   std::string mFLIR_TrackProcessor{""}; 
   std::string mEyesTrackProcessor{""};  
   std::string mPerceptionMasterTrackProcessorStr{""}; 
   WsfTrackProcessor* mPerceptionMasterTrackProcessorPtr{nullptr}; 
   bool               mUsingPerceptionMasterTrackProcessor{
      false}; 
 
   // RF Emissions
   bool mRadarEmitting{false};        
   bool mJammerEmitting{false};       
   bool mOtherSystemsEmitting{false}; 
 
   double mAssetDataPurgeLifetime{0};        
   double mStartupAssetDataPurgeLifetime{0}; 
   double mDisplayPerceptionDelay{0.0};
   double mVisualPerceptionDelay{0.0};
 
   // This structure holds the collection of data members that are used to manage a given type of SA processor update.
   // The vector that follows is used to manage this data for all the SA processor update types.
   struct UpdateMgmtRecord
   {
      double startupInterval{0.0};  // update interval established at startup (multiple of mUpdateInterval)
      double activeInterval{0.0};   // update interval that is currently active (multiple of mUpdateInterval)
      double lastUpdateTime{0.0};   // last simulation time at which this update was performed
      double nextUpdateTime{0.0};   // next simulation time at which this update is requested
      bool   manualModeLock{false}; // true = disallow automated/adaptive changes to this update rate
   };
 
   std::vector<UpdateMgmtRecord> mUpdateMgmtData; // used to manage data for all SA processor update types
   size_t                        mEventCount{0};  // total number of update events
   PerceiveData                  mData;           // perceived data container used by multiple SAP classes
   bool mUpdatedScriptContext{false}; // set to true if the script context was updated within HandleSA_ProcessorUpdates
   bool mUseDebugOutput{false};       // set to true to output debug information
   std::string mDebugPlatformName{"Talon_1_1"}; // set this to the name of the platform used in debugging
};
 
#endif