WsfDefaultSensorScheduler.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 WSFDEFAULTSENSORSCHEDULER_HPP
#define WSFDEFAULTSENSORSCHEDULER_HPP
 
#include "wsf_export.h"
 
#include <vector>
 
#include "WsfSensorScheduler.hpp"
#include "WsfTrack.hpp"
#include "WsfTrackId.hpp"

class WSF_EXPORT WsfDefaultSensorScheduler : public WsfSensorScheduler
{
public:
   WsfDefaultSensorScheduler();
 
   ~WsfDefaultSensorScheduler() override = default;
 
   static std::unique_ptr<WsfSensorScheduler> ObjectFactory(const std::string& aTypeName);
 
   WsfSensorScheduler* Clone() const override;
 
   void FrameTimeChanged(double aSimTime, WsfStringId aModeNameId) override;
 
   int GetActiveRequestCount(WsfStringId aModeNameId) const override;
 
   int GetMaximumRequestCount(WsfStringId aModeNameId) const override;
 
   bool HaveRequestFor(const WsfTrackId& aRequestId) const 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 PlatformDeleted(WsfPlatform* aPlatformPtr) override;
 
   bool ProcessInput(UtInput& aInput) override;
 
   void RemoveTarget(double aSimTime, size_t aTargetIndex) override;
 
   const WsfTrack& GetTrackForRequest(const WsfTrackId& aRequestId) const override;
 
   bool SelectTarget(double               aSimTime,
                     double&              aNextSimTime,
                     size_t&              aTargetIndex,
                     WsfTrackId&          aRequestId,
                     WsfSensor::Settings& aSettings) override;
 
   bool StartTracking(double aSimTime, const WsfTrack& aTrack, WsfStringId aModeNameId) override;
 
   bool StopTracking(double aSimTime, const WsfTrackId& aRequestId) override;
 
   void TrackerModeChange(double            aSimTime,
                          const WsfTrackId& aRequestId,
                          size_t            aTargetIndex,
                          WsfPlatform*      aTargetPtr,
                          const WsfTrack*   aTrackPtr,
                          WsfStringId       aModeNameId) override;
 
   void TurnOff(double aSimTime) override;
 
   void TurnOn(double aSimTime) override;

   class Request
   {
   public:
      Request() = default;
      Request(double aSimTime, const WsfTrack& aTrack, size_t aModeIndex)
         : mRequestId(aTrack.GetTrackId())
         , mTrack(aTrack)
         , mStartTime(aSimTime)
         , mNextVisitTime(aSimTime)
         , mLastVisitTime(-1.0)
         , mTargetIndex(0)
         , mModeIndex(aModeIndex)
      {
      }

      WsfTrackId mRequestId = WsfTrackId();

      WsfTrack mTrack = WsfTrack();

      double mStartTime = -1.0;

      double mNextVisitTime = -1.0;

      double mLastVisitTime = -1.0;

      size_t mTargetIndex = 0;

      size_t mModeIndex = 0;
   };
   using RequestList      = std::vector<Request>;
   using RequestListIndex = RequestList::size_type;
 
   const RequestList& GetRequestList() const { return mRequestList; }
 
protected:
   enum ScanSchedulingMethod
   {
      cSSM_RANDOM,
      cSSM_INPUT_ORDER,
      cSSM_REVERSE_INPUT_ORDER
   };
 
   WsfDefaultSensorScheduler(const WsfDefaultSensorScheduler& aSrc);
   WsfDefaultSensorScheduler& operator=(const WsfDefaultSensorScheduler&) = delete;
 
   void CheckSearchModeAvailability();
 
   void DeselectMode(double aSimTime, Request& aRequest);
 
   void SelectMode(double aSimTime, Request& aRequest);
 
   void ResetTrackList();
 
   void ResetSearchList();
 
   size_t SelectTargetForRequest(Request& aRequest);
 
   bool TargetHasActiveRequest(size_t aTargetIndex) const;
 
   void UpdateNextTrackVisitTime();
 
   void UpdateSearchChanceInterval();
 
   void UpdateSearchFrameTime(double aSimTime);
 

   class CompareRequestId
   {
   public:
      CompareRequestId(const WsfTrackId& aRequestId)
         : mRequestId(aRequestId)
      {
      }
 
      bool operator()(const Request& aRequest) const { return (aRequest.mRequestId == mRequestId); }
 
   private:
      WsfTrackId mRequestId;
   };

   std::vector<WsfSensorMode*> mModeList;
 
   double mDwellEndTime;
   double mNextSearchVisitTime;
   double mNextTrackVisitTime;
   double mSearchChanceInterval;
   double mSearchFrameTime;

   SearchListIndex mSearchIndex;

   RequestList mRequestList;

   RequestListIndex mRequestIndex;

   size_t mLastExplicitModeIndex;

   size_t mSearchModeIndex;

   bool mSearchAllowed;

   bool mCheckSearchList;

   ScanSchedulingMethod mScanSchedulingMethod;
};
 
#endif