WsfPhysicalScanSensorScheduler.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 WSFPHYSICALSCANSENSORSCHEDULER_HPP
#define WSFPHYSICALSCANSENSORSCHEDULER_HPP
 
#include "wsf_export.h"
 
#include <functional>
#include <queue>
#include <vector>
 
#include "UtOptional.hpp"
#include "WsfSensorScheduler.hpp"
#include "WsfTrack.hpp"
 
class WSF_EXPORT WsfPhysicalScanSensorScheduler : public WsfSensorScheduler
{
   using SearchListSortFn = std::function<bool(size_t, size_t)>;
 
public:
   WsfPhysicalScanSensorScheduler() = default;
   WsfPhysicalScanSensorScheduler(std::string aTypeName, bool aRandomizeInitialHeading, SearchListSortFn aSearchListSort);
   ~WsfPhysicalScanSensorScheduler() override = default;
 
   static std::unique_ptr<WsfSensorScheduler> ObjectFactory(const std::string& aTypeName);
 
   WsfSensorScheduler* Clone() const override;
 
   bool ProcessInput(UtInput& aInput) override;
 
   bool Initialize(double aSimTime, WsfSensor* aSensorPtr, WsfSensorTracker* aTrackerPtr) override;
 
   void ModeDeselected(double aSimTime, WsfStringId aModeNameId) override;
 
   void ModeSelected(double aSimTime, WsfStringId aModeNameId) override;
 
   void PlatformAdded(double aSimTime, WsfPlatform* aPlatformPtr) override;
 
   void RemoveTarget(double aSimTime, size_t aTargetIndex) override;
 
   bool SelectTarget(double               aSimTime,
                     double&              aNextSimTime,
                     size_t&              aTargetIndex,
                     WsfTrackId&          aRequestId,
                     WsfSensor::Settings& aSettings) override;
 
   void TurnOff(double aSimTime) override;
 
   void TurnOn(double aSimTime) override;

   double GetInitialHeading() const { return mInitialHeading.value(); }
 
protected:
   WsfPhysicalScanSensorScheduler(const WsfPhysicalScanSensorScheduler& aSrc);
   WsfPhysicalScanSensorScheduler& operator=(const WsfPhysicalScanSensorScheduler&) = delete;
 
   void CheckSearchModeAvailability();
 
   void ResetSearchList();

   std::vector<WsfSensorMode*> mModeList;

   size_t mLastExplicitModeIndex{0};

   std::vector<size_t> mSearchModeIndex{0};

   bool mSearchAllowed{false};
 
   struct SensorTarget
   {
      SensorTarget()
         : SensorTarget(0, 0)
      {
      }
 
      SensorTarget(size_t aTargetIndex, size_t aModeIndex)
         : mTargetIndex(aTargetIndex)
         , mModeIndex(aModeIndex)
      {
      }
 
      size_t mTargetIndex;
      size_t mModeIndex;
   };

   std::queue<SensorTarget> mSensorTargetQueue;

   double mSensorUpdateInterval{0.0};
 
   struct SearchModeData
   {
      double mLastUpdate;           // TODO - not sure this is required per mode (sensor level)
      double mSensorPieSize;        
      double mCurrentSensorHeading; // TODO - not sure this is required per mode (sensor level)
   };
 
   std::map<size_t, SearchModeData> mSearchModeDataMap;

   double mLastUpdate{-1.0};

   // double                      mCurrentSensorHeading;
 
private:
   std::string          mTypeName{"physical_scan"};
   ut::optional<double> mInitialHeading{ut::nullopt}; // If empty, initial heading will be randomized during initialization
   SearchListSortFn     mSearchListSort;
};
 
#endif