P6DofAeroMovableObject.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 P6DOFAEROMOVABLEOBJECT_H
#define P6DOFAEROMOVABLEOBJECT_H
 
#include <string>
 
#include "UtCloneablePtr.hpp"
#include "UtTable.hpp"
 
class UtInput;
class UtVec3dX;
 
// The P6DofAeroMovableObject provides supplemental aerodynamics for an object,
// beyond the 'core' aerodynamics of P6DofAeroCoreObject. It is used for
// aerodynamics for components, landing gear, flaps, speed brakes, etc.
 
class P6DofAeroMovableObject
{
public:
   P6DofAeroMovableObject()  = default;
   ~P6DofAeroMovableObject() = default;
 
   P6DofAeroMovableObject& operator=(const P6DofAeroMovableObject& other) = delete;
 
   P6DofAeroMovableObject* Clone() const;
 
   // The SetExtendedValue function determines the extended amount of the item (0.0-1.0)
   void SetExtendedValue(double aExtendedValue);
 
   // The SetAngle_deg function determines the angle the item (typically, retracted = 0.0)
   void SetAngle_deg(double aAngle_deg);
 
   // ProcessInput reads initialization data
   bool ProcessInput(UtInput& aInput);
   bool Initialize();
 
   // This sets the handle for the control surface (or other aero part)
   void SetControlSurfaceHandle(size_t aHandle);
 
   // This gets the handle for the control surface (or other aero part)
   size_t GetControlSurfaceHandle() const;
 
   // Returns the name string
   std::string GetName() const;
 
   // Either SetReferenceArea or SetReferenceAreas should be called during initialization
   void SetReferenceArea(double aRefArea_sqft);
 
   // Either SetReferenceArea or SetReferenceAreas should be called during initialization
   void SetReferenceAreas(double aWingChord_ft, double aWingSpan_ft, double aWingArea_sqft);
 
   // The CalculateMovableAeroFM function is called to calculate the aerodynamic
   // forces and moments. The aLiftFactor is used for spoilers, which have the
   // potential to spoil lift for the entire vehicle.
   void CalculateMovableAeroFM(double          aDynPress_lbsqft,
                               double          aMach,
                               double          aSpeed_fps,
                               double          aAlpha_rad,
                               double          aBeta_rad,
                               const UtVec3dX& aAngularRates_rps,
                               UtVec3dX&       aMoment_ftlbs,
                               double&         aLift_lbs,
                               double&         aDrag_lbs,
                               double&         aSideForce_lbs,
                               double&         aLiftFactor,
                               double          aAngle_deg);
 
   // This calculates the pitching moment (Cm) including reference area effects
   // but not including dynamic pressure effects.
   double CalculateMovableAeroCmArea(double aMach, double aAlpha_rad, double aAngle_deg) const;
 
   // This calculates the lift coefficient (CL) including reference area effects
   // but not including dynamic pressure effects.
   double CalculateMovableAeroCLArea(double aMach, double aAlpha_rad, double aAngle_deg) const;
 
   // This calculates the lift coefficient (CL) without considering reference
   // area effects.
   double CalculateMovableAeroCL(double aMach, double aAlpha_rad, double aAngle_deg) const;
 
   // This calculates the drag coefficient (Cd) including reference area effects
   // but not including dynamic pressure effects.
   double CalculateMovableAeroCdArea(double aMach, double aAlpha_rad, double aAngle_deg) const;
 
   // This is deprecated. This is currently use to allow "legacy" stability derivatives.
   // However, it may be removed (along with legacy stability derivatives in later versions.
   bool UseLegacyAero() const { return mUseLegacy; }
 
protected:
   P6DofAeroMovableObject(const P6DofAeroMovableObject& aSrc) = default;
 
   // Lift
   double CL_AngleAlphaMach(double aMach, double aAlpha_rad, double aAngle_deg) const;
   double CLFactor_AngleMach(double aMach, double aAngle_deg) const; 
 
   // Drag
   double Cd_AngleAlphaMach(double aMach, double aAlpha_rad, double aAngle_deg) const; // This should be used when drag
                                                                                       // is only a function of alpha
   double Cd_AngleBetaMach(double aMach, double aBeta_rad, double aAngle_deg) const; // This should be used when drag is
                                                                                     // only a function of beta
   double Cd_AngleMach(double aMach,
                       double aAngle_deg) const; // This should be used when drag is a function of alpha and beta
 
   // Side force
   double CY_AngleBetaMach(double aMach, double aBeta_rad, double aAngle_deg) const;
 
   // Pitching moments
   double Cm_AngleAlphaMach(double aMach, double aAlpha_rad, double aAngle_deg) const;
   double Cmq_AngleMach(double aMach, double aAngle_deg) const;
 
   // Yawing moments
   double Cn_AngleBetaMach(double aMach, double aBeta_rad, double aAngle_deg) const;
   double Cnr_AngleMach(double aMach, double aAngle_deg) const;
 
   // Rolling moments
   double Cl_AngleMach(double aMach, double aAngle_deg) const; 
   double Cl_AngleAlphaBeta(double aAlpha_rad, double aBeta_rad, double aAngle_deg) const;
   double Clp_AngleMach(double aMach, double aAngle_deg) const;
   double Clq_AngleMach(double aMach, double aAngle_deg) const;
   double Clr_AngleMach(double aMach, double aAngle_deg) const;
 
   std::string mName;
 
   bool   mUseExternalRefArea   = false;
   bool   mUseInternalRefArea   = false;
   double mRefExternalArea_sqft = 0.0;
   double mRefInternalArea_sqft = 0.0;
   double mRefWingChord_ft      = 0.0;
   double mRefWingSpan_ft       = 0.0;
   double mRefWingArea_sqft     = 0.0;
   double mExtendedValue        = 0.0;
   double mAngle_deg            = 0.0;
 
   size_t mControlSurfaceHandle = 0;
 
   // This "legacy" flag allows the use of older aero stability derivatives, which are deprecated and should no longer be used
   bool mUseLegacy = false; 
 
   // This "reduced frequency" flag allows the use of reduced frequency rather than angular rates to compute aerodynamic derivatives
   bool mUseReducedFrequency = true;
 
   // Lift
   UtCloneablePtr<UtTable::Table> mCL_AngleAlphaMachTablePtr{nullptr};
   UtCloneablePtr<UtTable::Table> mCLFactor_AngleMachTablePtr{nullptr}; 
 
   // Drag - Only one of these should be used
   UtCloneablePtr<UtTable::Table> mCd_AngleAlphaMachTablePtr{
      nullptr}; // This should be used when drag is only a function of alpha
   UtCloneablePtr<UtTable::Table> mCd_AngleBetaMachTablePtr{
      nullptr}; // This should be used when drag is only a function of beta
   UtCloneablePtr<UtTable::Table> mCd_AngleMachTablePtr{
      nullptr}; // This should be used when drag is a function of alpha and beta
 
   // Side force
   UtCloneablePtr<UtTable::Table> mCY_AngleBetaMachTablePtr{nullptr};
 
   // Pitching moments
   UtCloneablePtr<UtTable::Table> mCm_AngleAlphaMachTablePtr{nullptr};
   UtCloneablePtr<UtTable::Table> mCmq_AngleMachTablePtr{nullptr};
 
   // Yawing moments
   UtCloneablePtr<UtTable::Table> mCn_AngleBetaMachTablePtr{nullptr};
   UtCloneablePtr<UtTable::Table> mCnr_AngleMachTablePtr{nullptr};
 
   // Rolling moments
   UtCloneablePtr<UtTable::Table> mCl_AngleMachTablePtr{nullptr}; 
   UtCloneablePtr<UtTable::Table> mCl_AngleAlphaBetaTablePtr{
      nullptr}; // This replaces the Mach-based version, instead using alpha/beta
   UtCloneablePtr<UtTable::Table> mClp_AngleMachTablePtr{nullptr};
   UtCloneablePtr<UtTable::Table> mClq_AngleMachTablePtr{nullptr};
   UtCloneablePtr<UtTable::Table> mClr_AngleMachTablePtr{nullptr};
};
 
#endif