WsfSensorComponent.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 WSFSENSORCOMPONENT_HPP
#define WSFSENSORCOMPONENT_HPP
 
class UtInput;
#include "WsfComponent.hpp"
class WsfPlatform;
class WsfSensor;
class WsfSensorBeam;
class WsfSensorMode;
class WsfSensorResult;
class WsfSensorTrackerSettings;
class WsfSimulation;
#include "WsfStandardSensorErrorModel.hpp"
class WsfTrack;
class WsfTrackId;

class WSF_EXPORT WsfSensorComponent : public WsfComponentT<WsfSensor>
{
public:
   // Makes things a little shorter.
   using TrackerSettings = WsfSensorTrackerSettings;


   WsfSensor*     GetSensor() const { return GetComponentParent(); }
   WsfPlatform*   GetPlatform() const;
   WsfSimulation* GetSimulation() const;


   using WsfComponent::Initialize;
   using WsfComponent::Initialize2;
   using WsfComponent::PreInitialize;
   using WsfComponent::ProcessInput;
 
   virtual bool ProcessModeInput(UtInput& aInput, WsfSensorMode& aSensorMode) { return false; }
   virtual bool ProcessBeamInput(UtInput& aInput, WsfSensorBeam& aSensorBeam) { return false; }
 
   virtual void PlatformAdded(double aSimTime, WsfPlatform* aPlatformPtr) {}
   virtual void PlatformDeleted(WsfPlatform* aPlatformPtr) {}
 
   virtual void SelectMode(double aSimTime, WsfStringId aModeNameId) {}
   virtual void DeselectMode(double aSimTime, WsfStringId aModeNameId) {}
   virtual void TurnOn(double aSimTime) {}
   virtual void TurnOff(double aSimTime) {}



   virtual void AttemptToDetect(double aSimTime, WsfSensorResult& aResult) {}

   virtual void PostAttemptToDetect(double aSimTime, WsfPlatform* aTargetPtr, WsfSensorResult& aResult) {}

   virtual void ComputeSphericalMeasurementErrors(const WsfSensorResult&           aResult,
                                                  wsf::SphericalMeasurementErrors& aErrors) const
   {
   }
 
   // NOTE The callbacks from PerformScheduledDetections were broken up to pre and post to
   //      enable the same order of operations as was present in WSF 1.x.

   virtual void PrePerformScheduledDetections(double aSimTime) {}

   virtual void PostPerformScheduledDetections(double aSimTime) {}
 
   // Extends WsfSensorMode::UpdateTrack
   virtual void UpdateTrack(double aSimTime, WsfTrack* aTrackPtr, WsfPlatform* aTargetPtr, WsfSensorResult& aResult) {}



   virtual bool TrackerAllowTracking(double                 aSimTime,
                                     const TrackerSettings& aSettings,
                                     const WsfTrackId&      aRequestId,
                                     size_t                 aObjectId,
                                     WsfTrack*              aTrackPtr,
                                     WsfSensorResult&       aResult)
   {
      return true;
   }

   virtual void TrackerInitializeTrack(double                 aSimTime,
                                       const TrackerSettings& aSettings,
                                       const WsfTrackId&      aRequestId,
                                       size_t                 aObjectId,
                                       WsfSensorMode*         aModePtr,
                                       WsfTrack*&             aTrackPtr)
   {
   }

   virtual void TrackerUpdateTrack(double                 aSimTime,
                                   const TrackerSettings& aSettings,
                                   const WsfTrackId&      aRequestId,
                                   size_t                 aObjectId,
                                   WsfSensorMode*         aModePtr,
                                   WsfTrack*              aTrackPtr,
                                   WsfPlatform*           aTargetPtr,
                                   WsfSensorResult&       aResult)
   {
   }

   virtual void TrackerDropTrack(double                 aSimTime,
                                 const TrackerSettings& aSettings,
                                 const WsfTrackId&      aRequestId,
                                 size_t                 aObjectId,
                                 WsfSensorMode*         aModePtr,
                                 WsfTrack*              aTrackPtr)
   {
   }



   static void AttemptToDetect(WsfSensor& aSensor, double aSimTime, WsfSensorResult& aResult);
 
   static bool PostAttemptToDetect(WsfSensor& aSensor, double aSimTime, WsfPlatform* aTargetPtr, WsfSensorResult& aResult);
 
   WSF_DEPRECATED static void ComputeMeasurementErrors(WsfSensor&       aSensor,
                                                       WsfSensorResult& aResult,
                                                       double&          aAzError,
                                                       double&          aElError,
                                                       double&          aRangeError,
                                                       double&          aRangeRateError);
 
   static void ComputeSphericalMeasurementErrors(WsfSensor&                       aSensor,
                                                 const WsfSensorResult&           aResult,
                                                 wsf::SphericalMeasurementErrors& aErrors);
 
   static void PrePerformScheduledDetections(WsfSensor& aSensor, double aSimTime);
 
   static void PostPerformScheduledDetections(WsfSensor& aSensor, double aSimTime);
 
   static void UpdateTrack(WsfSensor&       aSensor,
                           double           aSimTime,
                           WsfTrack*        aTrackPtr,
                           WsfPlatform*     aTargetPtr,
                           WsfSensorResult& aResult);
};
 
#endif