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. Since any two of those angles
  93    specifies the third gamma (flight path angle) is favored when setting
  94    alpha and theta and alpha is favored when setting gamma. i.e.
  95         set alpha : recalculate theta using gamma as currently set
  96                   set theta : recalculate alpha using gamma as currently set
  97                   set gamma : recalculate theta using alpha as currently set
  98
  99          The idea being that gamma is most interesting to pilots (since it
 100          is indicative of climb rate).
 101
 102          Setting climb rate is, for the purpose of this discussion,
 103          considered equivalent to setting gamma.
 104
 105 */
 106
 107 class FGInitialCondition {
 108 public:
 109
 110   FGInitialCondition(FGFDMExec *fdmex);
 111   ~FGInitialCondition(void);
 112
 113   void SetVcalibratedKtsIC(float tt);
 114   void SetVequivalentKtsIC(float tt);
 115   void SetVtrueKtsIC(float tt);
 116   void SetMachIC(float tt);
 117
 118   void SetUBodyFpsIC(float tt);
 119   void SetVBodyFpsIC(float tt);
 120   void SetWBodyFpsIC(float tt);
 121
 122   void SetVnorthFpsIC(float tt);
 123   void SetVeastFpsIC(float tt);
 124   void SetVdownFpsIC(float tt);
 125
 126   void SetAltitudeFtIC(float tt);
 127   void SetAltitudeAGLFtIC(float tt);
 128
 129   //"vertical" flight path, recalculate theta
 130   inline void SetFlightPathAngleDegIC(float tt) { SetFlightPathAngleRadIC(tt*DEGTORAD); }
 131   void SetFlightPathAngleRadIC(float tt);
 132   //set speed first
 133   void SetClimbRateFpmIC(float tt);
 134   void SetClimbRateFpsIC(float tt);
 135   //use currently stored gamma, recalcualte theta
 136   inline void SetAlphaDegIC(float tt)      { alpha=tt*DEGTORAD; getTheta(); }
 137   inline void SetAlphaRadIC(float tt)      { alpha=tt; getTheta(); }
 138   //use currently stored gamma, recalcualte alpha
 139   inline void SetPitchAngleDegIC(float tt) { theta=tt*DEGTORAD; getAlpha(); }
 140   inline void SetPitchAngleRadIC(float tt) { theta=tt; getAlpha(); }
 141
 142   inline void SetBetaDegIC(float tt)       { beta=tt*DEGTORAD; getTheta();}
 143   inline void SetBetaRadIC(float tt)       { beta=tt; getTheta(); }
 144
 145   inline void SetRollAngleDegIC(float tt) { phi=tt*DEGTORAD; getTheta(); }
 146   inline void SetRollAngleRadIC(float tt) { phi=tt; getTheta(); }
 147
 148   inline void SetHeadingDegIC(float tt)   { psi=tt*DEGTORAD; }
 149   inline void SetHeadingRadIC(float tt)   { psi=tt; }
 150
 151   inline void SetLatitudeDegIC(float tt)  { latitude=tt*DEGTORAD; }
 152   inline void SetLatitudeRadIC(float tt)  { latitude=tt; }
 153
 154   inline void SetLongitudeDegIC(float tt) { longitude=tt*DEGTORAD; }
 155   inline void SetLongitudeRadIC(float tt) { longitude=tt; }
 156
 157   inline float GetVcalibratedKtsIC(void) { return vc*FPSTOKTS; }
 158   inline float GetVequivalentKtsIC(void) { return ve*FPSTOKTS; }
 159   inline float GetVtrueKtsIC(void) { return vt*FPSTOKTS; }
 160   inline float GetVtrueFpsIC(void) { return vt; }
 161   inline float GetMachIC(void) { return mach; }
 162
 163   inline float GetAltitudeFtIC(void) { return altitude; }
 164
 165   inline float GetFlightPathAngleDegIC(void) { return gamma*RADTODEG; }
 166   inline float GetFlightPathAngleRadIC(void) { return gamma; }
 167
 168   inline float GetClimbRateFpmIC(void) { return hdot*60; }
 169   inline float GetClimbRateFpsIC(void) { return hdot; }
 170
 171   inline float GetAlphaDegIC(void)      { return alpha*RADTODEG; }
 172   inline float GetAlphaRadIC(void)      { return alpha; }
 173
 174   inline float GetPitchAngleDegIC(void) { return theta*RADTODEG; }
 175   inline float GetPitchAngleRadIC(void) { return theta; }
 176
 177
 178   inline float GetBetaDegIC(void)       { return beta*RADTODEG; }
 179   inline float GetBetaRadIC(void)       { return beta*RADTODEG; }
 180
 181   inline float GetRollAngleDegIC(void) { return phi*RADTODEG; }
 182   inline float GetRollAngleRadIC(void) { return phi; }
 183
 184   inline float GetHeadingDegIC(void)   { return psi*RADTODEG; }
 185   inline float GetHeadingRadIC(void)   { return psi; }
 186
 187   inline float GetLatitudeDegIC(void)  { return latitude*RADTODEG; }
 188   inline float GetLatitudeRadIC(void) { return latitude; }
 189
 190   inline float GetLongitudeDegIC(void) { return longitude*RADTODEG; }
 191   inline float GetLongitudeRadIC(void) { return longitude; }
 192
 193   inline float GetUBodyFpsIC(void) { return vt*cos(alpha)*cos(beta); }
 194   inline float GetVBodyFpsIC(void) { return vt*sin(beta); }
 195   inline float GetWBodyFpsIC(void) { return vt*sin(alpha)*cos(beta); }
 196
 197   inline float GetThetaRadIC(void) { return theta; }
 198   inline float GetPhiRadIC(void)   { return phi; }
 199   inline float GetPsiRadIC(void)   { return psi; }
 200
 201
 202
 203 private:
 204   float vt,vc,ve;
 205   float alpha,beta,gamma,theta,phi,psi;
 206   float mach;
 207   float altitude,hdot;
 208   float latitude,longitude;
 209   float u,v,w;
 210   float vnorth,veast,vdown;
 211
 212   float xlo, xhi,xmin,xmax;
 213
 214   typedef float (FGInitialCondition::*fp)(float x);
 215   fp sfunc;
 216
 217   speedset lastSpeedSet;
 218
 219   FGFDMExec *fdmex;
 220
 221
 222   bool getAlpha(void);
 223   bool getTheta(void);
 224   bool getMachFromVcas(float *Mach,float vcas);
 225
 226   float GammaEqOfTheta(float Theta);
 227   float GammaEqOfAlpha(float Alpha);
 228   float calcVcas(float Mach);
 229   void calcUVWfromNED(void);
 230
 231   bool findInterval(float x,float guess);
 232   bool solve(float *y, float x);
 233 };
 234
 235 #endif