WsfSimulationInput.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 WSFSIMULATIONINPUT_HPP
#define WSFSIMULATIONINPUT_HPP
 
#include "wsf_export.h"
 
#include <map>
#include <vector>
 
class UtInput;
class WsfDateTime;
class WsfPlatform;
class WsfScenario;
class WsfSimulation;
#include "WsfStringId.hpp"

class WSF_EXPORT WsfSimulationInput
{
public:
   friend class WsfSimulation;
   WsfSimulationInput(WsfScenario& aScenario);
   virtual ~WsfSimulationInput();
 
   virtual bool ProcessInput(UtInput& aInput);
 
   virtual void LoadComplete();

   double GetMinimumMoverTimestep() const { return mMinimumMoverTimestep; }
 

   bool MultiThreaded() const { return mMultiThreaded; }

   double GetEndTime() const { return mEndTime; }
 
   const WsfDateTime& GetDateTime() const { return *mDateTimePtr; }

   bool UseConstantRequiredPd() const { return mUseConstantRequiredPd; }

   void UseConstantRequiredPd(bool aUseConstantRequiredPd) { mUseConstantRequiredPd = aUseConstantRequiredPd; }


   bool RandomizeFrequency() const { return mRandomizeFrequency; }
   void RandomizeFrequency(bool aRandomizeFrequency);
 
   bool UseDefaultFrequency() const { return mUseDefaultFrequency; }
   void UseDefaultFrequency(bool aUseDefaultFrequency);

   void SetMultiThreaded(bool aMultiThreaded) { mMultiThreaded = aMultiThreaded; }

   void AllowClutterCalculationShortcuts(bool aAllowCalculationShortcuts)
   {
      mAllowClutterCalculationShortcuts = aAllowCalculationShortcuts;
   }

   bool AllowClutterCalculationShortcuts() const { return mAllowClutterCalculationShortcuts; }

   void AllowEM_PropagationCalculationShortcuts(bool aAllowCalculationShortcuts)
   {
      mAllowEM_PropagationCalculationShortcuts = aAllowCalculationShortcuts;
   }

   bool AllowEM_PropagationCalculationShortcuts() const { return mAllowEM_PropagationCalculationShortcuts; }
 
   WsfScenario* GetScenario() const { return mScenarioPtr; }

   enum ProcessPriority
   {
      cPP_BELOW_NORMAL,
      cPP_NORMAL,
      cPP_ABOVE_NORMAL,
      cPP_HIGH,
      cPP_REALTIME
   };

   void SetProcessPriority(ProcessPriority aProcessPriority) { mProcessPriority = aProcessPriority; }
 
protected:
   WsfScenario* mScenarioPtr;

   bool mIsRealTime;

   bool mMultiThreaded;

   int mWallClockTimingMethod;

   double mMinimumMoverTimestep;

   double mEndTime;

   double mClockRate;
 
   WsfDateTime* mDateTimePtr;

   bool mUseConstantRequiredPd;

   bool mRandomizeFrequency;

   bool mUseDefaultFrequency;
 
   int             mNumberOfThreads;
   double          mBreakUpdateTime;
   bool            mDebugMultiThreading;
   ProcessPriority mProcessPriority;

   bool mAllowClutterCalculationShortcuts;

   bool mAllowEM_PropagationCalculationShortcuts;
};

class WSF_EXPORT WsfEventStepSimulationInput
{
public:
   WsfEventStepSimulationInput();
   virtual ~WsfEventStepSimulationInput() {}
   bool ProcessInput(UtInput& aInput, WsfSimulationInput& aSimInput);
 
   double mThreadUpdateInterval;
   int    mPlatformThreadUpdateMultiplier;
   int    mSensorThreadUpdateMultiplier;
};

class WSF_EXPORT WsfFrameStepSimulationInput
{
public:
   WsfFrameStepSimulationInput();
   virtual ~WsfFrameStepSimulationInput() {}
   bool ProcessInput(UtInput& aInput, WsfSimulationInput& aSimInput);

   double mFrameTime;
};

class WsfDefaultSimulationInput : public WsfSimulationInput, public WsfEventStepSimulationInput, public WsfFrameStepSimulationInput
{
public:
   WsfDefaultSimulationInput(WsfScenario& aScenario);
   ~WsfDefaultSimulationInput() override;
   bool ProcessInput(UtInput& aInput) override;
};
 
#endif