WsfGuidedMoverBase.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.
// ****************************************************************************
// ****************************************************************************
// Updated by Infoscitex, a DCS Company
// ****************************************************************************
 
#ifndef WSFGUIDEDMOVERBASE_HPP
#define WSFGUIDEDMOVERBASE_HPP
 
#include "wsf_mil_export.h"
 
#include <fstream>
 
#include "UtAtmosphere.hpp"
#include "UtCallback.hpp"
#include "UtEntity.hpp"
class UtInput;
#include "UtLog.hpp"
#include "WsfMover.hpp"
class WsfMoverGuidance;
class WsfProcessor;
#include "WsfRoute.hpp"
class WsfWeapon;

 
class WSF_MIL_EXPORT WsfGuidedMoverBase : public WsfMover
{
public:
   WsfGuidedMoverBase(WsfScenario& aScenario);
   ~WsfGuidedMoverBase() override;
   WsfGuidedMoverBase& operator=(const WsfGuidedMoverBase&) = delete;


   bool Initialize(double aSimTime) override;
   bool Initialize2(double aSimTime) override;
   bool ProcessInput(UtInput& aInput) override;
   void Update(double aSimTime) override;


   void PartBroken(double aSimTime) override;


   WsfSpatialDomain GetSpatialDomain() const override { return WSF_SPATIAL_DOMAIN_AIR; }
 
   const WsfRoute* GetRoute() const override;
 
   // IsExtrapolating is used to signify that boost phase is complete.
   bool IsExtrapolating() const override { return mBoostComplete; }
 
   bool IsPaused() const override { return mFMM_Time < 0.0; }
 
   bool IsStopped() const override { return mFMM_Time < 0.0; }
 
   bool SetRoute(double aSimTime, const WsfRoute& aRoute) override;
 
   bool UpdateRoute(double aSimTime, const WsfRoute& aRoute) override;

   virtual void SetGuidance(WsfMoverGuidance* aGuidancePtr) { mGuidancePtr = aGuidancePtr; }

   virtual WsfMoverGuidance* GetGuidance() const { return mGuidancePtr; }



   virtual void SetYandZForces(double aYForce, double aZForce)
   {
      mYForce = aYForce;
      mZForce = aZForce;
   }

   virtual void SetCommandedYawRate(double aRate) { mCommandedYawRate = aRate; }

   virtual void SetCommandedPitchRate(double aRate) { mCommandedPitchRate = aRate; }

   virtual void SetCommandedRollRate(double aRate) { mCommandedRollRate = aRate; }

   virtual void SetCommandedSpeed(double aCommandedSpeed) { mCommandedSpeed = aCommandedSpeed; }

   virtual void SetCommandedThrottle(double aCommandedThrottle) { mCommandedThrottle = aCommandedThrottle; }

   virtual void SetCommandedEngineStopTime(double aStopTime) { mCommandedEngineStopTime = aStopTime; }

   virtual void SetMinimumHeightAboveTerrain(double aMinimum) { mMinimumHeightAboveTerrain = aMinimum; }

   virtual size_t CurrentStage() const { return mStageIndex; }
 
   virtual void EjectStage(double aSimTime, double aPreSeparationCoastTime, double aPreIgnitionCoastTime);


   UtCallbackListN<void(double)>         RouteChanged;
   UtCallbackListN<void(double, double)> StageIgnition;
   UtCallbackListN<void(double, double)> StageBurnout;
   UtCallbackListN<void(double, double)> StageSeparation;
 
   void WriteKinematicStatus(ut::log::MessageStream& aStream);
 
protected:
   enum Phase
   {
      cPHASE_PRE_BURN,  //<! Coasting, after separation of previous stage, before starting engine
      cPHASE_BURN,      //<! Engine running
      cPHASE_POST_BURN, //<! Coasting after expenditure of fuel, before stage separation.
      cPHASE_FAIL       //<! Coasting after a failure (ignition, staging, etc.)
   };
 
   // Declare default copy constructor (for Clone())
   WsfGuidedMoverBase(const WsfGuidedMoverBase& aSrc);

   virtual void AdvanceTime(double aSimTime, double aBegTime, double& aEndTime, Phase& aNextPhase) = 0;
 
   void CallStagingEventScript(double aSimTime, const std::string& aScriptName);
 
   virtual void InitiateMotion(double aSimTime, double aCurTime);
 
   virtual bool SeparateStage(double aSimTime, size_t aStageIndex);
 
   virtual bool IgniteStage(double aSimTime, size_t aStageIndex);
 
   virtual void InitiateStage(double aSimTime, double aCurTime, size_t aStageIndex);
 
   virtual void PostUpdate(double aSimTime);
 
   void PrelaunchAdvanceTime(double aSimTime, double aCurTime);
 
   void PrelaunchComplete(double aSimTime, double aCurTime);
 
   void SetInitialState(double aSimTime, double aCurTime, bool aInitiatingMotion);
 
   virtual void WriteStagingMessage(ut::log::MessageStream& aStream,
                                    double                  aSimTime,
                                    double                  aCurTime,
                                    const std::string&      aStatus,
                                    size_t                  aStageIndex);
 
   virtual void WriteTrajectoryOutput(double aSimTime, double aCurTime, const double aECS_Forces[3]);

   double mLaunchTime;

   UtEntity mExternalState;

   double mLastAdvanceTime;

   double mIntegrationTimestep;
 
   size_t mStageIndex; 

   size_t mBoostCompleteStageIndex;

   bool mBoostComplete;
 
   WsfRoute mRoute; 


   Phase mPhase;
   double mPhaseStartTime;
   double mPreIgnitionCoastTime;
   double mPreSeparationCoastTime;

   double mLaunchComputerBurnTime;
 
   WsfMoverGuidance* mGuidancePtr;
   double            mYForce;
   double            mZForce;
   double            mCommandedRollRate;
   double            mCommandedPitchRate;
   double            mCommandedYawRate;
   double            mCommandedSpeed;
   double            mCommandedThrottle;

   double mCommandedEngineStopTime;

   double mCommandedPreSeparationCoastTime;
   double mCommandedPreIgnitionCoastTime;

   double mMinimumHeightAboveTerrain;
 
   bool mShowStatus; 
   bool mShowTrajectory;
   bool mMatchOwningPlatHeading;
   bool mCheckForGroundImpact;
 
   UtAtmosphere mAtmosphere;
   double       mSeaLevelPressure;


   double mFMM_Time;
   double mFMM_LocWCS[3];
   double mFMM_Heading;
 
   std::string   mTimeHistoryPath;
   std::ofstream mTimeHistoryOfs;

   size_t     mLaunchPlatformIndex;
   WsfWeapon* mLaunchWeaponPtr;
 
private:
   void AdvanceTimeInternal(double aSimTime, double aBegTime, double& aEndTime);
};
 
#endif