JSBsim/FGAircraft.h

   1 /*******************************************************************************
   2
   3  Header:       FGAircraft.h
   4  Author:       Jon S. Berndt
   5  Date started: 12/12/98
   6
   7  ------------- Copyright (C) 1999  Jon S. Berndt (jsb@hal-pc.org) -------------
   8
   9  This program is free software; you can redistribute it and/or modify it under
  10  the terms of the GNU General Public License as published by the Free Software
  11  Foundation; either version 2 of the License, or (at your option) any later
  12  version.
  13
  14  This program is distributed in the hope that it will be useful, but WITHOUT
  15  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  16  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  17  details.
  18
  19  You should have received a copy of the GNU General Public License along with
  20  this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  21  Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23  Further information about the GNU General Public License can also be found on
  24  the world wide web at http://www.gnu.org.
  25
  26 HISTORY
  27 --------------------------------------------------------------------------------
  28 12/12/98   JSB   Created
  29
  30 ********************************************************************************
  31 SENTRY
  32 *******************************************************************************/
  33
  34 #ifndef FGAIRCRAFT_H
  35 #define FGAIRCRAFT_H
  36
  37 /*******************************************************************************
  38 COMMENTS, REFERENCES,  and NOTES
  39 *******************************************************************************/
  40 /**
  41 The aerodynamic coefficients used in this model typically are:
  42 <PRE>
  43 <b>Longitudinal</b>
  44   CL0 - Reference lift at zero alpha
  45   CD0 - Reference drag at zero alpha
  46   CDM - Drag due to Mach
  47   CLa - Lift curve slope (w.r.t. alpha)
  48   CDa - Drag curve slope (w.r.t. alpha)
  49   CLq - Lift due to pitch rate
  50   CLM - Lift due to Mach
  51   CLadt - Lift due to alpha rate
  52
  53   Cmadt - Pitching Moment due to alpha rate
  54   Cm0 - Reference Pitching moment at zero alpha
  55   Cma - Pitching moment slope (w.r.t. alpha)
  56   Cmq - Pitch damping (pitch moment due to pitch rate)
  57   CmM - Pitch Moment due to Mach
  58
  59 <b>Lateral</b>
  60   Cyb - Side force due to sideslip
  61   Cyr - Side force due to yaw rate
  62
  63   Clb - Dihedral effect (roll moment due to sideslip)
  64   Clp - Roll damping (roll moment due to roll rate)
  65   Clr - Roll moment due to yaw rate
  66   Cnb - Weathercocking stability (yaw moment due to sideslip)
  67   Cnp - Rudder adverse yaw (yaw moment due to roll rate)
  68   Cnr - Yaw damping (yaw moment due to yaw rate)
  69
  70 <b>Control</b>
  71   CLDe - Lift due to elevator
  72   CDDe - Drag due to elevator
  73   CyDr - Side force due to rudder
  74   CyDa - Side force due to aileron
  75
  76   CmDe - Pitch moment due to elevator
  77   ClDa - Roll moment due to aileron
  78   ClDr - Roll moment due to rudder
  79   CnDr - Yaw moment due to rudder
  80   CnDa - Yaw moment due to aileron
  81 </PRE>
  82 This class expects to be run in a directory which contains the subdirectory
  83 structure shown below (where example aircraft X-15 is shown):
  84
  85 <PRE>
  86 aircraft/
  87   X-15/
  88     X-15.dat reset00 reset01 reset02 ...
  89       CDRAG/
  90         a0 a M De
  91       CSIDE/
  92         b r Dr Da
  93       CLIFT/
  94         a0 a M adt De
  95       CROLL/
  96         b p r Da Dr
  97       CPITCH/
  98         a0 a adt q M De
  99       CYAW/
 100         b p r Dr Da
 101   F-16/
 102     F-16.dat reset00 reset01 ...
 103       CDRAG/
 104         a0 a M De
 105       ...
 106 </PRE>
 107
 108 The General Idea
 109
 110 The file structure is arranged so that various modeled aircraft are stored in
 111 their own subdirectory. Each aircraft subdirectory is named after the aircraft.
 112 There should be a file present in the specific aircraft subdirectory (e.g.
 113 aircraft/X-15) with the same name as the directory with a .dat appended. This
 114 file contains mass properties information, name of aircraft, etc. for the
 115 aircraft. In that same directory are reset files numbered starting from 0 (two
 116 digit numbers), e.g. reset03. Within each reset file are values for important
 117 state variables for specific flight conditions (altitude, airspeed, etc.). Also
 118 within this directory are the directories containing lookup tables for the
 119 stability derivatives for the aircraft.
 120 @author Jon S. Berndt
 121 @memo  Encompasses all aircraft functionality and objects
 122 @see <ll>
 123 <li>[1] Cooke, Zyda, Pratt, and McGhee, "NPSNET: Flight Simulation Dynamic Modeling
 124          Using Quaternions", Presence, Vol. 1, No. 4, pp. 404-420  Naval Postgraduate
 125          School, January 1994</li>
 126 <li>[2] D. M. Henderson, "Euler Angles, Quaternions, and Transformation Matrices",
 127          JSC 12960, July 1977</li>
 128 <li>[3] Richard E. McFarland, "A Standard Kinematic Model for Flight Simulation at
 129          NASA-Ames", NASA CR-2497, January 1975</li>
 130 <li>[4] Barnes W. McCormick, "Aerodynamics, Aeronautics, and Flight Mechanics",
 131          Wiley & Sons, 1979 ISBN 0-471-03032-5</li>
 132 <li>[5] Bernard Etkin, "Dynamics of Flight, Stability and Control", Wiley & Sons,
 133          1982 ISBN 0-471-08936-2</li>
 134 </ll>
 135 */
 136
 137 /*******************************************************************************
 138 INCLUDES
 139 *******************************************************************************/
 140
 141 #ifdef FGFS
 142 #  include <Include/compiler.h>
 143 #  ifdef FG_HAVE_STD_INCLUDES
 144 #    include <fstream>
 145 #  else
 146 #    include <fstream.h>
 147 #  endif
 148 #else
 149 #  include <fstream>
 150 #endif
 151
 152 #include "FGModel.h"
 153 #include "FGCoefficient.h"
 154 #include "FGEngine.h"
 155 #include "FGTank.h"
 156
 157 /*******************************************************************************
 158 DEFINITIONS
 159 *******************************************************************************/
 160
 161 /*******************************************************************************
 162 CLASS DECLARATION
 163 *******************************************************************************/
 164
 165 class FGAircraft : public FGModel
 166 {
 167 public:
 168   // ***************************************************************************
 169   /** @memo Constructor
 170       @param FGFDMExec* - a pointer to the "owning" FDM Executive
 171   */
 172   FGAircraft(FGFDMExec*);
 173
 174   // ***************************************************************************
 175   /** Destructor */
 176   ~FGAircraft(void);
 177
 178   // ***************************************************************************
 179   /** This must be called for each dt to execute the model algorithm */
 180   bool Run(void);
 181
 182   // ***************************************************************************
 183   /** This function must be called with the name of an aircraft which
 184       has an associated .dat file in the appropriate subdirectory. The paths
 185       to the appropriate subdirectories are given as the first two parameters.
 186       @memo Loads the given aircraft.
 187       @param string Path to the aircraft files
 188       @param string Path to the engine files
 189       @param string The name of the aircraft to be loaded, e.g. "X15".
 190       @return True - if successful
 191   */
 192   bool LoadAircraft(string, string, string);
 193
 194   // ***************************************************************************
 195   /** @memo Gets the aircraft name as defined in the aircraft config file.
 196       @param
 197       @return string Aircraft name.
 198   */
 199   inline string GetAircraftName(void) {return AircraftName;}
 200
 201   // ***************************************************************************
 202   /** @memo Sets the GearUp flag
 203       @param boolean true or false
 204       @return
 205   */
 206   inline void SetGearUp(bool tt) {GearUp = tt;}
 207
 208   // ***************************************************************************
 209   /** @memo Returns the state of the GearUp flag
 210       @param
 211       @return boolean true or false
 212   */
 213   inline bool GetGearUp(void) {return GearUp;}
 214
 215   // ***************************************************************************
 216   /** @memo Returns the area of the wing
 217       @param
 218       @return float wing area S, in square feet
 219   */
 220   inline float GetWingArea(void) {return WingArea;}
 221
 222   // ***************************************************************************
 223   /** @memo Returns the wing span
 224       @param
 225       @return float wing span in feet
 226   */
 227   inline float GetWingSpan(void) {return WingSpan;}
 228
 229   // ***************************************************************************
 230   /** @memo Returns the average wing chord
 231       @param
 232       @return float wing chord in feet
 233   */
 234   inline float Getcbar(void) {return cbar;}
 235
 236   // ***************************************************************************
 237   /** @memo Returns an engine object
 238       @param int The engine number
 239       @return FGEengine* The pointer to the requested engine object.
 240   */
 241   inline FGEngine* GetEngine(int tt) {return Engine[tt];}
 242
 243   // ***************************************************************************
 244   /** @memo
 245       @param
 246       @return
 247   */
 248   inline FGTank* GetTank(int tt) {return Tank[tt];}
 249
 250   // ***************************************************************************
 251   /** @memo
 252       @param
 253       @return
 254   */
 255   inline float GetWeight(void) {return Weight;}
 256
 257   // ***************************************************************************
 258   /** @memo
 259       @param
 260       @return
 261   */
 262   inline float GetMass(void) {return Mass;}
 263
 264   // ***************************************************************************
 265   /** @memo
 266       @param
 267       @return
 268   */
 269   inline float GetL(void) {return Moments[0];}
 270
 271   // ***************************************************************************
 272   /** @memo
 273       @param
 274       @return
 275   */
 276   inline float GetM(void) {return Moments[1];}
 277
 278   // ***************************************************************************
 279   /** @memo
 280       @param
 281       @return
 282   */
 283   inline float GetN(void) {return Moments[2];}
 284
 285   // ***************************************************************************
 286   /** @memo
 287       @param
 288       @return
 289   */
 290   inline float GetFx(void) {return Forces[0];}
 291
 292   // ***************************************************************************
 293   /** @memo
 294       @param
 295       @return
 296   */
 297   inline float GetFy(void) {return Forces[1];}
 298
 299   // ***************************************************************************
 300   /** @memo
 301       @param
 302       @return
 303   */
 304   inline float GetFz(void) {return Forces[2];}
 305
 306   // ***************************************************************************
 307   /** @memo
 308       @param
 309       @return
 310   */
 311   inline float GetIxx(void) {return Ixx;}
 312
 313   // ***************************************************************************
 314   /** @memo
 315       @param
 316       @return
 317   */
 318   inline float GetIyy(void) {return Iyy;}
 319
 320   // ***************************************************************************
 321   /** @memo
 322       @param
 323       @return
 324   */
 325   inline float GetIzz(void) {return Izz;}
 326
 327   // ***************************************************************************
 328   /** @memo
 329       @param
 330       @return
 331   */
 332   inline float GetIxz(void) {return Ixz;}
 333
 334 private:
 335   // ***************************************************************************
 336   /** @memo
 337       @param
 338       @return
 339   */
 340   void GetState(void);
 341
 342   // ***************************************************************************
 343   /** @memo
 344       @param
 345       @return
 346   */
 347   void PutState(void);
 348
 349   // ***************************************************************************
 350   /** @memo
 351       @param
 352       @return
 353   */
 354   void FAero(void);
 355
 356   // ***************************************************************************
 357   /** @memo
 358       @param
 359       @return
 360   */
 361   void FGear(void);
 362
 363   // ***************************************************************************
 364   /** @memo
 365       @param
 366       @return
 367   */
 368   void FMass(void);
 369
 370   // ***************************************************************************
 371   /** @memo
 372       @param
 373       @return
 374   */
 375   void FProp(void);
 376
 377   // ***************************************************************************
 378   /** @memo
 379       @param
 380       @return
 381   */
 382   void MAero(void);
 383
 384   // ***************************************************************************
 385   /** @memo
 386       @param
 387       @return
 388   */
 389   void MGear(void);
 390
 391   // ***************************************************************************
 392   /** @memo
 393       @param
 394       @return
 395   */
 396   void MMass(void);
 397
 398   // ***************************************************************************
 399   /** @memo
 400       @param
 401       @return
 402   */
 403   void MProp(void);
 404
 405   // ***************************************************************************
 406   /** @memo
 407       @param
 408       @return
 409   */
 410   void MassChange(void);
 411
 412   // ***************************************************************************
 413   /** @memo
 414       @param
 415       @return
 416   */
 417   float Moments[3];
 418
 419   // ***************************************************************************
 420   /** @memo
 421       @param
 422       @return
 423   */
 424   float Forces[3];
 425
 426   // ***************************************************************************
 427   /** @memo
 428       @param
 429       @return
 430   */
 431   string AircraftName;
 432
 433   // ***************************************************************************
 434   ///
 435   float Ixx, Iyy, Izz, Ixz, EmptyMass, Mass;
 436   ///
 437   float Xcg, Ycg, Zcg;
 438   ///
 439   float Xep, Yep, Zep;
 440   ///
 441   float rho, qbar, Vt;
 442   ///
 443   float alpha, beta;
 444   ///
 445   float WingArea, WingSpan, cbar;
 446   ///
 447   float phi, tht, psi;
 448   ///
 449   float Weight, EmptyWeight;
 450   ///
 451   float dt;
 452
 453   ///
 454   int numTanks;
 455   ///
 456   int numEngines;
 457   ///
 458   int numSelectedOxiTanks;
 459   ///
 460   int numSelectedFuelTanks;
 461   ///
 462   FGTank* Tank[MAX_TANKS];
 463   ///
 464   FGEngine *Engine[MAX_ENGINES];
 465
 466   ///
 467   FGCoefficient *Coeff[6][10];
 468   ///
 469   int coeff_ctr[6];
 470
 471   ///
 472   bool GearUp;
 473
 474   ///
 475   enum Param {LiftCoeff,
 476               DragCoeff,
 477               SideCoeff,
 478               RollCoeff,
 479               PitchCoeff,
 480               YawCoeff,
 481               numCoeffs};
 482
 483   ///
 484   string Axis[6];
 485
 486 protected:
 487
 488 };
 489
 490 /******************************************************************************/
 491 #endif