WsfSimulation.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 WSFSIMULATION_HPP
#define WSFSIMULATION_HPP
 
#include "wsf_export.h"
 
#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <string>
#include <vector>
 
class UtAtmosphere;
class UtInput;
#include "UtMemory.hpp"
#include "UtRandom.hpp"
class UtScriptClass;
#include "UtScriptExecutor.hpp"
class UtScriptTypes;
#include "UtWallClock.hpp"
#include "WsfAdvancedBehaviorObserver.hpp"
class WsfApplication;
#include "WsfBehaviorObserver.hpp"
#include "WsfClockSource.hpp"
#include "WsfCommObserver.hpp"
#include "WsfDateTime.hpp"
#include "WsfDisObserver.hpp"
#include "WsfEM_Manager.hpp"
class WsfEnvironment;
#include "WsfEvent.hpp"
#include "WsfEventManager.hpp"
#include "WsfException.hpp"
#include "WsfExchangeObserver.hpp"
#include "WsfExtensionList.hpp"
#include "WsfFuelObserver.hpp"
#include "WsfGroupManager.hpp"
class WsfIFF_Manager;
class WsfLOS_Manager;
class WsfMover;
#include "WsfMoverObserver.hpp"
#include "WsfMultiThreadManager.hpp"
class WsfPathFinderList;
class WsfPlatform;
#include "WsfPlatformObserver.hpp"
class WsfPlatformPart;
#include "WsfPlatformPartObserver.hpp"
class WsfProcessor;
#include "WsfProcessorObserver.hpp"
class WsfRealTimeClockSource;
class WsfRoute;
class WsfScenario;
#include "WsfScriptStateMachineObserver.hpp"
#include "script/WsfScriptContext.hpp"
class WsfSensor;
#include "WsfSensorObserver.hpp"
class WsfSimulationExtension;
class WsfSimulationInput;
#include "WsfSimulationObserver.hpp"
#include "WsfStringId.hpp"
class WsfSystemLog;
#include "WsfTaskObserver.hpp"
#include "WsfTrackObserver.hpp"
#include "WsfTypes.hpp"
class WsfZone;
#include "WsfZoneAttenuation.hpp"
#include "WsfZoneObserver.hpp"

namespace wsf
{
class TerrainInterface;
namespace comm
{
class Comm;
class NetworkManager;
} // namespace comm
} // namespace wsf

 
class WSF_EXPORT WsfSimulation
{
public:
   enum State
   {
      cPENDING_INITIALIZE, 
      cINITIALIZING,       
      cPENDING_START,      
      cSTARTING,           
      cACTIVE,             
      cPENDING_COMPLETE, 
      cCOMPLETE          
   };

   enum CompletionReason
   {
      cNONE,             
      cEND_TIME_REACHED, 
      cRESET,            
      cTERMINATE,        
      cOTHER             
   };

   class WSF_EXPORT InitializeError : public WsfException
   {
   public:
      InitializeError();
   };

   class WSF_EXPORT StartError : public WsfException
   {
   public:
      StartError();
   };

   class CreateError : public WsfException
   {
   public:
      CreateError();
   };

 
   class WSF_EXPORT AddPlatformEvent : public WsfEvent
   {
   public:
      AddPlatformEvent(double aSimTime, WsfPlatform* aPlatformPtr);
 
      ~AddPlatformEvent() override;
 
      EventDisposition Execute() override;
 
   private:
      WsfPlatform* mPlatformPtr;
   };
 
   WsfSimulation(const WsfScenario& aScenario, unsigned int aRunNumber);
   virtual ~WsfSimulation();
   WsfSimulation(const WsfSimulation& aSrc) = delete;
   WsfSimulation& operator=(const WsfSimulation& aRhs) = delete;
 
   const WsfScenario& GetScenario() const { return mScenario; }
   WsfApplication&    GetApplication() const;


   virtual void Initialize();
 
   virtual void PrepareSimulation();
 
   virtual void AddEvent(std::unique_ptr<WsfEvent> aEventPtr);
   // A helper function to construct and queue an event, returning a non-owning reference to the event
   template<typename T, typename... Args>
   T* AddEventT(Args&&... args)
   {
      static_assert(std::is_base_of<WsfEvent, T>::value, "Template type argument must derive from WsfEvent");
      auto eventPtr  = ut::make_unique<T>(std::forward<Args>(args)...);
      auto returnPtr = eventPtr.get();
      AddEvent(std::move(eventPtr));
      return returnPtr;
   }
 
   virtual void AddWallEvent(std::unique_ptr<WsfEvent> aEventPtr);
   // A helper function to construct and queue a wall event, returning a non-owning reference to the event
   template<typename T, typename... Args>
   T* AddWallEventT(Args&&... args)
   {
      static_assert(std::is_base_of<WsfEvent, T>::value, "Template type argument must derive from WsfEvent");
      auto eventPtr  = ut::make_unique<T>(std::forward<Args>(args)...);
      auto returnPtr = eventPtr.get();
      AddWallEvent(std::move(eventPtr));
      return returnPtr;
   }
 
   virtual double AdvanceTime();
 
   virtual double AdvanceTime(double aSimTime);
 
   virtual bool ShouldExecute() const;
 
   virtual void Start();
 
   virtual void Pause();
 
   void PauseAndRequestAdvance(double);
 
   virtual void Resume();
 
   virtual void Complete(double aSimTime);
 
   virtual void RequestReset();
 
   virtual void WaitForAdvanceTime();

   bool IsActive() const { return (mState == cACTIVE); }

   State GetState() const { return mState; }

   const std::string& GetStateString() const;

   static const std::string& GetStateString(State aState);

   CompletionReason GetCompletionReason() const { return mCompletionReason; }
 
   virtual std::string GetCompletionReasonString() const;
 
   virtual void RequestTermination();

   void SetEndTime(double aEndTime);

   double GetSimTime() const { return mSimTime; }

   double GetEndTime() const { return mEndTime; }
 
   virtual double GetNextEventTime() const;

   double GetRealTime() const { return mRealTime; }

   bool IsRealTime() const { return mIsRealTime; }

   double GetWallTime() const;

   double GetTimeBehind() const { return mTimeBehind; }

   double GetTimestep() const { return mTimestep; }

   double GetSyncTimestep() const { return mSyncTimestep; }

   virtual void SetRealtime(double aSimTime, bool aIsRealTime) {}
 
   void SetIsExternallyStarted(bool aIsExternallyStarted);

   bool IsExternallyStarted() const { return mIsExternallyStarted; }

   bool MultiThreadingActive() const { return mMultiThreadingActive; }

   void SetMultiThreadingActive(bool aMultiThreadingActive) { mMultiThreadingActive = aMultiThreadingActive; }

   bool IsEventStepSimulation() const { return mAmAnEventStepSimulation; }
 
   void SetAmAnEventStepSimulation(bool aFlag) { mAmAnEventStepSimulation = aFlag; }
 
   void SetClockSource(std::unique_ptr<WsfClockSource> aClockSourcePtr);

   const WsfClockSource* GetClockSource() const { return mClockSourcePtr.get(); }
 
   virtual double GetClockRate() const;
 
   virtual void SetClockRate(double aClockRate);
 
   virtual void
   SetTimeParameters(int aTimeScheme, double aSimTime, double aClockRate, double aTimeStep, bool aTimeAdvance = false);


   virtual bool AddPlatform(WsfPlatform* aPlatformPtr);
 
   virtual bool AddPlatform(double aSimTime, WsfPlatform* aPlatformPtr);
 
   // void AssignPlatformToSimulation(WsfPlatform* aPlatformPtr);
 
   // Remove the Platform from the Simulation and cleans up the memory if aDeleteMemory is true
   virtual void DeletePlatform(double aSimTime, WsfPlatform* aPlatformPtr, bool aDeleteMemory = true);
 
   WsfPlatform* GetPlatformByIndex(size_t aIndex) const;
 
   WsfPlatform* GetPlatformByName(WsfStringId aNameId) const;
 
   bool PlatformExists(size_t aIndex) const;
 
   WsfStringId GetPlatformNameId(size_t aIndex) const;
 
   WsfStringId GetPlatformTypeId(size_t aIndex) const;


   size_t GetPlatformCount() const;
 
   WsfPlatform* GetPlatformEntry(size_t aEntry) const;


   virtual bool TurnPartOff(double aSimTime, WsfPlatformPart* aPartPtr) { return TurnPartOffP(aSimTime, aPartPtr); }
 
   virtual bool TurnPartOn(double aSimTime, WsfPlatformPart* aPartPtr) { return TurnPartOnP(aSimTime, aPartPtr); }
 
   virtual bool SetPartOperational(double aSimTime, WsfPlatformPart* aPartPtr, bool aOperational = true)
   {
      return SetPartOperationalP(aSimTime, aPartPtr, aOperational);
   }
 
   virtual void SetPartUpdateInterval(double aSimTime, WsfPlatformPart* aPartPtr, double aUpdateInterval);


   virtual bool PlatformDeleted(double aSimTime, WsfPlatform* aOldPlatformPtr);
 
   virtual void ProcessRemovePlatformEvent(double aSimTime, WsfPlatform* aPlatformPtr, bool aDeletePlatform);
 
   virtual void ProcessPlatformBrokenEvent(double aSimTime, WsfPlatform* aPlatformPtr);



   virtual void SimulationStarting() { Start(); }
   virtual void SimulationComplete(double aSimTime) { Complete(aSimTime); }

   bool IsFlexibleRealtime() const { return mIsFlexibleRealtime; }
 
   void SetFlexibleRealtime() { mIsFlexibleRealtime = true; }


   WsfAdvancedBehaviorObserver&   GetAdvancedBehaviorObserver() const { return mAdvancedBehaviorObserver; }
   WsfBehaviorObserver&           GetBehaviorObserver() const { return mBehaviorObserver; }
   WsfCommObserver&               GetCommObserver() const { return mCommObserver; }
   WsfDisObserver&                GetDisObserver() const { return mDisObserver; }
   WsfExchangeObserver&           GetExchangeObserver() const { return mExchangeObserver; }
   WsfFuelObserver&               GetFuelObserver() const { return mFuelObserver; }
   WsfMoverObserver&              GetMoverObserver() const { return mMoverObserver; }
   WsfPlatformObserver&           GetPlatformObserver() const { return mPlatformObserver; }
   WsfPlatformPartObserver&       GetPlatformPartObserver() const { return mPlatformPartObserver; }
   WsfProcessorObserver&          GetProcessorObserver() const { return mProcessorObserver; }
   WsfScriptStateMachineObserver& GetScriptStateMachineObserver() const { return mScriptStateMachineObserver; }
   WsfSensorObserver&             GetSensorObserver() const { return mSensorObserver; }
   WsfSimulationObserver&         GetSimulationObserver() const { return mSimulationObserver; }
   WsfTaskObserver&               GetTaskObserver() const { return mTaskObserver; }
   WsfTrackObserver&              GetTrackObserver() const { return mTrackObserver; }
   WsfZoneObserver&               GetZoneObserver() const { return mZoneObserver; }


   WsfSimulationExtension* FindExtension(const std::string& aName) const;
   WsfSimulationExtension& GetExtension(const std::string& aName) const;
   const WsfExtensionList& GetExtensions() const { return mExtensionList; }
 
   void RegisterExtension(const std::string& aName, std::unique_ptr<WsfSimulationExtension> aExtensionPtr);
   const std::vector<std::string>& GetExtensionNames() const;
 
   unsigned int AssignUniqueId();
 
   ut::Random& GetRandom();
   ut::Random& LockRandom();
   void        UnlockRandom();
 
   ut::Random& GetScriptRandom();
   ut::Random& LockScriptRandom();
   void        UnlockScriptRandom();
 
   wsf::TerrainInterface*     GetTerrainInterface() const;
   WsfDateTime&               GetDateTime() { return mDateTime; }
   const WsfDateTime&         GetDateTime() const { return mDateTime; }
   WsfGroupManager&           GetGroupManager() { return mGroupManager; }
   wsf::comm::NetworkManager* GetCommNetworkManager() const { return mCommNetworkManagerPtr; }
   WsfMultiThreadManager&     GetMultiThreadManager() { return mMultiThreadManager; }
   WsfPathFinderList&         GetPathFinderList() const { return mPathFinderList; }
   WsfScriptContext&          GetScriptContext() { return mGlobalContext; }
   const WsfScriptContext&    GetScriptContext() const { return mGlobalContext; }
   WsfLOS_Manager*            GetLOS_Manager() const { return mLOS_ManagerPtr; }
   WsfZoneAttenuation&        GetZoneAttenuation() { return mZoneAttenuation; }
   WsfEM_Manager&             GetEM_Manager() { return mEM_Manager; }
   UtScriptExecutor&          GetScriptExecutor() { return mScriptExecutor; }
   UtAtmosphere&              GetAtmosphere() const;
   WsfEnvironment&            GetEnvironment() const;
   WsfSystemLog&              GetSystemLog() const;
   WsfIFF_Manager*            GetIFF_Manager() const;
 
   unsigned int NextMessageSerialNumber() { return ++mNextMessageSerialNumber; }
   unsigned int NextEngagementSerialNumber() { return ++mNextEngagementSerialNumber; }
   unsigned int PreviousEngagementSerialNumber() const { return mNextEngagementSerialNumber; }
   void         ReclaimPreviousEngagementSerialNumber() { --mNextEngagementSerialNumber; }
   double       CreateMessageDataTag();

   bool MultiThreaded() const { return mMultiThreaded; }

   unsigned int GetRunNumber() const { return mRunNumber; }
 
   unsigned int GetFinalRunNumber() const;
 
   bool RandomizeFrequency() const;
 
   bool   UseDefaultFrequency() const;
   double GetMinimumMoverTimestep() const { return mMinimumMoverTimestep; }
 
   const WsfSimulationInput& GetSimulationInput() const { return mSimulationInput; }
 
   std::string SubstituteOutputFileVariables(const std::string& aOutputFile);
 
protected:

   void AddToPlatformList(WsfPlatform* aPlatformPtr);
 
   bool DeleteFromPlatformList(WsfPlatform* aPlatformPtr);
 
   bool PlatformPointerExists(WsfPlatform* aPlatformPtr);
 
   void ResetPlatformList();

   bool AddInputPlatforms();
 
   virtual bool TurnPartOffP(double aSimTime, WsfPlatformPart* aPartPtr);
 
   virtual bool TurnPartOnP(double aSimTime, WsfPlatformPart* aPartPtr);
 
   virtual bool SetPartOperationalP(double aSimTime, WsfPlatformPart* aPartPtr, bool aOperational);
 
   virtual void DispatchWallEvents();
   virtual void DispatchSimEvents(double aSimTime);
   virtual void DispatchEvents(double aSimTime);
 
   virtual bool PlatformInitialized(double aSimTime, WsfPlatform* aNewPlatformPtr);
 
   virtual bool PlatformIntroduced(double aSimTime, WsfPlatform* aNewPlatformPtr);
 
 
   virtual bool SimulationInitialized();
 
   virtual void CreateClock();
 
   virtual bool PlatformIsAvailable(WsfPlatform* aPlatformPtr);

   WsfEM_Manager mEM_Manager;

   WsfEventManager mEventManager;

   WsfEventManager mWallEventManager;

   std::unique_ptr<WsfClockSource> mClockSourcePtr{nullptr};

   WsfRealTimeClockSource* mRealTimeClockSourcePtr{nullptr};

   double mSimTime{0.0};

   double mRealTime{false};

   double mTimeBehind{0.0};

   double mTimestep{0.0};

   double mSyncAccumulatedTime{0.0};

   volatile State mState{cPENDING_INITIALIZE};

   volatile CompletionReason mCompletionReason{cNONE};

   bool mExternalEventReady{false};

   unsigned int mRunNumber;
 
   const WsfSimulationInput& mSimulationInput;
 
   WsfDateTime mDateTime;
 
   bool mMultiThreaded;
 
   double mMinimumMoverTimestep;

   double mEndTime{std::numeric_limits<double>::max()};
 
   bool mIsRealTime{false};
 
private:
   void AssignDefaultName(WsfPlatform* aPlatformPtr);
 
   bool IntroducePlatform(double aSimTime, WsfPlatform* aNewPlatformPtr);
 
   void TurnOnSystems(double aSimTime, WsfPlatform* aPlatformPtr);
 
   void HandlePlatformInitializationFailure(WsfPlatform* aPlatformPtr);
 
   const WsfScenario& mScenario;

   std::vector<WsfStringId> mPlatformNameIds;

   std::vector<WsfStringId> mPlatformTypeIds;

   UtWallClock mWallClock;

   double mSyncTimestep{0.0};

   double mClockRate;
 
   double mNextMessageDataTag{1.0};
 
   unsigned int mNextMessageSerialNumber{0};
 
   unsigned int mNextEngagementSerialNumber{0};
 
   std::recursive_mutex mUniqueIdMutex;
   unsigned int         mUniqueId{0};

   ut::Random           mRandom;
   std::recursive_mutex mRandomMutex;

   ut::Random           mScriptRandom;
   std::recursive_mutex mScriptRandomMutex;

   bool mIsExternallyStarted{false};

   bool mMultiThreadingActive{false};

   bool mAmAnEventStepSimulation{true};

   bool mIsFlexibleRealtime{false};

   std::map<WsfStringId, int> mNextDefaultNameNumber;

   mutable WsfAdvancedBehaviorObserver   mAdvancedBehaviorObserver;
   mutable WsfBehaviorObserver           mBehaviorObserver;
   mutable WsfCommObserver               mCommObserver;
   mutable WsfDisObserver                mDisObserver;
   mutable WsfExchangeObserver           mExchangeObserver;
   mutable WsfFuelObserver               mFuelObserver;
   mutable WsfMoverObserver              mMoverObserver;
   mutable WsfPlatformObserver           mPlatformObserver;
   mutable WsfPlatformPartObserver       mPlatformPartObserver;
   mutable WsfProcessorObserver          mProcessorObserver;
   mutable WsfScriptStateMachineObserver mScriptStateMachineObserver;
   mutable WsfSensorObserver             mSensorObserver;
   mutable WsfSimulationObserver         mSimulationObserver;
   mutable WsfTaskObserver               mTaskObserver;
   mutable WsfTrackObserver              mTrackObserver;
   mutable WsfZoneObserver               mZoneObserver;
 
   wsf::comm::NetworkManager* mCommNetworkManagerPtr{nullptr};
   WsfGroupManager            mGroupManager;
   WsfLOS_Manager*            mLOS_ManagerPtr{nullptr};
   WsfMultiThreadManager      mMultiThreadManager;
   WsfPathFinderList&         mPathFinderList;
   WsfZoneAttenuation         mZoneAttenuation;
 
   UtScriptExecutor mScriptExecutor;

   WsfScriptContext mGlobalContext;

   std::vector<WsfPlatform*> mPlatforms;

   std::vector<WsfPlatform*> mPlatformsByIndex;

   std::map<WsfStringId, WsfPlatform*> mPlatformsByName;
 
   // Records the creation order of extensions
   WsfExtensionList mExtensionList;
};
 
// Helper macro for observer objects to implement their callback accessors
#define WSF_OBSERVER_CALLBACK_DEFINE(OBSERVER, EVENT)                                    \
   WsfObserver::EVENT##Callback& WsfObserver::EVENT(const WsfSimulation* aSimulationPtr) \
   {                                                                                     \
      return aSimulationPtr->Get##OBSERVER##Observer().EVENT;                            \
   }
 
#endif