WsfTBM_Mover.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 WSFTBM_MOVER_HPP
#define WSFTBM_MOVER_HPP
 
#include "wsf_mil_export.h"
 
#include <vector>
 
#include "TblLookup.hpp"
#include "UtLog.hpp"
#include "UtRandom.hpp"
#include "WsfMover.hpp"

 
class WSF_MIL_EXPORT WsfTBM_Mover : public WsfMover
{
public:
   WsfTBM_Mover(WsfScenario& aScenario);
   ~WsfTBM_Mover() override = default;
   WsfTBM_Mover& operator=(const WsfTBM_Mover&) = delete;
 
   WsfMover* Clone() const override;
   bool      Initialize(double aSimTime) override;
   bool      Initialize2(double aSimTime) override;
   bool      ProcessInput(UtInput& aInput) override;
   void      Update(double aSimTime) override;
 
   static ut::Random& GetRandom();
   static void        ClearRandom();
 
   WsfSpatialDomain GetSpatialDomain() const override { return WSF_SPATIAL_DOMAIN_AIR; }
 
   double GetTBMLastUpdateTime() const { return WsfTBM_Mover::mLastUpdateTime; }
   void   SetTBMLastUpdateTime(double aLastUpdateTime) { WsfTBM_Mover::mLastUpdateTime = aLastUpdateTime; }
 
   void GetLaunchLLA(double& aLat, double& aLon, double& aAlt, bool& aAltAGL);
   void SetLaunchLLA(double aLat, double aLon, double aAlt, bool aAltAGL);
 
   double GetLaunchTime() const { return mLaunchTime; }
   void   SetLaunchTime(double aLaunchTime) { mLaunchTime = aLaunchTime; }
 
   unsigned int GetStageIndex() const { return mStageIndex; }
   void         SetStageIndex(unsigned int aStageIndex);
   bool         IsExtrapolating() const override { return mIsBallistic; }

   std::vector<double> GetState() const;
   void                SetState(const std::vector<double>& aStateVector);
 
   void GetTerminalLLA(double& aLat, double& aLon, double& aAlt);
   void GetTargetLLA(double& aLat, double& aLon, double& aAlt);
   void SetTargetLLA(double aLat, double aLon, double aAlt);

   class Stage
   {
   public:
      Stage();
 
      bool Initialize(double aStageStartTime);
      bool Initialize2();
      bool ProcessInput(UtInput& aInput);

      double RemainingInitialMass() const { return mEmptyMass + mFuelMass + mPayloadMass; }

      double RemainingBurnoutMass() const { return mEmptyMass + mPayloadMass; }
 
      //@(

      double mBallisticCoeff; 

      double mEmptyMass;

      double mFuelMass;

      double mFuelMassFraction;

      double mTotalMass;

      double mThrust;

      double mSpecificImpulse;

      double mThrustDuration;

      double mPreIgnitionCoastTime;

      double mPreSeparationCoastTime;

      double mCd0;

      double mReferenceArea;




      double mWdot;
 
      double mPayloadMass;

      double mS_Cd0;

      double mInitialTime;
      double mInitialState[9];

      double mIgnitionTime;
      double mIgnitionState[9];

      double mBurnOutTime;
      double mBurnOutState[9];

      double mSeparationTime;

   };
 
protected:
   WsfTBM_Mover(const WsfTBM_Mover& aSrc);
 
   bool ProcessCepTable(UtInput& aInput);
 
   bool SaveCepPoint(bool&                aFormatIsFrozen,
                     std::vector<double>& aNominalRanges,
                     std::vector<double>& aRangeErrors,
                     std::vector<double>& aAzimuthErrors,
                     double               aNominalRange,
                     double               aRangeError,
                     double               aAzimuthError);
 
   void ComputeTargetError();
   void SetMasses();
 
   void ComputeImpactRange(double psi, double& rangegr, double& xmid, double& aMaxAlt);
 
   void ComputeTransitionStateVectors(const double aInitialState[9]);
 
   void CreateInitialState(double aElevation, double aState[9]);
 
   void ComputeLaunchAngle(double fltran, double psicrit, double rngmax, double& flttim, double& psi, double& maxAlt, bool& toofar);
 
   void ComputeMaximumRange(double al, double am, double ah, double tol, double& psicrit, double& rngmax);
 
   double GetAltitude(const double aState[9]) const;
 
   double GetSpeed(const double aState[9]) const;
 
   void CepTableLookup(double aTargetGroundRange, double& aRangeError, double& aAzimuthError);
 
   void PrintState(const double aState[9], ut::log::MessageStream& aStream) const;
 
   void ScheduleScriptEvents(double aSimTime);
 
   void SetTrailingEffects(double aSimTime) const;
 
   void WriteStateForPlot(double aTime, const double aState[9]);
 
   void odeint2(double y[9], double x1, double x2);
 
   void derivs(double x, const double y[9], double dydx[6]) const;
 
   void rkqc(double y[9], double dydx[6], double& x, double htry, double eps, double yscal[], double& hdid, double& hnext);
 
   void rk4(double y[9], double dydx[6], double x, double h, double yout[9]);

   void OutputDiagnostic(double aSimTime);
 
   double       mLaunchTime; 
   Stage        mStage;      
   unsigned int mStageIndex; 
   double       mState[9];   
 
   std::vector<Stage> mStageList;         
   bool               mExplicitStageUsed; 
   bool               mImplicitStageUsed; 
 
   bool   mAzErrorUsed;
   bool   mHaveTarget;
   bool   mIsBallistic;
   double mFixedCEP; 
 
   // The launcher position (derived from either the platform or the input file)
 
   double mLaunchLat;    
   double mLaunchLon;    
   double mLaunchAlt;    
   bool   mLaunchAltAGL; 
 
   // Scenario launch conditions
 
   bool mIgnoreTarget; 
   bool mLofted;       
 
   double mTargetLat; 
   double mTargetLon; 
   double mTargetAlt; 
 
   double mTerminalLat; 
   double mTerminalLon; 
   double mTerminalAlt; 
 
   bool mShowStatus; 
 
   int mDebugCallTrigger;
   int mDebugCallCount;
 
   TblIndVarU<double>  mNomRanges;     //<! Nominal Downrange independent values
   TblDepVar1<double>  mRangeErrors;   //<! Range Error values at different nominal ranges
   TblDepVar1<double>  mAzimuthErrors; //<! Azimuth Error values at different nominal ranges
   TblLookupLU<double> mLookupUtility; //<! Table Lookup utility.
 
   // PROGRAMMER's NOTE:  TODO --
   // This implementation does not yet use WsfPlatform values for mass accounting purposes.
};
 
#endif