src/FDM/JSBSim/FGInitialCondition.h

   1 /*******************************************************************************
   2
   3  Header:       FGInitialCondition.h
   4  Author:       Tony Peden
   5  Date started: 7/1/99
   6
   7  ------------- Copyright (C) 1999  Anthony K. Peden (apeden@earthlink.net) -------------
   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
  27  HISTORY
  28 --------------------------------------------------------------------------------
  29 7/1/99   TP   Created
  30
  31
  32 FUNCTIONAL DESCRIPTION
  33 --------------------------------------------------------------------------------
  34
  35 The purpose of this class is to take a set of initial conditions and provide
  36 a kinematically consistent set of body axis velocity components, euler
  37 angles, and altitude.  This class does not attempt to trim the model i.e.
  38 the sim will most likely start in a very dynamic state (unless, of course,
  39 you have chosen your IC's wisely) even after setting it up with this class.
  40
  41 ********************************************************************************
  42 SENTRY
  43 *******************************************************************************/
  44
  45 #ifndef FGINITIALCONDITION_H
  46 #define FGINITIALCONDITION_H
  47
  48 /*******************************************************************************
  49 INCLUDES
  50 *******************************************************************************/
  51
  52 #include "FGFDMExec.h"
  53 #include "FGAtmosphere.h"
  54 #include "FGMatrix.h"
  55
  56 /*******************************************************************************
  57 CLASS DECLARATION
  58 *******************************************************************************/
  59
  60 typedef enum { setvt, setvc, setve, setmach } speedset;
  61
  62
  63 /* USAGE NOTES
  64    With a valid object of FGFDMExec and an aircraft model loaded
  65    FGInitialCondition fgic=new FGInitialCondition(FDMExec);
  66    fgic->SetVcalibratedKtsIC()
  67    fgic->SetAltitudeFtIC();
  68    .
  69    .
  70    .
  71    //to directly into Run
  72    FDMExec->GetState()->Initialize(fgic)
  73    delete fgic;
  74    FDMExec->Run()
  75
  76    //or to loop the sim w/o integrating
  77    FDMExec->RunIC(fgic)
  78
  79
  80
  81    Speed:
  82          Since vc, ve, vt, and mach all represent speed, the remaining
  83          three are recalculated each time one of them is set (using the
  84          current altitude).  The most recent speed set is remembered so
  85          that if and when altitude is reset, the last set speed is used
  86          to recalculate the remaining three. Setting any of the body
  87          components forces a recalculation of vt and vt then becomes the
  88          most recent speed set.
  89
  90    Alpha,Gamma, and Theta:
  91      This class assumes that it will be used to set up the sim for a
  92          steady, zero pitch rate condition. This entails the assumption
  93          that alpha=theta-gamma. Since any two of those angles specifies
  94          the third (again, for zero pitch rate) gamma (flight path angle)
  95          is favored when setting alpha and theta and alpha is favored when
  96          setting gamma. i.e.
  97           set alpha : recalculate theta using gamma as currently set
  98                   set theta : recalculate alpha using gamma as currently set
  99                   set gamma : recalculate theta using alpha as currently set
 100
 101          The idea being that gamma is most interesting to pilots (since it
 102          is indicative of climb rate).
 103
 104          Setting climb rate is, for the purpose of this discussion,
 105          considered equivalent to setting gamma.
 106
 107 */
 108 class FGInitialCondition {
 109 public:
 110
 111   FGInitialCondition(FGFDMExec *fdmex);
 112   ~FGInitialCondition(void);
 113
 114   void SetVcalibratedKtsIC(float tt);
 115   void SetVequivalentKtsIC(float tt);
 116   void SetVtrueKtsIC(float tt);
 117   void SetMachIC(float tt);
 118
 119   void SetUBodyFpsIC(float tt);
 120   void SetVBodyFpsIC(float tt);
 121   void SetWBodyFpsIC(float tt);
 122
 123   void SetAltitudeFtIC(float tt);
 124   void SetAltitudeAGLFtIC(float tt);
 125
 126   //"vertical" flight path, recalculate theta
 127   inline void SetFlightPathAngleDegIC(float tt) { SetFlightPathAngleRadIC(gamma=tt*DEGTORAD); }
 128   void SetFlightPathAngleRadIC(float tt);
 129   //set speed first
 130   void SetClimbRateFpmIC(float tt);
 131   //use currently stored gamma, recalcualte theta
 132   inline void SetAlphaDegIC(float tt)      { alpha=tt*DEGTORAD; getTheta(); }
 133   inline void SetAlphaRadIC(float tt)      { alpha=tt; getTheta(); }
 134   //use currently stored gamma, recalcualte alpha
 135   inline void SetPitchAngleDegIC(float tt) { theta=tt*DEGTORAD; getAlpha(); }
 136   inline void SetPitchAngleRadIC(float tt) { theta=tt; getAlpha(); }
 137
 138   inline void SetBetaDegIC(float tt)       { beta=tt*DEGTORAD; getTheta();}
 139   inline void SetBetaRadIC(float tt)       { beta=tt; getTheta(); }
 140
 141   inline void SetRollAngleDegIC(float tt) { phi=tt*DEGTORAD; getTheta(); }
 142   inline void SetRollAngleRadIC(float tt) { phi=tt; getTheta(); }
 143
 144   inline void SetHeadingDegIC(float tt)   { psi=tt*DEGTORAD; }
 145   inline void SetHeadingRadIC(float tt)   { psi=tt; }
 146
 147   inline void SetLatitudeDegIC(float tt)  { latitude=tt*DEGTORAD; }
 148   inline void SetLatitudeRadIC(float tt)  { latitude=tt; }
 149
 150   inline void SetLongitudeDegIC(float tt) { longitude=tt*DEGTORAD; }
 151   inline void SetLongitudeRadIC(float tt) { longitude=tt; }
 152
 153   inline float GetVcalibratedKtsIC(void) { return vc*FPSTOKTS; }
 154   inline float GetVequivalentKtsIC(void) { return ve*FPSTOKTS; }
 155   inline float GetVtrueKtsIC(void) { return vt*FPSTOKTS; }
 156   inline float GetVtrueFpsIC(void) { return vt; }
 157   inline float GetMachIC(void) { return mach; }
 158
 159   inline float GetAltitudeFtIC(void) { return altitude; }
 160
 161   inline float GetFlightPathAngleDegIC(void) { return gamma*RADTODEG; }
 162   inline float GetFlightPathAngleRadIC(void) { return gamma; }
 163
 164   inline float GetClimbRateFpmIC(void) { return hdot*60; }
 165   inline float GetClimbRateFpsIC(void) { return hdot; }
 166
 167   inline float GetAlphaDegIC(void)      { return alpha*RADTODEG; }
 168   inline float GetAlphaRadIC(void)      { return alpha; }
 169
 170   inline float GetPitchAngleDegIC(void) { return theta*RADTODEG; }
 171   inline float GetPitchAngleRadIC(void) { return theta; }
 172
 173
 174   inline float GetBetaDegIC(void)       { return beta*RADTODEG; }
 175   inline float GetBetaRadIC(void)       { return beta*RADTODEG; }
 176
 177   inline float GetRollAngleDegIC(void) { return phi*RADTODEG; }
 178   inline float GetRollAngleRadIC(void) { return phi; }
 179
 180   inline float GetHeadingDegIC(void)   { return psi*RADTODEG; }
 181   inline float GetHeadingRadIC(void)   { return psi; }
 182
 183   inline float GetLatitudeDegIC(void)  { return latitude*RADTODEG; }
 184   inline float GetLatitudeRadIC(void) { return latitude; }
 185
 186   inline float GetLongitudeDegIC(void) { return longitude*RADTODEG; }
 187   inline float GetLongitudeRadIC(void) { return longitude; }
 188
 189   inline float GetUBodyFpsIC(void) { return vt*cos(alpha)*cos(beta); }
 190   inline float GetVBodyFpsIC(void) { return vt*sin(beta); }
 191   inline float GetWBodyFpsIC(void) { return vt*sin(alpha)*cos(beta); }
 192
 193   inline float GetThetaRadIC(void) { return theta; }
 194   inline float GetPhiRadIC(void)   { return phi; }
 195   inline float GetPsiRadIC(void)   { return psi; }
 196
 197
 198
 199 private:
 200   float vt,vc,ve;
 201   float alpha,beta,gamma,theta,phi,psi;
 202   float mach;
 203   float altitude,hdot;
 204   float latitude,longitude;
 205   float u,v,w;
 206
 207   float xlo, xhi,xmin,xmax;
 208
 209   typedef float (FGInitialCondition::*fp)(float x);
 210   fp sfunc;
 211
 212   speedset lastSpeedSet;
 213
 214   FGFDMExec *fdmex;
 215
 216
 217   bool getAlpha(void);
 218   bool getTheta(void);
 219   bool getMachFromVcas(float *Mach,float vcas);
 220
 221   float GammaEqOfTheta(float Theta);
 222   float GammaEqOfAlpha(float Alpha);
 223   float calcVcas(float Mach);
 224
 225   bool findInterval(float x,float guess);
 226   bool solve(float *y, float x);
 227 };
 228
 229 #endif