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 #define ID_INITIALCONDITION "$Header"
  57
  58 /*******************************************************************************
  59 CLASS DECLARATION
  60 *******************************************************************************/
  61
  62 typedef enum { setvt, setvc, setve, setmach, setuvw, setned } speedset;
  63
  64 #define jsbFPSTOKTS 0.5924838
  65 #define jsbKTSTOFPS 1.6878099
  66
  67
  68 /* USAGE NOTES
  69    With a valid object of FGFDMExec and an aircraft model loaded
  70    FGInitialCondition fgic=new FGInitialCondition(FDMExec);
  71    fgic->SetVcalibratedKtsIC()
  72    fgic->SetAltitudeFtIC();
  73    .
  74    .
  75    .
  76    //to directly into Run
  77    FDMExec->GetState()->Initialize(fgic)
  78    delete fgic;
  79    FDMExec->Run()
  80
  81    //or to loop the sim w/o integrating
  82    FDMExec->RunIC(fgic)
  83
  84
  85
  86    Speed:
  87          Since vc, ve, vt, and mach all represent speed, the remaining
  88          three are recalculated each time one of them is set (using the
  89          current altitude).  The most recent speed set is remembered so
  90          that if and when altitude is reset, the last set speed is used
  91          to recalculate the remaining three. Setting any of the body
  92          components forces a recalculation of vt and vt then becomes the
  93          most recent speed set.
  94
  95    Alpha,Gamma, and Theta:
  96      This class assumes that it will be used to set up the sim for a
  97          steady, zero pitch rate condition. Since any two of those angles
  98    specifies the third gamma (flight path angle) is favored when setting
  99    alpha and theta and alpha is favored when setting gamma. i.e.
 100         set alpha : recalculate theta using gamma as currently set
 101                   set theta : recalculate alpha using gamma as currently set
 102                   set gamma : recalculate theta using alpha as currently set
 103
 104          The idea being that gamma is most interesting to pilots (since it
 105          is indicative of climb rate).
 106
 107          Setting climb rate is, for the purpose of this discussion,
 108          considered equivalent to setting gamma.
 109
 110 */
 111 class FGInitialCondition {
 112 public:
 113
 114   FGInitialCondition(FGFDMExec *fdmex);
 115   ~FGInitialCondition(void);
 116
 117   inline speedset GetSpeedSet(void) { return lastSpeedSet; }
 118
 119   void SetVcalibratedKtsIC(float tt);
 120   void SetVequivalentKtsIC(float tt);
 121   inline void SetVtrueKtsIC(float tt) { SetVtrueFpsIC(tt*jsbKTSTOFPS); }
 122   void SetVtrueFpsIC(float tt);
 123   void SetMachIC(float tt);
 124
 125   void SetUBodyFpsIC(float tt);
 126   void SetVBodyFpsIC(float tt);
 127   void SetWBodyFpsIC(float tt);
 128
 129   void SetVnorthFpsIC(float tt);
 130   void SetVeastFpsIC(float tt);
 131   void SetVdownFpsIC(float tt);
 132
 133   void SetAltitudeFtIC(float tt);
 134   void SetAltitudeAGLFtIC(float tt);
 135
 136   void SetSeaLevelRadiusFtIC(double tt);
 137   void SetTerrainAltitudeFtIC(double tt);
 138
 139   //"vertical" flight path, recalculate theta
 140   inline void SetFlightPathAngleDegIC(float tt) { SetFlightPathAngleRadIC(tt*DEGTORAD); }
 141   void SetFlightPathAngleRadIC(float tt);
 142   //set speed first
 143   void SetClimbRateFpmIC(float tt);
 144   void SetClimbRateFpsIC(float tt);
 145   //use currently stored gamma, recalcualte theta
 146   inline void SetAlphaDegIC(float tt)      { alpha=tt*DEGTORAD; getTheta(); }
 147   inline void SetAlphaRadIC(float tt)      { alpha=tt; getTheta(); }
 148   //use currently stored gamma, recalcualte alpha
 149   inline void SetPitchAngleDegIC(float tt) { theta=tt*DEGTORAD; getAlpha(); }
 150   inline void SetPitchAngleRadIC(float tt) { theta=tt; getAlpha(); }
 151
 152   inline void SetBetaDegIC(float tt)       { beta=tt*DEGTORAD; getTheta();}
 153   inline void SetBetaRadIC(float tt)       { beta=tt; getTheta(); }
 154
 155   inline void SetRollAngleDegIC(float tt) { phi=tt*DEGTORAD; getTheta(); }
 156   inline void SetRollAngleRadIC(float tt) { phi=tt; getTheta(); }
 157
 158   inline void SetTrueHeadingDegIC(float tt)   { psi=tt*DEGTORAD; }
 159   inline void SetTrueHeadingRadIC(float tt)   { psi=tt; }
 160
 161   inline void SetLatitudeDegIC(float tt)  { latitude=tt*DEGTORAD; }
 162   inline void SetLatitudeRadIC(float tt)  { latitude=tt; }
 163
 164   inline void SetLongitudeDegIC(float tt) { longitude=tt*DEGTORAD; }
 165   inline void SetLongitudeRadIC(float tt) { longitude=tt; }
 166
 167   inline float GetVcalibratedKtsIC(void) { return vc*jsbFPSTOKTS; }
 168   inline float GetVequivalentKtsIC(void) { return ve*jsbFPSTOKTS; }
 169   inline float GetVtrueKtsIC(void) { return vt*jsbFPSTOKTS; }
 170   inline float GetVtrueFpsIC(void) { return vt; }
 171   inline float GetMachIC(void) { return mach; }
 172
 173   inline float GetAltitudeFtIC(void) { return altitude; }
 174
 175   inline float GetFlightPathAngleDegIC(void) { return gamma*RADTODEG; }
 176   inline float GetFlightPathAngleRadIC(void) { return gamma; }
 177
 178   inline float GetClimbRateFpmIC(void) { return hdot*60; }
 179   inline float GetClimbRateFpsIC(void) { return hdot; }
 180
 181   inline float GetAlphaDegIC(void)      { return alpha*RADTODEG; }
 182   inline float GetAlphaRadIC(void)      { return alpha; }
 183
 184   inline float GetPitchAngleDegIC(void) { return theta*RADTODEG; }
 185   inline float GetPitchAngleRadIC(void) { return theta; }
 186
 187
 188   inline float GetBetaDegIC(void)       { return beta*RADTODEG; }
 189   inline float GetBetaRadIC(void)       { return beta*RADTODEG; }
 190
 191   inline float GetRollAngleDegIC(void) { return phi*RADTODEG; }
 192   inline float GetRollAngleRadIC(void) { return phi; }
 193
 194   inline float GetHeadingDegIC(void)   { return psi*RADTODEG; }
 195   inline float GetHeadingRadIC(void)   { return psi; }
 196
 197   inline float GetLatitudeDegIC(void)  { return latitude*RADTODEG; }
 198   inline float GetLatitudeRadIC(void) { return latitude; }
 199
 200   inline float GetLongitudeDegIC(void) { return longitude*RADTODEG; }
 201   inline float GetLongitudeRadIC(void) { return longitude; }
 202
 203   inline float GetUBodyFpsIC(void) { return vt*cos(alpha)*cos(beta); }
 204   inline float GetVBodyFpsIC(void) { return vt*sin(beta); }
 205   inline float GetWBodyFpsIC(void) { return vt*sin(alpha)*cos(beta); }
 206
 207   inline float GetThetaRadIC(void) { return theta; }
 208   inline float GetPhiRadIC(void)   { return phi; }
 209   inline float GetPsiRadIC(void)   { return psi; }
 210
 211   inline float GetSeaLevelRadiusFtIC(void)  { return sea_level_radius; }
 212   inline float GetTerrainAltitudeFtIC(void) { return terrain_altitude; }
 213
 214
 215
 216 private:
 217   float vt,vc,ve;
 218   float alpha,beta,gamma,theta,phi,psi;
 219   float mach;
 220   float altitude,hdot;
 221   float latitude,longitude;
 222   float u,v,w;
 223   float vnorth,veast,vdown;
 224   double sea_level_radius;
 225   double terrain_altitude;
 226   double radius_to_vehicle;
 227
 228   float xlo, xhi,xmin,xmax;
 229
 230   typedef float (FGInitialCondition::*fp)(float x);
 231   fp sfunc;
 232
 233   speedset lastSpeedSet;
 234
 235   FGFDMExec *fdmex;
 236
 237
 238   bool getAlpha(void);
 239   bool getTheta(void);
 240   bool getMachFromVcas(float *Mach,float vcas);
 241
 242   float GammaEqOfTheta(float Theta);
 243   float GammaEqOfAlpha(float Alpha);
 244   float calcVcas(float Mach);
 245   void calcUVWfromNED(void);
 246
 247   bool findInterval(float x,float guess);
 248   bool solve(float *y, float x);
 249 };
 250
 251 #endif