--- /dev/null
+************************************************
+* *
+* FGFS Reconfigurable Aircraft Flight Model *
+* Input File Documentation *
+* Version 0.73, June 27, 2000 *
+* *
+* Authors: *
+* Jeff Scott (jscott@mail.com) *
+* Bipin Sehgal (bsehgal@uiuc.edu) *
+* Michael Selig (m-selig@uiuc.edu) *
+* Dept of Aero and Astro Engineering *
+* University of Illinois at Urbana-Champaign *
+* Urbana, IL *
+* http://amber.aae.uiuc.edu/~m-selig *
+* *
+************************************************
+
+
+**********************************************************************
+NOTE: Most of the commands discussed in this documentation are
+ currently implemented in the UIUC aerodynamics model. Those
+ denoted by '|' are proposed and will likely be added in the
+ future but are not currently implemented. Some commands are
+ in use but not producing the desired results. These are
+ clearly noted, so please do not attempt to use them at this
+ time.
+**********************************************************************
+
+**********************************************************************
+This documentation includes:
+ - Required and optional input lines.
+ - Input line formats and conventions.
+
+ Viewing this file in emacs makefile-mode with color makes this file
+ easier to read.
+**********************************************************************
+
+**********************************************************************
+I. Conventions and Notations and Reading this Document:
+
+ # ... Comments
+ | Input line not yet implemented
+ | Optional data
+ | Sometimes indicates a feature not yet used,
+ but proposed convention is indicated nevertheless.
+ <...> Value or file name to be placed here
+ || Input line disabled
+ || Option disabled
+ ... Repeat similar data
+ -> Continue onto next line
+**********************************************************************
+
+**********************************************************************
+II. General Input Line Format:
+
+Examples input lines include
+
+Cm Cmo 0.194 # [] Bray pg 33
+Cm Cm_a -2.12 # [/rad] Bray pg 33
+CL CLfa CLfa.dat 0 1 # [] Bray pg 50, Table 4.7
+
+These follow the more general input line form
+
+keyword variableName <value -or- file> | ->
+ <value -or- file> # [units] <data source>
+
+Each term of the input line will be discussed in turn.
+
+(1) KEYWORDS
+============
+
+There currently exist the following variable keyword types:
+
+init Initial values for equation of motion
+geometry Aircraft-specific geometric quantities
+controlSurface Control surface deflections and properties
+|controlsMixer Control surface mixer options
+mass Aircraft-specific mass properties
+engine Propulsion data
+CD Aerodynamic x-force quantities (longitudinal)
+CL Aerodynamic z-force quantities (longitudinal)
+Cm Aerodynamic m-moment quantities (longitudinal)
+CY Aerodynamic y-force quantities (lateral)
+Cl Aerodynamic l-moment quantities (lateral)
+Cn Aerodynamic n-moment quantities (lateral)
+|gear Landing gear model quantities
+ice Icing model parameters
+record Record desired quantites to file
+misc Miscellaneous inputs
+
+As each line of the input file is read, the code recognizes the
+keyword, enters the appropriate switch statement in the code, and
+proceeds to read the next term in the input line.
+
+(2) VARIABLE NAMES
+==================
+
+The variable name indicates the form of the variable itself. This
+form may be a constant, a stability derivative (a specific form of a
+constant), or a variable-dimensional lookup table. More variable
+types can be easily prescribed by defining a new convention. The
+variable name may also indicate that the quantity is to be calculated
+from a hard-coded equation or set of equations provided at an
+appropriate location within the code.
+
+If the parameter name denotes a constant, a numerical value will
+follow the variable name. If a lookup table, the name of the table
+containing the data will follow.
+
+More than one value or file name can be specified if the code is
+intended to read in multiple pieces of data when implementing the
+particular switch in question (see also OPTIONAL data, section (3)).
+
+The conventions used for naming the variables are provided below.
+Several of these variable names are not currently used.
+
+1) variable class
+_ denotes stability derivative
+f "function of" (indicates data table)
+
+2) timing data (global simulator variables)
+Simtime current simulator time [s]
+dt current simulator time step [s]
+
+3) aircraft position data
+Lat_geocentric geocentric latitude of CG [rad]
+Lon_geocentric geocentric longitude of CG [rad]
+Radius_to_vehicle distance of CG from inertial frame [ft]
+Latitude geodetic latitude of CG [rad]
+Longitude geodetic longitude of CG [rad]
+Altitude height of CG above reference ellipsoid [ft]
+Phi Euler bank/roll angle [rad]
+Theta Euler pitch attitude angle [rad]
+Psi Euler heading angle [rad]
+
+4) aircraft accelerations
+V_dot_north local x-acceleration [ft/s^2]
+V_dot_east local y-acceleration [ft/s^2]
+V_dot_down local z-acceleration [ft/s^2]
+U_dot_body body x-acceleration [ft/s^2]
+V_dot_body body y-acceleration [ft/s^2]
+W_dot_body body z-acceleration [ft/s^2]
+A_X_pilot pilot x-acceleration [ft/s^2]
+A_Y_pilot pilot y-acceleration [ft/s^2]
+A_Z_pilot pilot z-acceleration [ft/s^2]
+A_X_cg center of gravity x-acceleration [ft/s^2]
+A_Y_cg center of gravity x-acceleration [ft/s^2]
+A_Z_cg center of gravity x-acceleration [ft/s^2]
+N_X_pilot pilot x-acceleration [ft/s^2]
+N_Y_pilot pilot y-acceleration [ft/s^2]
+N_Z_pilot pilot z-acceleration [ft/s^2]
+N_X_cg center of gravity x-acceleration [ft/s^2]
+N_Y_cg center of gravity Y-acceleration [ft/s^2]
+N_Z_cg center of gravity Z-acceleration [ft/s^2]
+P_dot_body roll rate acceleration [rad/s^2]
+Q_dot_body pitch rate acceleration [rad/s^2]
+R_dot_body yaw rate acceleration [rad/s^2]
+
+5) aircraft velocities
+V_north local x-velocity [ft/s]
+V_east local y-velocity [ft/s]
+V_down local z-velocity [ft/s]
+V_north_rel_ground local x-velocity with respect to ground [ft/s]
+V_east_rel_ground local y-velocity with respect to ground [ft/s]
+V_down_rel_ground local z-velocity with respect to ground [ft/s]
+V_north_airmass local x-velocity of steady airmass [ft/s]
+V_east_airmass local y-velocity of steady airmass [ft/s]
+V_down_airmass local z-velocity of steady airmass [ft/s]
+V_north_rel_airmass local x-velocity wrt steady airmass [ft/s]
+V_east_rel_airmass local y-velocity wrt steady airmass [ft/s]
+V_down_rel_airmass local z-velocity wrt steady airmass [ft/s]
+U_gust local linear turbulence x-velocity [ft/s]
+V_gust local linear turbulence y-velocity [ft/s]
+W_gust local linear turbulence z-velocity [ft/s]
+U_body wind x-velocity in body axis [ft/s]
+V_body wind y-velocity in body axis [ft/s]
+W_body wind z-velocity in body axis [ft/s]
+V_rel_wind total wind velocity (freestream) [ft/s]
+V_true_kts true velocity [kts]
+V_rel_ground total velocity wrt ground [ft/s]
+V_inertial total inertial velocity [ft/s]
+V_ground_speed velocity at right angles to local vertical [ft/s]
+V_equiv equivalent airspeed [ft/s]
+V_equiv_kts equivalent airspeed [kts]
+V_calibrated calibrated indicated airspeed [ft/s]
+V_calibrated_kts calibrated indicated airspeed [kts]
+P_local local roll rate [rad/s]
+Q_local local pitch rate [rad/s]
+R_local local yaw rate [rad/s]
+P_body body roll rate [rad/s]
+Q_body body pitch rate [rad/s]
+R_body body yaw rate [rad/s]
+P_total roll rate of body axis wrt local axis [rad/s]
+Q_total pitch rate of body axis wrt local axis [rad/s]
+R_total yaw rate of body axis wrt local axis [rad/s]
+Phi_dot change in bank angle rate [rad/s]
+Theta_dot change in pitch attitude angle rate [rad/s]
+Psi_dot change in heading angle rate [rad/s]
+Latitude_dot change in geocentric latitude rate [rad/s]
+Longitude_dot change in geocentric longitude rate [rad/s]
+Radius_dot change in geocentric radius rate [ft/s]
+
+6) angles
+Alpha angle of attack [rad]
+Alpha_deg angle of attack [deg]
+Alpha_dot rate of change of alpha [rad/s]
+Alpha_dot_deg rate of change of alpha [deg/s]
+Beta sideslip angle [rad]
+Beta_deg sideslip angle [deg]
+Beta_dot rate of change of beta [rad]
+Beta_dot_deg rate of change of beta [deg]
+Gamma_vert local vertical flight path angle [rad]
+Gamma_ver_deg local vertical flight path angle [deg]
+Gamma_horiz local horizontal flight path angle [rad]
+Gamma_horiz_deg local horizontal flight path angle [deg]
+
+7) atmosperic properties
+Density atmospheric density [slug/ft^3]
+V_sound speed of sound [ft/s]
+Mach_number free-stream Mach number []
+M Mach number []
+Re Reynolds number []
+Static_pressure static pressure [lb/ft^2]
+Total_pressure total pressure [lb/ft^2]
+Impact_pressure impact pressure [lb/ft^2]
+Dynamic_pressure dynamic pressure [lb/ft^2]
+Static_temperature static temperature [deg F?]
+Total_temperature total temperature [deg F?]
+
+8) Earth properties
+Gravity acceleration due to gravity [ft/s^2]
+Sea_level_radius local Earth radius [ft]
+Earth_position_angle Earth rotation angle since reference time [rad]
+Runway_altitude runway height above local sea level [ft]
+Runway_latitude runway latitude [rad]
+Runway_longitude runway longitude [rad]
+Runway_heading runway heading [rad]
+Radius_to_rwy geocentric radius to runway [ft]
+D_pilot_north_of_rwy local pilot x-distance from runway [ft]
+D_pilot_east_of_rwy local pilot y-distance from runway [ft]
+D_pilot_down_of_rwy local pilot z-distance from runway [ft]
+X_pilot_rwy pilot x-distance from rwy in rwy axis [ft]
+Y_pilot_rwy pilot y-distance from rwy in rwy axis [ft]
+H_pilot_rwy pilot z-distance from rwy in rwy axis [ft]
+D_cg_north_of_rwy local cg x-distance from runway [ft]
+D_cg_east_of_rwy local cg y-distance from runway [ft]
+D_cg_down_of_rwy local cg z-distance from runway [ft]
+X_cg_rwy cg x-distance from rwy in rwy axis [ft]
+Y_cg_rwy cg y-distance from rwy in rwy axis [ft]
+H_cg_rwy cg z-distance from rwy in rwy axis [ft]
+
+9) aircraft geometric variables
+bw wingspan [ft]
+cbar mean aerodynamic chord [ft]
+Sw wing planform area [ft^2]
+|iw wing incidence angle [deg]
+|bc canard span [ft]
+|cc canard (mean) chord [ft]
+|Sc canard area [ft^2]
+|ic canard incidence angle [deg]
+bh horizontal tail span [ft]
+ch horizontal tail (mean) chord [ft]
+Sh horizontal tail area [ft^2]
+ih horizontal tail incidence angle [deg]
+|bv vertical tail span (height) [ft]
+|cv vertical tail (mean) chord [ft]
+|iv vertical tail incidence angle [deg]
+|Sv vertical tail area [ft^2]
+Dx_pilot reference pilot x-location [ft]
+Dy_pilot reference pilot y-location [ft]
+Dz_pilot referende pilot z-location [ft]
+Dx_cg reference center of gravity x-loc [ft]
+Dy_cg reference center of gravity y-loc [ft]
+Dz_cg reference center of gravity z-loc [ft]
+
+10) aircraft control surface properties
+|Sa aileron area [ft^2]
+|Se elevator area [ft^2]
+|Sf flap area [ft^2]
+|Sr rudder area [ft^2]
+Long_control pitch control input []
+Long_trim longitudinal trim input [rad]
+set_Long_trim set longitudinal trim to constant[rad]
+zero_Long_trim set longitudinal trim to zero [deg]
+elevator elevator deflection [rad]
+Lat_control roll control input []
+aileron aileron deflection [rad]
+Rudder_pedal yaw control input []
+rudder rudder deflection [rad]
+|flap flap deflection [rad]
+
+11) user-specified control surface deflections
+elevator_step_angle elevator step input angle [deg]
+elevator_step_startTime elevator step input starting time [s]
+elevator_singlet_angle elevator singlet input angle [deg]
+elevator_singlet_startTime elevator singlet input starting time [s]
+elevator_singlet_duration elevator singlet time duration [s]
+elevator_doublet_angle elevator singlet input angle [deg]
+elevator_doublet_startTime elevator doublet input starting time [s]
+elevator_doublet_duration elevator doublet TOTAL time duration [s]
+elevator_input_file file of elevator deflections vs. time [s,deg]
+
+12) mass variables
+Weight gross takeoff weight [lb]
+Mass aircraft mass (used by LaRCsim) [slug]
+I_xx roll inertia [slug-ft^2]
+I_yy pitch inertia [slug-ft^2]
+I_zz yaw inertia [slug-ft^2]
+I_xz lateral cross inertia [slug-ft^2]
+
+13) engine/propulsion variables
+|thrust engine thrust [lb]
+simpleSingle treat all engines as one; max thrust [lb]
+Throttle_pct throttle input ("stick") []
+Throttle_3 throttle deflection (determines thrust) [%]
+
+14) force/moment coefficients
+CD coefficient of drag []
+CY coefficient of side-force []
+CL coefficient of lift []
+Cl coefficient of roll moment []
+Cm coefficient of pitching moment []
+Cn coefficient of yaw moment []
+|CT coefficient of thrust []
+
+15) total forces/moments
+F_X_wind aerodynamic x-force in wind-axes [lb]
+F_Y_wind aerodynamic y-force in wind-axes [lb]
+F_Z_wind aerodynamic z-force in wind-axes [lb]
+F_X_aero aerodynamic x-force in body-axes [lb]
+F_Y_aero aerodynamic y-force in body-axes [lb]
+F_Z_aero aerodynamic z-force in body-axes [lb]
+F_X_engine propulsion x-force in body axes [lb]
+F_Y_engine propulsion y-force in body axes [lb]
+F_Z_engine propulsion z-force in body axes [lb]
+F_X_gear gear x-force in body axes [lb]
+F_Y_gear gear y-force in body axes [lb]
+F_Z_gear gear z-force in body axes [lb]
+F_X total x-force in body-axes [lb]
+F_Y total y-force in body-axes [lb]
+F_Z total z-force in body-axes [lb]
+F_north total x-force in local-axes [lb]
+F_east total y-force in local-axes [lb]
+F_down total z-force in local-axes [lb]
+M_l_aero aero roll-moment in body-axes [ft-lb]
+M_m_aero aero pitch-moment in body-axes [ft-lb]
+M_n_aero aero yaw-moment in body-axes [ft-lb]
+M_l_engine prop roll-moment in body axes [ft-lb]
+M_m_engine prop pitch-moment in body axes [ft-lb]
+M_n_engine prop yaw-moment in body axes [ft-lb]
+M_l_gear gear roll-moment in body axes [ft-lb]
+M_m_gear gear pitch-moment in body axes [ft-lb]
+M_n_gear gear yaw-moment in body axes [ft-lb]
+M_l_rp total roll-moment [ft-lb]
+M_m_rp total pitch-moment [ft-lb]
+M_n_rp total yaw-moment [ft-lb]
+
+16) landing gear properties
+|cgear gear damping constant [?]
+|kgear gear spring constant [?]
+|muGear gear rolling friction coef [?]
+|strutLength gear strut length [ft]
+
+17) icing model parameters
+iceTime time when icing begins [s]
+transientTime time period over which eta increases to final [s]
+eta_ice_final icing severity factor at end of transient time []
+kCA icing constants for associated aero coef. [] (see IV)
+beta_probe_wing location of flow angle probe on wing [ft]
+beta_probe_tail location of flow angle probe on tail [ft]
+
+18) subscripts
+o value for all angles = 0 (alfa, beta, etc)
+a angle of attack
+a2 alpha squared
+a3 alpha cubed
+adot rate change in angle alpha
+beta sideslip angle
+b2 beta squared
+b3 beta cubed
+bdot rate change in beta
+p roll rate
+q pitch rate
+r yaw rate
+|pdot rate change in p
+|qdot rate change in q
+|rdot rate change in r
+|udot rate change in x-velocity
+da aileron deflection
+de elevator deflection
+dr rudder deflection
+|df flap deflection
+|df2 flap deflection for second set
+|df3 flap deflection for third set
+max maximum
+min minimum
+
+19) miscellaneous
+recordRate number of times to record data per second [/s]
+recordStartTime time to start recording outpud data [s]
+dyn_on_speed speed when dynamic pressure terms first computed [ft/s]
+nondim_rate_V_rel_wind use V_rel_wind to compute control rates []
+|simpleHingeMomentCoef hinge moment coefficient []
+
+(3) | [OPTIONAL DATA]
+=====================
+
+An input line may also be used to provide optional data that
+will be used if provided but is not necessary for the code to
+operate. As with the variable data described in section (2), multiple
+values or data files may be provided if the code is written to use
+them.
+
+(4) # [COMMENTS]
+================
+
+Appended comments should be provided with each input line to indicate
+units on the variable in question and to indicate the source the data
+was drawn from.
+**********************************************************************
+
+**********************************************************************
+III. Sample Input Lines:
+
+CONSTANTS
+=========
+
+geometry bw <value> # geometric parameter, wingspan
+Cm Cm_a <value> # stability derivative, d(Cm)/d(alpha)
+controlSurface de <value> <value> # max and min elevator deflections
+
+LOOKUP TABLES
+=============
+
+CD CDfCL <file.dat> # CD(CL), drag polar data file
+Cm Cmfade <file.dat> # Cm(alpha,delta_e), moment data file
+
+HARD-CODED EQUATION
+===================
+
+CD CDfCL # CD(CL), drag calculated in code based on CL
+(none currently in use)
+
+**********************************************************************
+
+**********************************************************************
+IV. Input Line Definitions:
+
+Of all the possible permutations of variable names described above in
+section II, only some are curently implemented in the code. These are
+described below. Comments, denoted by '#,' are used to define the
+lines and to indicate examples of the data if additional clarity is
+needed for unique situations. Again, those lines beginning with '|'
+are not currently implemented in the code, but indicate planned
+conventions in later versions.
+
+# Key Variable Data Units Description Where Defined
+#------------------------------------------------------------------------------------
+
+init recordRate <recordRate> # [/s] record data n times per second uiuc_aircraft.h
+
+# [s] time to start recording output data uiuc_aircraft.h
+init recordStartTime <recordStartTime>
+
+# [] use V_rel_wind to compute control rates (instead of U_body) uiuc_aircraft.h
+init nondim_rate_V_rel_wind <nondim_rate_V_rel_wind>
+
+# [ft/s] speed at which dynamic pressure terms are first computed uiuc_aircraft.h
+init dyn_on_speed <dyn_on_speed>
+
+init Dx_pilot <Dx_pilot> # [ft] reference pilot x-position ls_generic.h
+init Dy_pilot <Dy_pilot> # [ft] reference pilot y-position ls_generic.h
+init Dz_pilot <Dz_pilot> # [ft] reference pilot z-position ls_generic.h
+
+# the following commands are currently conflicting with Flight
+# Gear and are not working correctly:
+|init Dx_cg <Dx_cg> # [ft] reference cg x_location ls_generic.h
+|init Dy_cg <Dy_cg> # [ft] reference cg y_location ls_generic.h
+|init Dz_cg <Dz_cg> # [ft] reference cg z_location ls_generic.h
+|init V_north <V_north> # [ft/s] initial local x-velocity ls_generic.h
+|init V_east <V_east> # [ft/s] initial local y-velocity ls_generic.h
+|init V_down <V_down> # [ft/s] initial local z-velocity ls_generic.h
+|init Altitude <Altitude> # [ft/s] initial altitude ls_generic.h
+
+init P_body <P_body> # [rad/s] initial roll rate ls_generic.h
+init Q_body <Q_body> # [rad/s] initial pitch rate ls_generic.h
+init R_body <R_body> # [rad/s] initial yaw rate ls_generic.h
+init Phi <Phi> # [rad] initial bank angle ls_generic.h
+init Theta <Theta> # [rad] initial pitch attitude angle ls_generic.h
+init Psi <Psi> # [rad] initial heading angle ls_generic.h
+init Long_trim <Long_trim> # [rad] longitudinal trim ls_cockpit.h
+
+geometry bw <bw> # [ft] wingspan uiuc_aircraft.h
+geometry cbar <cbar> # [ft] wing mean aero chord uiuc_aircraft.h
+geometry Sw <Sw> # [ft^2] wing reference area uiuc_aircraft.h
+|geometry iw <iw> # [deg] wing incidence angle uiuc_aircraft.h
+|geometry bc <bc> # [ft] canard span uiuc_aircraft.h
+|geometry cc <cc> # [ft] canard chord uiuc_aircraft.h
+|geometry Sc <Sc> # [sq-ft] canard area uiuc_aircraft.h
+|geometry ic <ic> # [deg] canard incidence angle uiuc_aircraft.h
+geometry bh <bh> # [ft] horizontal tail span uiuc_aircraft.h
+geometry ch <ch> # [ft] horizontal tail chord uiuc_aircraft.h
+geometry Sh <Sh> # [sq-ft] horizontal tail area uiuc_aircraft.h
+geometry ih <ih> # [deg] horiz tail incidence angle uiuc_aircraft.h
+|geometry bv <bv> # [ft] vertical tail span uiuc_aircraft.h
+|geometry cv <cv> # [ft] vertical tail chord uiuc_aircraft.h
+|geometry Sv <Sv> # [sq-ft] vertical tail area uiuc_aircraft.h
+|geometry iv <iv> # [deg] vert tail incidence angle uiuc_aircraft.h
+
+|controlSurface Se <Se> # [ft^2] elevator area uiuc_aircraft.h
+|controlSurface Sa <Sa> # [ft^2] aileron area uiuc_aircraft.h
+|controlSurface Sr <Sr> # [ft^2] rudder area uiuc_aircraft.h
+|controlSurface Sf <Sf> # [ft^2] flap area uiuc_aircraft.h
+controlSurface de <demax> <demin> # [deg] max/min elev deflections uiuc_aircraft.h
+controlSurface da <damax> <damin> # [deg] max/min ail deflections uiuc_aircraft.h
+controlSurface dr <drmax> <drmin> # [deg] max/min rud deflections uiuc_aircraft.h
+|controlSurface df <dfmax> <dfmin> # [deg] max/min flap deflections uiuc_aircraft.h
+
+# Note: Currently demin/damin/drmin are not used in the code, and the max/min is +-dema
+
+# trim always set to some fixed input value (radians) [rad] uiuc_aircraft.h
+controlSurface set_Long_trim <elevator_tab>
+
+# trim always set to some fixed input value (degrees) [deg] uiuc_aircraft.h
+controlSurface set_Long_trim_deg <elevator_tab>
+
+controlSurface zero_Long_trim # [deg] trim always set to zero uiuc_aircraft.h
+
+# elevator step input with deflection angle [deg] and starting time [s] uiuc_aircraft.h
+controlSurface elevator_step <elevator_step_angle> <elevator_step_startTime>
+
+# elevator singlet input with deflection angle [deg], starting time [s],
+# and duration of input [s] uiuc_aircraft.h
+controlSurface elevator_singlet <elevator_singlet_angle> ->
+ <elevator_singlet_startTime> <elevator_singlet_duration>
+
+# elevator doublet input with deflection angle [deg], starting time [s],
+# and TOTAL duration of input (both up and down deflections) [s] uiuc_aircraft.h
+controlSurface elevator_doublet <elevator_doublet_angle> ->
+ <elevator_doublet_startTime> <elevator_doublet_duration>
+
+# tabulated elevator input (as function of time) with conversion
+# factor codes and starting time [s] uiuc_aircraft.h
+controlSurface elevator_input <elevator_input_file> ->
+ <token_value_convert1> <token_value_convert2> ->
+ <elevator_input_startTime>
+
+
+|controlsMixer nomix <?> # [] no controls mixing uiuc_aircraft.h
+
+
+mass Weight <Weight> # [lb] gross takeoff weight uiuc_aircraft.h
+mass Mass <Mass> # [slug] gross takeoff mass ls_generic.h
+mass I_xx <I_xx> # [slug-ft^2] roll inertia ls_generic.h
+mass I_yy <I_yy> # [slug-ft^2] pitch inertia ls_generic.h
+mass I_zz <I_zz> # [slug-ft^2] yaw inertia ls_generic.h
+mass I_xz <I_xz> # [slug-ft^2] lateral cross inertia ls_generic.h
+
+
+# maximum and minimum engine thrust [lb] uiuc_aircraft.h
+|engine thrust <thrustMax> <thrustMin>
+
+# simple single engine maximum thrust [lb] uiuc_aircraft.h
+engine simpleSingle <simpleSingleMaxThrust>
+
+engine c172 # use Cessna 172 engine model of Tony Peden
+engine cherokee # use Piper Cherokee engine model
+
+
+CL CLo <CLo> # [] lift coef for all angles = 0 uiuc_aircraft.h
+CL CL_a <CL_a> # [/rad] lift curve slope, d(CL)/d(alpha) uiuc_aircraft.h
+CL CL_adot <CL_adot> # [/rad] d(CL)/d(alpha)/da(time) uiuc_aircraft.h
+CL CL_q <CL_q> # [/rad] d(CL)/d(q) uiuc_aircraft.h
+CL CL_ih <CL_ih> # [/rad] CL due to horiz tail incidence uiuc_aircraft.h
+CL CL_de <CL_de> # [/rad] d(CL)/d(de) uiuc_aircraft.h
+
+# CL(alpha), conversion for CL, for alpha [] uiuc_aircraft.h
+CL CLfa <CLfa.dat> <token_value_convert1> <token_value_convert2>
+
+# CL(alpha,delta_e), conversion for CL, for alpha, for delta_e [] uiuc_aircraft.h
+CL CLfade <CLfade.dat> <token_value_convert1> <token_value_convert2> ->
+ <token_value_convert3>
+
+ # the following are lift coefficients in the body axis
+CL CZo <CZo> # [] lift coef for all angles = 0 uiuc_aircraft.h
+CL CZ_a <Cz_a> # [/rad] lift curve slope, d(CZ)/d(alpha) uiuc_aircraft.h
+CL CZ_a2 <CZ_a2> # [/rad] d(CZ)/d(alpha squared) uiuc_aircraft.h
+CL CZ_a3 <CZ_a3> # [/rad] d(CZ)/d(alpha cubed) uiuc_aircraft.h
+CL CZ_adot <CZ_adot> # [/rad] d(CZ)/d(alpha)/d(time) uiuc_aircraft.h
+CL CZ_q <CZ_q> # [/rad] d(CZ)/d(q) uiuc_aircraft.h
+CL CZ_de <CZ_de> # [/rad] d(CZ)/d(de) uiuc_aircraft.h
+CL CZ_deb2 <CZ_deb2> # [/rad] d(CZ)/d(de, beta squared) uiuc_aircraft.h
+CL CZ_df <CZ_df> # [/rad] d(CZ)/d(df) uiuc_aircraft.h
+CL CZ_adf <CZ_adf> # [/rad] d(CZ)/d(alpha, df) uiuc_aircraft.h
+
+|CL CLfCT <CLfCT.dat> # CL(thrust coef) uiuc_aircraft.h
+|CL CLfRe # CL(Reynolds #), equation uiuc_aircraft.h
+|CL CL_afaM <CL_afaM.dat> # CL_alpha(alpha,Mach #) uiuc_aircraft.h
+ # these are sample examples that might be used in later versions of the code
+
+
+# note that CD terms must come after CL for induced drag to be computed
+CD CDo <CDo> # [] drag coef for all angles = 0 uiuc_aircraft.h
+CD CDK <CDK> # [] induced drag constant 1/(pi*e*AR) uiuc_aircraft.h
+CD CD_a <CD_a> # [/rad] d(CD)/d(alpha) uiuc_aircraft.h
+CD CD_ih <CD_ih> # [/rad] CD due to horiz tail incidence uiuc_aircraft.h
+CD CD_de <CD_de> # [/rad] d(CD)/d(delta_e) uiuc_aircraft.h
+
+# CD(alpha), conversion for CD, for alpha [] uiuc_aircraft.h
+CD CDfa <CDfa.dat> <token_value_convert1> <token_value_convert2>
+
+# CD(CL) drag polar, conversion for CD, for CL [] uiuc_aircraft.h
+CD CDfCL <CDfCL.dat> <token_value_convert1> <token_value_convert2>
+
+# CD(alpha,delta_e), conversion for CD, for alpha, for delta_e [] uiuc_aircraft.h
+CD CDfade <CDfade.dat> <token_value_convert1> <token_value_convert2> ->
+ <token_value_convert3>
+
+ # the following are drag coefficients in the body axis
+CD CXo <CXo> # [] drag coef for all angles = 0 uiuc_aircraft.h
+CD CXK <CXK> # [] induced drag constant 1/(pi*e*AR) uiuc_aircraft.h
+CD CX_a <CX_a> # [/rad] d(CX)/d(alpha) uiuc_aircraft.h
+CD CX_a2 <CX_a2> # [/rad] d(CX)/d(alpha squared) uiuc_aircraft.h
+CD CX_a3 <CX_a3> # [/rad] d(CX)/d(alpha cubed) uiuc_aircraft.h
+CD CX_q <CX_q> # [/rad] d(CX)/d(q) uiuc_aircraft.h
+CD CX_de <CX_de> # [/rad] d(CX)/d(de) uiuc_aircraft.h
+CD CX_dr <CX_dr> # [/rad] d(CX)/d(dr) uiuc_aircraft.h
+CD CX_df <CX_df> # [/rad] d(CX)/d(df) uiuc_aircraft.h
+CD CX_adf <CX_adf> # [/rad] d(CX)/d(alpha, df) uiuc_aircraft.h
+
+
+Cm Cmo <Cmo> # [] pitch mom coef for all angles=0 uiuc_aircraft.h
+Cm Cm_a <Cm_a> # [/rad] d(Cm)/d(alpha) uiuc_aircraft.h
+Cm Cm_a2 <Cm_a2> # [/rad] d(Cm)/d(alpha squared) uiuc_aircraft.h
+Cm Cm_adot <Cm_adot> # [/rad] d(Cm)/d(alpha)/d(time) uiuc_aircraft.h
+Cm Cm_q <Cm_q> # [/rad] d(Cm)/d(q) uiuc_aircraft.h
+Cm Cm_ih <Cm_ih> # [/rad] Cm due to horiz tail incidence uiuc_aircraft.h
+Cm Cm_de <Cm_de> # [/rad] d(Cm)/d(de) uiuc_aircraft.h
+Cm Cm_de <Cm_b2> # [/rad] d(Cm)/d(beta squared) uiuc_aircraft.h
+Cm Cm_r <Cm_r> # [/rad] d(Cm)/d(r) uiuc_aircraft.h
+Cm Cm_df <Cm_df> # [/rad] d(Cm)/d(df) uiuc_aircraft.h
+
+# Cm(alpha), conversion for Cm, for alpha [] uiuc_aircraft.h
+Cm Cmfa <Cmfa.dat> <token_value_convert1> <token_value_convert2>
+
+# Cm(alpha,delta_e), conversion for Cm, for alpha, for delta_e [] uiuc_aircraft.h
+Cm Cmfade <Cmfade.dat> <token_value_convert1> <token_value_convert2> ->
+ <token_value_convert3>
+
+
+CY CYo <CYo> # [] side-force coef for all angles=0 uiuc_aircraft.h
+CY CY_beta <CY_beta> # [/rad] d(CY)/d(beta) uiuc_aircraft.h
+CY CY_p <CY_p> # [/rad] d(CY)/d(p) uiuc_aircraft.h
+CY CY_r <CY_r> # [/rad] d(CY)/d(r) uiuc_aircraft.h
+CY CY_da <CY_da> # [/rad] d(CY)/d(da) uiuc_aircraft.h
+CY CY_dr <CY_dr> # [/rad] d(CY)/d(dr) uiuc_aircraft.h
+CY CY_dra <CY_dra> # [/rad] d(CY)/d(dr, alpha) uiuc_aircraft.h
+CY CY_dra <CY_bdot> # [/rad] d(CY)/d(beta)/d(time) uiuc_aircraft.h
+
+# CY(alpha,delta_a), conversion for CY, for alpha, for delta_a [] uiuc_aircraft.h
+CY CYfada <CYfada.dat> <token_value_convert1> <token_value_convert2> ->
+ <token_value_convert3>
+
+# CY(beta,delta_r), conversion for CY, for beta, for delta_r [] uiuc_aircraft.h
+CY CYfbetadr <CYfbetadr.dat> <token_value_convert1> <token_value_convert2> ->
+ <token_value_convert3>
+
+
+Cl Clo <Clo> # [] roll mom coef for all angles=0 uiuc_aircraft.h
+Cl Cl_beta <Cl_beta> # [/rad] d(Cl)/d(beta) uiuc_aircraft.h
+Cl Cl_p <Cl_p> # [/rad] d(Cl)/d(p) uiuc_aircraft.h
+Cl Cl_r <Cl_r> # [/rad] d(Cl)/d(r) uiuc_aircraft.h
+Cl Cl_da <Cl_da> # [/rad] d(Cl)/d(da) uiuc_aircraft.h
+Cl Cl_dr <Cl_dr> # [/rad] d(Cl)/d(dr) uiuc_aircraft.h
+Cl Cl_daa <Cl_daa> # [/rad] d(Cl)/d(da, alpha) uiuc_aircraft.h
+
+# Cl(alpha,delta_a), conversion for Cl, for alpha, for delta_a [] uiuc_aircraft.h
+Cl Clfada <CYfada.dat> <token_value_convert1> <token_value_convert2> ->
+ <token_value_convert3>
+
+# Cl(beta,delta_r), conversion for Cl, for beta, for delta_r [] uiuc_aircraft.h
+Cl Clfbetadr <CYfbetadr.dat> <token_value_convert1> <token_value_convert2> ->
+ <token_value_convert3>
+
+
+Cn Cno <Cno> # [] yaw mom coef for all angles=0 uiuc_aircraft.h
+Cn Cn_beta <Cn_beta> # [/rad] d(Cn)/d(beta) uiuc_aircraft.h
+Cn Cn_p <Cn_p> # [/rad] d(Cn)/d(p) uiuc_aircraft.h
+Cn Cn_r <Cn_r> # [/rad] d(Cn)/d(r) uiuc_aircraft.h
+Cn Cn_da <Cn_da> # [/rad] d(Cn)/d(da) uiuc_aircraft.h
+Cn Cn_dr <Cn_dr> # [/rad] d(Cn)/d(dr) uiuc_aircraft.h
+Cn Cn_q <Cn_q> # [/rad] d(Cn)/d(q) uiuc_aircraft.h
+Cn Cn_b3 <Cn_b3> # [/rad] d(Cn)/d(beta cubed) uiuc_aircraft.h
+
+# Cn(alpha,delta_a), conversion for Cn, for alpha, for delta_a [] uiuc_aircraft.h
+Cn Cnfada <Cnfada.dat> <token_value_convert1> <token_value_convert2> ->
+ <token_value_convert3>
+
+# Cn(beta,delta_r), conversion for Cn, for beta, for delta_r [] uiuc_aircraft.h
+Cn Cnfbetadr <Cnfbetadr.dat> <token_value_convert1> <token_value_convert2> ->
+ <token_value_convert3>
+
+=============================CONVERSION CODES================================
+
+To calculate the aero forces, angles (eg, alfa, beta, elevator deflection, etc)
+must be in radians. To convert input data in degree to radian, use a
+conversion code of 1. To use no conversion, use a conversion code of 0.
+
+------------------------------------------------
+convert1/2/3 Action
+------------------------------------------------
+ 0 no conversion (multiply by 1)
+ 1 convert degrees to radians
+=============================================================================
+
+|gear kgear <kgear> # [] gear spring constant(s) uiuc_aircraft.h
+|gear muRoll <muRoll> # [] gear rolling friction coef(s) uiuc_aircraft.h
+|gear cgear <cgear> # [] gear damping constant(s) uiuc_aircraft.h
+|gear strutLength <sL> # [ft] gear strut length uiuc_aircraft.h
+
+
+ice iceTime <iceTime> # [s] time when icing begins uiuc_aircraft.h
+
+# [s] period for eta_ice to reach eta_final uiuc_aircraft.h
+ice transientTime <transientTime>
+
+# [] icing severity factor uiuc_aircraft.h
+ice eta_ice_final <eta_ice_final>
+
+ice kCDo <kCDo> # [] icing constant for CDo uiuc_aircraft.h
+ice kCDK <kCDo> # [] icing constant for CDK uiuc_aircraft.h
+ice kCD_a <kCD_a> # [] icing constant for CD_a uiuc_aircraft.h
+ice kCD_q <kCD_q> # [] icing constant for CD_q uiuc_aircraft.h
+ice kCD_de <kCD_de> # [] icing constant for CD_de uiuc_aircraft.h
+ice kCD_dr <kCD_dr> # [] icing constant for CD_dr uiuc_aircraft.h
+ice kCD_df <kCD_df> # [] icing constant for CD_df uiuc_aircraft.h
+ice kCD_adf <kCD_adf> # [] icing constant for CD_adf uiuc_aircraft.h
+
+ice kCXo <kCXo> # [] icing constant for CXo uiuc_aircraft.h
+ice kCXK <kCXo> # [] icing constant for CXK uiuc_aircraft.h
+ice kCX_a <kCX_a> # [] icing constant for CX_a uiuc_aircraft.h
+ice kCX_a2 <kCX_a2> # [] icing constant for CX_a2 uiuc_aircraft.h
+ice kCX_a3 <kCX_a3> # [] icing constant for CX_a3 uiuc_aircraft.h
+ice kCX_q <kCX_q> # [] icing constant for CX_q uiuc_aircraft.h
+ice kCX_de <kCX_de> # [] icing constant for CX_de uiuc_aircraft.h
+ice kCX_dr <kCX_dr> # [] icing constant for CX_dr uiuc_aircraft.h
+ice kCX_df <kCX_df> # [] icing constant for CX_df uiuc_aircraft.h
+ice kCX_adf <kCX_adf> # [] icing constant for CX_adf uiuc_aircraft.h
+
+ice kCLo <kCLo> # [] icing constant for CLo uiuc_aircraft.h
+ice kCL_a <kCL_a> # [] icing constant for CL_a uiuc_aircraft.h
+ice kCL_adot <kCL_adot> # [] icing constant for CL_adot uiuc_aircraft.h
+ice kCL_q <kCL_q> # [] icing constant for CL_q uiuc_aircraft.h
+ice kCL_de <kCL_de> # [] icing constant for CL_de uiuc_aircraft.h
+ice kCL_df <kCL_df> # [] icing constant for CL_df uiuc_aircraft.h
+ice kCL_adf <kCL_adf> # [] icing constant for CL_adf uiuc_aircraft.h
+
+ice kCZo <kCZo> # [] icing constant for CZo uiuc_aircraft.h
+ice kCZ_a <kCZ_a> # [] icing constant for CZ_a uiuc_aircraft.h
+ice kCZ_a2 <kCZ_a2> # [] icing constant for CZ_a2 uiuc_aircraft.h
+ice kCZ_a3 <kCZ_a3> # [] icing constant for CZ_a3 uiuc_aircraft.h
+ice kCZ_adot <kCZ_adot> # [] icing constant for CZ_adot uiuc_aircraft.h
+ice kCZ_q <kCZ_q> # [] icing constant for CZ_q uiuc_aircraft.h
+ice kCZ_de <kCZ_de> # [] icing constant for CZ_de uiuc_aircraft.h
+ice kCZ_df <kCZ_df> # [] icing constant for CZ_df uiuc_aircraft.h
+ice kCZ_adf <kCZ_adf> # [] icing constant for CZ_adf uiuc_aircraft.h
+ice kCZ_deb2 <kCZ_deb2> # [] icing constant for CZ_deb2 uiuc_aircraft.h
+
+ice kCmo <kCmo> # [] icing constant for Cmo uiuc_aircraft.h
+ice kCm_a <kCm_a> # [] icing constant for Cm_a uiuc_aircraft.h
+ice kCm_a2 <kCm_a2> # [] icing constant for Cm_a2 uiuc_aircraft.h
+ice kCm_a3 <kCm_a3> # [] icing constant for Cm_a3 uiuc_aircraft.h
+ice kCm_adot <kCm_adot> # [] icing constant for Cm_adot uiuc_aircraft.h
+ice kCm_q <kCm_q> # [] icing constant for Cm_q uiuc_aircraft.h
+ice kCm_r <kCm_r> # [] icing constant for Cm_r uiuc_aircraft.h
+ice kCm_de <kCm_de> # [] icing constant for Cm_de uiuc_aircraft.h
+ice kCm_df <kCm_df> # [] icing constant for Cm_df uiuc_aircraft.h
+
+ice kCYo <kCYo> # [] icing constant for CYo uiuc_aircraft.h
+ice kCY_beta <kCy_beta> # [] icing constant for CY_beta uiuc_aircraft.h
+ice kCY_p <kCY_p> # [] icing constant for CY_p uiuc_aircraft.h
+ice kCY_r <kCY_r> # [] icing constant for CY_r uiuc_aircraft.h
+ice kCY_da <kCY_da> # [] icing constant for CY_da uiuc_aircraft.h
+ice kCY_dr <kCY_dr> # [] icing constant for CY_dr uiuc_aircraft.h
+ice kCY_dra <kCY_dra> # [] icing constant for CY_dra uiuc_aircraft.h
+ice kCY_bdot <kCY_bdot> # [] icing constant for CY_bdot uiuc_aircraft.h
+
+ice kClo <kClo> # [] icing constant for Clo uiuc_aircraft.h
+ice kCl_beta <kCl_beta> # [] icing constant for Cl_beta uiuc_aircraft.h
+ice kCl_p <kCl_p> # [] icing constant for Cl_p uiuc_aircraft.h
+ice kCl_r <kCl_r> # [] icing constant for Cl_r uiuc_aircraft.h
+ice kCl_da <kCl_da> # [] icing constant for Cl_da uiuc_aircraft.h
+ice kCl_dr <kCl_dr> # [] icing constant for Cl_dr uiuc_aircraft.h
+ice kCl_daa <kCl_daa> # [] icing constant for Cl_daa uiuc_aircraft.h
+
+ice kCno <kCno> # [] icing constant for Cno uiuc_aircraft.h
+ice kCn_beta <kCn_beta> # [] icing constant for Cn_beta uiuc_aircraft.h
+ice kCn_b3 <kCn_b3> # [] icing constant for Cn_b3 uiuc_aircraft.h
+ice kCn_p <kCn_p> # [] icing constant for Cn_p uiuc_aircraft.h
+ice kCn_q <kCn_q> # [] icing constant for Cn_q uiuc_aircraft.h
+ice kCn_r <kCn_r> # [] icing constant for Cn_r uiuc_aircraft.h
+ice kCn_da <kCn_da> # [] icing constant for Cn_da uiuc_aircraft.h
+ice kCn_dr <kCn_dr> # [] icing constant for Cn_dr uiuc_aircraft.h
+
+ice beta_probe_wing <x_probe_wing> # wing flow angle probe location uiuc_aircraft.h
+ice beta_probe_wing <x_probe_tail> # tail flow angle probe location uiuc_aircraft.h
+
+
+record Simtime # [s] current sim time global
+record dt # [s] current time step global
+record Weight # [lb] aircraft gross takeoff weight uiuc_aircraft.h
+record Mass # [slug] aircraft mass ls_generic.h
+record I_xx # [slug-ft^2] roll inertia ls_generic.h
+record I_yy # [slug-ft^2] pitch inertia ls_generic.h
+record I_zz # [slug-ft^2] yaw inertia ls_generic.h
+record I_xz # [slug-ft^2] lateral cross inertia ls_generic.h
+record Dx_pilot # [ft] reference pilot x-location ls_generic.h
+record Dy_pilot # [ft] reference pilot y-location ls_generic.h
+record Dz_pilot # [ft] reference pilot z-location ls_generic.h
+record Dx_cg # [ft] cg x_location ls_generic.h
+record Dy_cg # [ft] cg y_location ls_generic.h
+record Dz_cg # [ft] cg z_location ls_generic.h
+record Lat_geocentric # [rad] geocentric latitude ls_generic.h
+record Lon_geocentric # [rad] geocentric longitude ls_generic.h
+record Radius_to_vehicle # [ft] geocentric distance ls_generic.h
+record Latitude # [rad] geodetic latitude ls_generic.h
+record Longitude # [rad] geodetic longitude ls_generic.h
+record Altitude # [ft] geodetic altitude ls_generic.h
+record Phi # [rad] Euler bank angle ls_generic.h
+record Theta # [rad] Euler pitch attitude angle ls_generic.h
+record Psi # [rad] Euler heading angle ls_generic.h
+record V_dot_north # [ft/s^2] local x-acceleration ls_generic.h
+record V_dot_east # [ft/s^2] local y-acceleration ls_generic.h
+record V_dot_down # [ft/s^2] local z-acceleration ls_generic.h
+record U_dot_body # [ft/s^2] body x-acceleration ls_generic.h
+record V_dot_body # [ft/s^2] body y-acceleration ls_generic.h
+record W_dot_body # [ft/s^2] body z-acceleration ls_generic.h
+record A_X_pilot # [ft/s^2] pilot x-acceleration ls_generic.h
+record A_Y_pilot # [ft/s^2] pilot y-acceleration ls_generic.h
+record A_Z_pilot # [ft/s^2] pilot z-acceleration ls_generic.h
+record A_X_cg # [ft/s^2] cg x-acceleration ls_generic.h
+record A_Y_cg # [ft/s^2] cg y-acceleration ls_generic.h
+record A_Z_cg # [ft/s^2] cg z-acceleration ls_generic.h
+record N_X_pilot # [ft/s^2] pilot x-acceleration ls_generic.h
+record N_Y_pilot # [ft/s^2] pilot y-acceleration ls_generic.h
+record N_Z_pilot # [ft/s^2] pilot z-acceleration ls_generic.h
+record N_X_cg # [ft/s^2] cg x-acceleration ls_generic.h
+record N_Y_cg # [ft/s^2] cg y-acceleration ls_generic.h
+record N_Z_cg # [ft/s^2] cg z-acceleration ls_generic.h
+record P_dot_body # [rad/s^2] roll rate acceleration ls_generic.h
+record Q_dot_body # [rad/s^2] pitch rate acceleration ls_generic.h
+record R_dot_body # [rad/s^2] yaw rate acceleration ls_generic.h
+record V_north # [ft/s] local x-velocity ls_generic.h
+record V_east # [ft/s] local y-velocity ls_generic.h
+record V_down # [ft/s] local z-velocity ls_generic.h
+record V_north_rel_ground # [ft/s] local x-velocity wrt ground ls_generic.h
+record V_east_rel_ground # [ft/s] local y-velocity wrt ground ls_generic.h
+record V_down_rel_ground # [ft/s] local z-velocity wrt ground ls_generic.h
+record V_north_airmass # [ft/s] local x-velocity of airmass ls_generic.h
+record V_east_airmass # [ft/s] local y-velocity of airmass ls_generic.h
+record V_down_airmass # [ft/s] local z-velocity of airmass ls_generic.h
+record V_north_rel_airmass # [ft/s] local x-velocity wrt airmass ls_generic.h
+record V_east_rel_airmass # [ft/s] local y-velocity wrt airmass ls_generic.h
+record V_down_rel_airmass # [ft/s] local z-velocity wrt airmass ls_generic.h
+record U_gust # [ft/s] local turbulence x-velocity ls_generic.h
+record V_gust # [ft/s] local turbulence y-velocity ls_generic.h
+record W_gust # [ft/s] local turbulence z-velocity ls_generic.h
+record U_body # [ft/s] wind x-velocity in body axis ls_generic.h
+record V_body # [ft/s] wind y-velocity in body axis ls_generic.h
+record W_body # [ft/s] wind z-velocity in body axis ls_generic.h
+record V_rel_wind # [ft/s] total freestream velocity ls_generic.h
+record V_true_kts # [kts] true velocity ls_generic.h
+record V_rel_ground # [ft/s] total velocity wrt ground ls_generic.h
+record V_inertial # [ft/s] total inertial velocity ls_generic.h
+record V_ground_speed # [ft/s] airspeed wrt ground ls_generic.h
+record V_equiv # [ft/s] equivalent airspeed ls_generic.h
+record V_equiv_kts # [kts] equivalent airspeed ls_generic.h
+record V_calibrated # [ft/s] calibrated airspeed ls_generic.h
+record V_calibrated_kts # [kts] calibrated airspeed ls_generic.h
+record P_local # [rad/s] local roll rate ls_generic.h
+record Q_local # [rad/s] local pitch rate ls_generic.h
+record R_local # [rad/s] local yaw rate ls_generic.h
+record P_body # [rad/s] body roll rate ls_generic.h
+record Q_body # [rad/s] body pitch rate ls_generic.h
+record R_body # [rad/s] body yaw rate ls_generic.h
+record P_total # [rad/s] total roll rate ls_generic.h
+record Q_total # [rad/s] total pitch rate ls_generic.h
+record R_total # [rad/s] total yaw rate ls_generic.h
+record Phi_dot # [rad/s] bank angle rate ls_generic.h
+record Theta_dot # [rad/s] pitch attitude angle rate ls_generic.h
+record Psi_dot # [rad/s] heading angle rate ls_generic.h
+record Latitude_dot # [rad/s] latitude rate ls_generic.h
+record Longitude_dot # [rad/s] longitude rate ls_generic.h
+record Radius_dot # [rad/s] radius rate ls_generic.h
+record Alpha # [rad] angle of attack ls_generic.h
+record Alpha_deg # [deg] angle of attack (in degrees) uiuc_aircraft.h
+record Alpha_dot # [rad/s] rate of change of alpha ls_generic.h
+record Alpha_dot_deg # [rad/s] rate of change of alpha uiuc_aircraft.h
+record Beta # [rad] sideslip angle ls_generic.h
+record Beta_deg # [rad] sideslip angle uiuc_aircraft.h
+record Beta_dot # [rad/s] rate of change of beta ls_generic.h
+record Beta_dot_deg # [rad/s] rate of change of beta uiuc_aircraft.h
+record Gamma_vert # [rad] vertical flight path angle ls_generic.h
+record Gamma_vert_deg # [deg] vertical flight path angle uiuc_aircraft.h
+record Gamma_horiz # [rad] horizontal flight path angle ls_generic.h
+record Gamma_horiz_deg # [deg] horizontal flight path angle uiuc_aircraft.h
+record Density # [slug/ft^3] air density ls_generic.h
+record V_sound # [ft/s] speed of sound ls_generic.h
+record Mach_number # [] Mach number ls_generic.h
+record Static_pressure # [lb/ft^2] static pressure ls_generic.h
+record Total_pressure # [lb/ft^2] total pressure ls_generic.h
+record Impact_pressure # [lb/ft^2] impact pressure ls_generic.h
+record Dynamic_pressure # [lb/ft^2] dynamic pressure ls_generic.h
+record Static_temperature # [?] static temperature ls_generic.h
+record Total_temperature # [?] total temperature ls_generic.h
+record Gravity # [ft/s^2] acceleration due to gravity ls_generic.h
+record Sea_level_radius # [ft] Earth radius ls_generic.h
+record Earth_position_angle # [rad] Earth rotation angle ls_generic.h
+record Runway_altitude # [ft] runway altitude ls_generic.h
+record Runway_latitude # [rad] runway latitude ls_generic.h
+record Runway_longitude # [rad] runway longititude ls_generic.h
+record Runway_heading # [rad] runway heading ls_generic.h
+record Radius_to_rwy # [ft] geocentric radius to runway ls_generic.h
+record D_pilot_north_of_rwy # [ft] local pilot x-dist from rwy ls_generic.h
+record D_pilot_east_of_rwy # [ft] local pilot y-dist from rwy ls_generic.h
+record D_pilot_down_of_rwy # [ft] local pilot z-dist from rwy ls_generic.h
+record X_pilot_rwy # [ft] pilot x-dist from rwy ls_generic.h
+record Y_pilot_rwy # [ft] pilot y-dist from rwy ls_generic.h
+record H_pilot_rwy # [ft] pilot z-dist from rwy ls_generic.h
+record D_cg_north_of_rwy # [ft] local cg x-dist from rwy ls_generic.h
+record D_cg_east_of_rwy # [ft] local cg y-dist from rwy ls_generic.h
+record D_cg_down_of_rwy # [ft] local cg z-dist from rwy ls_generic.h
+record X_cg_rwy # [ft] cg x-dist from rwy ls_generic.h
+record Y_cg_rwy # [ft] cg y-dist from rwy ls_generic.h
+record H_cg_rwy # [ft] cg z-dist from rwy ls_generic.h
+record Throttle_pct # [%] throttle input ls_cockpit.h
+record Throttle_3 # [%] throttle deflection ls_cockpit.h
+record Long_control # [] pitch input ls_cockpit.h
+record Long_trim # [rad] longitudinal trim ls_cockpit.h
+record Long_trim_deg # [deg] longitudinal trim uiuc_aircraft.h
+record elevator # [rad] elevator deflection uiuc_aircraft.h
+record elevator_deg # [deg] elevator deflection uiuc_aircraft.h
+record Lat_control # [] roll input ls_cockpit.h
+record aileron # [rad] aileron deflection uiuc_aircraft.h
+record aileron_deg # [deg] aileron deflection uiuc_aircraft.h
+record Rudder_pedal # [] yaw input ls_cockpit.h
+record rudder # [rad] rudder deflection uiuc_aircraft.h
+record rudder_deg # [deg] rudder deflection uiuc_aircraft.h
+record CDfaI # [] CD(alpha) uiuc_aircraft.h
+record CDfCLI # [] CD(CL), drag polar uiuc_aircraft.h
+record CDfadeI # [] CD(alpha,delta_e) uiuc_aircraft.h
+record CD # [] drag coefficient uiuc_aircraft.h
+record CLfaI # [] CL(alpha) uiuc_aircraft.h
+record CLfadeI # [] CL(alpha,delta_e) uiuc_aircraft.h
+record CL # [] lift coefficient uiuc_aircraft.h
+record CmfaI # [] Cm(alpha) uiuc_aircraft.h
+record CmfadeI # [] Cm(alpha,delta_e) uiuc_aircraft.h
+record Cm # [] pitch moment coefficient uiuc_aircraft.h
+record CYfadaI # [] CY(alpha,delta_a) uiuc_aircraft.h
+record CYfbetadrI # [] CY(beta,delta_r) uiuc_aircraft.h
+record CY # [] side-force coefficient uiuc_aircraft.h
+record ClfadaI # [] Cl(alpha,delta_a) uiuc_aircraft.h
+record ClfbetadrI # [] Cl(beta,delta_r) uiuc_aircraft.h
+record Cl # [] roll moment coefficient uiuc_aircraft.h
+record CnfadaI # [] Cn(alpha,delta_a) uiuc_aircraft.h
+record CnfbetadrI # [] Cn(beta,delta_r) uiuc_aircraft.h
+record Cn # [] yaw moment coefficient uiuc_aircraft.h
+record CLclean_wing # [] wing clean lift coefficient uiuc_aircraft.h
+record CLiced_wing # [] wing iced lift coefficient uiuc_aircraft.h
+record CLclean_tail # [] tail clean lift coefficient uiuc_aircraft.h
+record CLiced_tail # [] tail iced lift coefficient uiuc_aircraft.h
+record Lift_clean_wing # [lb] wing clean lift force uiuc_aircraft.h
+record Lift_iced_wing # [lb] wing iced lift force uiuc_aircraft.h
+record Lift_clean_tail # [lb] tail clean lift force uiuc_aircraft.h
+record Lift_iced_tail # [lb] tail iced lift force uiuc_aircraft.h
+record Gamma_clean_wing # [ft^2/s] wing clean circulation uiuc_aircraft.h
+record Gamma_iced_wing # [ft^2/s] wing iced circulation uiuc_aircraft.h
+record Gamma_clean_tail # [ft^2/s] tail clean circulation uiuc_aircraft.h
+record Gamma_iced_tail # [ft^2/s] tail iced circulation uiuc_aircraft.h
+record w_clean_wing # [ft/s] wing clean downwash uiuc_aircraft.h
+record w_iced_wing # [ft/s] wing iced downwash uiuc_aircraft.h
+record w_clean_tail # [ft/s] tail clean downwash uiuc_aircraft.h
+record w_iced_tail # [ft/s] tail iced downwash uiuc_aircraft.h
+record V_total_clean_wing # [ft/s] wing clean velocity uiuc_aircraft.h
+record V_total_iced_wing # [ft/s] wing iced velocity uiuc_aircraft.h
+record V_total_clean_tail # [ft/s] tail clean velocity uiuc_aircraft.h
+record V_total_iced_tail # [ft/s] tail iced velocity uiuc_aircraft.h
+record beta_flow_clean_wing # [rad] wing clean flow angle uiuc_aircraft.h
+record beta_flow_clean_wing_deg # [deg] wing clean flow angle uiuc_aircraft.h
+record beta_flow_iced_wing # [rad] wing iced flow angle uiuc_aircraft.h
+record beta_flow_iced_wing_deg # [deg] wing iced flow angle uiuc_aircraft.h
+record beta_flow_clean_tail # [rad] tail clean flow angle uiuc_aircraft.h
+record beta_flow_clean_tail_deg # [deg] tail clean flow angle uiuc_aircraft.h
+record beta_flow_iced_tail # [rad] tail iced flow angle uiuc_aircraft.h
+record beta_flow_iced_tail_deg # [deg] tail iced flow angle uiuc_aircraft.h
+record Dbeta_flow_wing # [rad] difference in wing flow angle uiuc_aircraft.h
+record Dbeta_flow_wing_deg # [deg] difference in wing flow angle uiuc_aircraft.h
+record Dbeta_flow_tail # [rad] difference in tail flow angle uiuc_aircraft.h
+record Dbeta_flow_tail_deg # [deg] difference in tail flow angle uiuc_aircraft.h
+record pct_beta_flow_wing # [%] difference in wing flow angle uiuc_aircraft.h
+record pct_beta_flow_tail # [%] difference in tail flow angle uiuc_aircraft.h
+record F_X_wind # [lb] aero x-force in wind-axes ls_generic.h
+record F_Y_wind # [lb] aero y-force in wind-axes ls_generic.h
+record F_Z_wind # [lb] aero z-force in wind-axes ls_generic.h
+record F_X_aero # [lb] aero x-force in body-axes ls_generic.h
+record F_Y_aero # [lb] aero y-force in body-axes ls_generic.h
+record F_Z_aero # [lb] aero z-force in body-axes ls_generic.h
+record F_X_engine # [lb] prop x-force in body-axes ls_generic.h
+record F_Y_engine # [lb] prop y-force in body-axes ls_generic.h
+record F_Z_engine # [lb] prop z-force in body-axes ls_generic.h
+record F_X_gear # [lb] gear x-force in body-axes ls_generic.h
+record F_Y_gear # [lb] gear y-force in body-axes ls_generic.h
+record F_Z_gear # [lb] gear z-force in body-axes ls_generic.h
+record F_X # [lb] total x-force in body-axes ls_generic.h
+record F_Y # [lb] total y-force in body-axes ls_generic.h
+record F_Z # [lb] total z-force in body-axes ls_generic.h
+record F_nort # [lb] total x-force in local-axes ls_generic.h
+record F_east # [lb] total y-force in local-axes ls_generic.h
+record F_down # [lb] total z-force in local-axes ls_generic.h
+record M_l_aero # [ft-lb] aero roll mom in body axes ls_generic.h
+record M_m_aero # [ft-lb] aero pitch mom in body axes ls_generic.h
+record M_n_aero # [ft-lb] aero yaw mom in body axes ls_generic.h
+record M_l_engine # [ft-lb] prop roll mom in body axes ls_generic.h
+record M_m_engine # [ft-lb] prop pitch mom in body axes ls_generic.h
+record M_n_engine # [ft-lb] prop yaw mom in body axes ls_generic.h
+record M_l_gear # [ft-lb] gear roll mom in body axes ls_generic.h
+record M_m_gear # [ft-lb] gear pitch mom in body axes ls_generic.h
+record M_n_gear # [ft-lb] gear yaw mom in body axes ls_generic.h
+record M_l_rp # [ft-lb] total roll mom in body axes ls_generic.h
+record M_m_rp # [ft-lb] total pitch mom in body axes ls_generic.h
+record M_n_rp # [ft-lb] total yaw mom in body axes ls_generic.h
+
+
+# the following command is implemented but the data is not used in any
+# equation of motion
+# hinge moment coefficient [] uiuc_aircraft.h
+|misc simpleHingeMomentCoef <simpleHingeMomentCoef>
+
+**********************************************************************
+
+**********************************************************************
+V. Mandatory Input:
+
+The following data is required for the simulator to function;
+otherwise either the UIUC Aero Model or LaRCsim parts of the code will
+probably crash.
+
+1) aircraft geometry (UIUC Aero Model)
+bw wingspan [ft]
+cbar mean aerodynamic chord [ft]
+Sw wing planform area [ft^2]
+
+2) engine properties (UIUC Engine Model)
+(some engine model must be specified, such as...)
+engine simpleSingle
+ <or>
+engine c172
+
+3) mass variables (LaRCsim)
+Weight aircraft gross takeoff weight [lb]
+ <or>
+Mass aircraft mass [slug]
+I_xx roll inertia [slug-ft^2]
+I_yy pitch inertia [slug-ft^2]
+I_zz yaw inertia [slug-ft^2]
+I_xz lateral cross inertia [slug-ft^2]
+
+4) aerodynamic force/moment components (Aero Model)
+CLo lift coef for all angles = 0 []
+CL_a lift curve slope, d(CL)/d(alpha) [/rad]
+CDo drag coef for all angles = 0 []
+CDK induced drag constant []
+ <or>
+CD_a d(CD)/d(alpha) [/rad]
+Cmo pitch mom coef for all angles=0 []
+Cm_a d(Cm)/d(alpha) [/rad]
+CY_beta d(CY)/d(beta) [/rad]
+Cl_beta d(Cl)/d(beta) [/rad]
+Cn_beta d(Cn)/d(beta) [/rad]
+
+5) gear properties (none yet)
+
+With the current version, the C172 model gear model is used for *ALL*
+aircraft. This can produce some interesting effects with heavy
+aircraft (eg, Convair model), and light aircraft (eg, Pioneer UAV)
+
+**********************************************************************
+
noinst_LIBRARIES = libUIUCModel.a
libUIUCModel_a_SOURCES = \
- uiuc_1DdataFileReader.h \
- uiuc_1DdataFileReader.cpp \
- uiuc_1Dinterpolation.h \
- uiuc_1Dinterpolation.cpp \
- uiuc_2DdataFileReader.h \
- uiuc_2DdataFileReader.cpp \
- uiuc_2Dinterpolation.h \
- uiuc_2Dinterpolation.cpp \
- uiuc_aerodeflections.h \
- uiuc_aerodeflections.cpp \
- uiuc_aircraft.h \
- uiuc_aircraftdir.h \
- uiuc_coefficients.h \
- uiuc_coefficients.cpp \
- uiuc_convert.h \
- uiuc_convert.cpp \
- uiuc_engine.h\
- uiuc_engine.cpp\
- uiuc_ice.h \
- uiuc_ice.cpp \
- uiuc_initializemaps.h \
- uiuc_initializemaps.cpp \
- uiuc_initializemaps1.cpp \
- uiuc_initializemaps2.cpp \
- uiuc_initializemaps3.cpp \
- uiuc_initializemaps4.cpp \
- uiuc_menu.h \
- uiuc_menu.cpp \
- uiuc_parsefile.h \
- uiuc_parsefile.cpp \
- uiuc_recorder.h \
- uiuc_recorder.cpp \
- uiuc_warnings_errors.h \
- uiuc_warnings_errors.cpp \
- uiuc_wrapper.h \
- uiuc_wrapper.cpp
-
-INCLUDES += -I$(top_builddir)
+ uiuc_1DdataFileReader.cpp \
+ uiuc_1Dinterpolation.cpp \
+ uiuc_2DdataFileReader.cpp \
+ uiuc_2Dinterpolation.cpp \
+ uiuc_aerodeflections.cpp \
+ uiuc_betaprobe.cpp \
+ uiuc_coefficients.cpp \
+ uiuc_coef_drag.cpp \
+ uiuc_coef_lift.cpp \
+ uiuc_coef_pitch.cpp \
+ uiuc_coef_sideforce.cpp \
+ uiuc_coef_roll.cpp \
+ uiuc_coef_yaw.cpp \
+ uiuc_controlInput.cpp \
+ uiuc_convert.cpp \
+ uiuc_engine.cpp\
+ uiuc_ice.cpp \
+ uiuc_initializemaps.cpp \
+ uiuc_map_CD.cpp \
+ uiuc_map_CL.cpp \
+ uiuc_map_Cm.cpp \
+ uiuc_map_Cn.cpp \
+ uiuc_map_controlSurface.cpp \
+ uiuc_map_Croll.cpp \
+ uiuc_map_CY.cpp \
+ uiuc_map_engine.cpp \
+ uiuc_map_geometry.cpp \
+ uiuc_map_ice.cpp \
+ uiuc_map_init.cpp \
+ uiuc_map_keyword.cpp \
+ uiuc_map_mass.cpp \
+ uiuc_map_misc.cpp \
+ uiuc_map_record1.cpp \
+ uiuc_map_record2.cpp \
+ uiuc_map_record3.cpp \
+ uiuc_map_record4.cpp \
+ uiuc_map_record5.cpp \
+ uiuc_menu.cpp \
+ uiuc_parsefile.cpp \
+ uiuc_recorder.cpp \
+ uiuc_warnings_errors.cpp \
+ uiuc_wrapper.cpp \
+INCLUDES += -I$(top_builddir)
#include "uiuc_1DdataFileReader.h"
int
-uiuc_1DdataFileReader( string file_name, double convert_x, double convert_y,
- double x[100], double y[100], int &xmax )
+uiuc_1DdataFileReader( string file_name,
+ double x[100], double y[100], int &xmax )
{
ParseFile *matrix;
#ifndef _1D_DATA_FILE_READER_H_
#define _1D_DATA_FILE_READER_H_
-#include <simgear/compiler.h>
-
-#include STL_STRSTREAM
+#include <strstream.h>
#include "uiuc_parsefile.h"
#include "uiuc_aircraft.h"
-FG_USING_NAMESPACE(std);
int uiuc_1DdataFileReader( string file_name,
- double convert_x,
- double convert_y,
- double x[100],
- double y[100],
- int &xmax );
+ double x[100],
+ double y[100],
+ int &xmax );
#endif // _1D_DATA_FILE_READER_H_
DESCRIPTION: reads in the yData and xData arrays and the value of x
to be interpolated on; performs 1D interpolation,
- i.e. y=f(x)
+ i.e. y=f(x)
----------------------------------------------------------------------
REFERENCES: syntax based on interp function in c172_aero.c
mathematics based on linear interpolation functions
- found in
- Kreyszig, Erwin. Advanced Engineering Mathematics,
- 7th ed. NY: John Wiley & Sons, 1993.
+ found in
+ Kreyszig, Erwin. Advanced Engineering Mathematics,
+ 7th ed. NY: John Wiley & Sons, 1993.
----------------------------------------------------------------------
else //x between xmax and x min
{
/*loop increases i until x is less than a known x,
- e.g. Alpha from LaRCsim less than Alpha given in
- tabulated data; once this value is found, i becomes
- the upper bound and i-1 the lower bound*/
+ e.g. Alpha from LaRCsim less than Alpha given in
+ tabulated data; once this value is found, i becomes
+ the upper bound and i-1 the lower bound*/
while (xData[i] <= x) //bracket upper bound
- {
- i++;
- }
+ {
+ i++;
+ }
x2 = xData[i]; //set upper bounds
y2 = yData[i];
x1 = xData[i-1]; //set lower bounds
#ifndef _1D_INTERPOLATION_H_
#define _1D_INTERPOLATION_H_
-double uiuc_1Dinterpolation( double xData[100], double yData[100], int xmax, double x );
+double uiuc_1Dinterpolation( double xData[100],
+ double yData[100],
+ int xmax,
+ double x );
#endif // _1D_INTERPOLATION_H_
#include "uiuc_2DdataFileReader.h"
-int uiuc_2DdataFileReader( string file_name,
- double convert_x,
- double convert_y,
- double convert_z,
- double x[100][100],
- double y[100],
- double z[100][100],
- int xmax[100],
- int &ymax)
+void uiuc_2DdataFileReader( string file_name,
+ double x[100][100],
+ double y[100],
+ double z[100][100],
+ int xmax[100],
+ int &ymax)
{
ParseFile *matrix;
double token_value1;
double token_value2;
- int counter_y = 1, counter_x = 1, data = 0;
+ int counter_y = 1, counter_x = 1;
string linetoken1;
string linetoken2;
counter_x++;
}
}
- data = 1;
- return data;
+ return;
}
// end uiuc_2DdataFileReader.cpp
#ifndef _2D_DATA_FILE_READER_H_
#define _2D_DATA_FILE_READER_H_
-#include <simgear/compiler.h>
-
-#include STL_STRSTREAM
+#include <strstream.h>
#include "uiuc_parsefile.h"
#include "uiuc_aircraft.h"
-FG_USING_NAMESPACE(std);
-
-int
-uiuc_2DdataFileReader( string file_name, double convert_x, double convert_y, double convert_z,
- double x[100][100], double y[100], double z[100][100], int xmax[100],
- int &ymax);
+void uiuc_2DdataFileReader( string file_name,
+ double x[100][100],
+ double y[100],
+ double z[100][100],
+ int xmax[100],
+ int &ymax);
#endif // _2D_DATA_FILE_READER_H_
#ifndef _2D_INTERPOLATION_H_
#define _2D_INTERPOLATION_H_
-double
-uiuc_2Dinterpolation( double xData[100][100], double yData[100], double zData[100][100],
- int xmax[100], int ymax, double x, double y );
+double uiuc_2Dinterpolation( double xData[100][100],
+ double yData[100],
+ double zData[100][100],
+ int xmax[100],
+ int ymax,
+ double x,
+ double y );
#endif // _2D_INTERPOLATION_H_
----------------------------------------------------------------------
HISTORY: 01/30/2000 initial release
+ 04/05/2000 (JS) added zero_Long_trim command
----------------------------------------------------------------------
#include "uiuc_aerodeflections.h"
-void uiuc_aerodeflections()
+void uiuc_aerodeflections( double dt )
{
-
- // for now, consider deflections to be equal
- // damin = damax
- aileron = - Lat_control * damax * DEG_TO_RAD;
-
- // for now, consider deflections to be equal
- // demin = demax
- elevator = Long_control * demax * DEG_TO_RAD + Long_trim;
-
- // for now, consider deflections to be equal
- // drmin = drmax
- rudder = - Rudder_pedal * drmax * DEG_TO_RAD;
+ double prevFlapHandle, flap_transit_rate;
+ bool flaps_in_transit;
+
+ if (zero_Long_trim)
+ {
+ Long_trim = 0;
+ //elevator_tab = 0;
+ }
+
+ if (Lat_control <= 0)
+ aileron = - Lat_control * damin * DEG_TO_RAD;
+ else
+ aileron = - Lat_control * damax * DEG_TO_RAD;
+
+ if ((Long_control+Long_trim) <= 0)
+ elevator = (Long_control + Long_trim) * demax * DEG_TO_RAD + elevator_tab;
+ else
+ elevator = (Long_control + Long_trim) * demin * DEG_TO_RAD + elevator_tab;
+
+ if (Rudder_pedal <= 0)
+ rudder = - Rudder_pedal * drmin * DEG_TO_RAD;
+ else
+ rudder = - Rudder_pedal * drmax * DEG_TO_RAD;
+
+ // flap routine
+ // check for lowest flap setting
+ if (Flap_handle < dfArray[1])
+ {
+ Flap_handle = dfArray[1];
+ prevFlapHandle = Flap_handle;
+ flap = Flap_handle;
+ }
+ // check for highest flap setting
+ else if (Flap_handle > dfArray[ndf])
+ {
+ Flap_handle = dfArray[ndf];
+ prevFlapHandle = Flap_handle;
+ flap = Flap_handle;
+ }
+ // otherwise in between
+ else
+ {
+ if(Flap_handle != prevFlapHandle)
+ {
+ flaps_in_transit = true;
+ }
+ if(flaps_in_transit)
+ {
+ int iflap = 0;
+ while (dfArray[iflap] < Flap_handle)
+ {
+ iflap++;
+ }
+ if (flap < Flap_handle)
+ {
+ if (TimeArray[iflap] > 0)
+ flap_transit_rate = (dfArray[iflap] - dfArray[iflap-1]) / TimeArray[iflap+1];
+ else
+ flap_transit_rate = (dfArray[iflap] - dfArray[iflap-1]) / 5;
+ }
+ else
+ {
+ if (TimeArray[iflap+1] > 0)
+ flap_transit_rate = (dfArray[iflap] - dfArray[iflap+1]) / TimeArray[iflap+1];
+ else
+ flap_transit_rate = (dfArray[iflap] - dfArray[iflap+1]) / 5;
+ }
+ if(fabs (flap - Flap_handle) > dt * flap_transit_rate)
+ flap += flap_transit_rate * dt;
+ else
+ {
+ flaps_in_transit = false;
+ flap = Flap_handle;
+ }
+ }
+ }
+ prevFlapHandle = Flap_handle;
return;
}
-
#ifndef _AERODEFLECTIONS_H_
#define _AERODEFLECTIONS_H_
-#include "uiuc_aircraft.h" /* uses aileron, elevator, rudder */
-#include "../LaRCsim/ls_cockpit.h" /* uses Long_control, Lat_control, Rudder_pedal */
-#include "../LaRCsim/ls_constants.h" /* uses RAD_TO_DEG, DEG_TO_RAD */
+#include "uiuc_aircraft.h" /* aileron, elevator, rudder */
+#include "../LaRCsim/ls_cockpit.h" /* Long_control, Lat_control, Rudder_pedal */
+#include "../LaRCsim/ls_constants.h" /* RAD_TO_DEG, DEG_TO_RAD */
+
-void uiuc_aerodeflections();
+void uiuc_aerodeflections( double dt );
#endif // _AERODEFLECTIONS_H_
functions of alpha and delta_a
03/02/2000 (JS) added record features for 1D and 2D
interpolations
+ 03/29/2000 (JS) added Cmfa interpolation functions
+ and Weight; added misc map
+ 04/01/2000 (JS) added throttle, longitudinal, lateral,
+ and rudder inputs to record map
----------------------------------------------------------------------
#define _AIRCRAFT_H_
#include <simgear/compiler.h>
-
#include <map>
#include <iostream>
#include "uiuc_parsefile.h"
FG_USING_STD(ofstream);
#endif
+
typedef stack :: iterator LIST;
/* Add more keywords here if required*/
enum {init_flag = 1000, geometry_flag, controlSurface_flag, controlsMixer_flag,
mass_flag, engine_flag, CD_flag, CL_flag, Cm_flag, CY_flag, Cl_flag,
- Cn_flag, gear_flag, ice_flag, record_flag};
+ Cn_flag, gear_flag, ice_flag, record_flag, misc_flag};
// init ======= Initial values for equation of motion
enum {Dx_pilot_flag = 2000, Dy_pilot_flag, Dz_pilot_flag,
- Dx_cg_flag, Dy_cg_flag, Dz_cg_flag,
+ Dx_cg_flag, Dy_cg_flag, Dz_cg_flag, Altitude_flag,
V_north_flag, V_east_flag, V_down_flag,
P_body_flag, Q_body_flag, R_body_flag,
- Phi_flag, Theta_flag, Psi_flag};
+ Phi_flag, Theta_flag, Psi_flag,
+ Long_trim_flag, recordRate_flag, recordStartTime_flag,
+ nondim_rate_V_rel_wind_flag, dyn_on_speed_flag};
// geometry === Aircraft-specific geometric quantities
-enum {bw_flag = 3000, cbar_flag, Sw_flag};
+enum {bw_flag = 3000, cbar_flag, Sw_flag, ih_flag, bh_flag, ch_flag, Sh_flag};
// controlSurface = Control surface deflections and properties
-enum {de_flag = 4000, da_flag, dr_flag};
+enum {de_flag = 4000, da_flag, dr_flag,
+ set_Long_trim_flag, set_Long_trim_deg_flag, zero_Long_trim_flag,
+ elevator_step_flag, elevator_singlet_flag, elevator_doublet_flag, elevator_input_flag};
// controlsMixer == Controls mixer
-enum {nomix_flag = 14000};
+enum {nomix_flag = 5000};
//mass ======== Aircraft-specific mass properties
-enum {Mass_flag = 5000, I_xx_flag, I_yy_flag, I_zz_flag, I_xz_flag};
+enum {Weight_flag = 6000, Mass_flag, I_xx_flag, I_yy_flag, I_zz_flag, I_xz_flag};
// engine ===== Propulsion data
-enum {simpleSingle_flag = 6000, c172_flag};
+enum {simpleSingle_flag = 7000, c172_flag, cherokee_flag};
// CD ========= Aerodynamic x-force quantities (longitudinal)
-enum {CDo_flag = 7000, CDK_flag, CD_a_flag, CD_de_flag, CDfa_flag, CDfade_flag};
+enum {CDo_flag = 8000, CDK_flag, CD_a_flag, CD_adot_flag, CD_q_flag, CD_ih_flag, CD_de_flag,
+ CDfa_flag, CDfCL_flag, CDfade_flag, CDfdf_flag, CDfadf_flag,
+ CXo_flag, CXK_flag, CX_a_flag, CX_a2_flag, CX_a3_flag, CX_adot_flag,
+ CX_q_flag, CX_de_flag, CX_dr_flag, CX_df_flag, CX_adf_flag};
// CL ========= Aerodynamic z-force quantities (longitudinal)
-enum {CLo_flag = 8000, CL_a_flag, CL_adot_flag, CL_q_flag, CL_de_flag, CLfa_flag, CLfade_flag};
+enum {CLo_flag = 9000, CL_a_flag, CL_adot_flag, CL_q_flag, CL_ih_flag, CL_de_flag,
+ CLfa_flag, CLfade_flag, CLfdf_flag, CLfadf_flag,
+ CZo_flag, CZ_a_flag, CZ_a2_flag, CZ_a3_flag, CZ_adot_flag,
+ CZ_q_flag, CZ_de_flag, CZ_deb2_flag, CZ_df_flag, CZ_adf_flag};
// Cm ========= Aerodynamic m-moment quantities (longitudinal)
-enum {Cmo_flag = 9000, Cm_a_flag, Cm_adot_flag, Cm_q_flag, Cm_de_flag, Cmfade_flag};
+enum {Cmo_flag = 10000, Cm_a_flag, Cm_a2_flag, Cm_adot_flag, Cm_q_flag,
+ Cm_ih_flag, Cm_de_flag, Cm_b2_flag, Cm_r_flag, Cm_df_flag,
+ Cmfa_flag, Cmfade_flag, Cmfdf_flag, Cmfadf_flag};
// CY ========= Aerodynamic y-force quantities (lateral)
-enum {CYo_flag = 10000, CY_beta_flag, CY_p_flag, CY_r_flag, CY_da_flag, CY_dr_flag,
- CYfada_flag, CYfbetadr_flag};
+enum {CYo_flag = 11000, CY_beta_flag, CY_p_flag, CY_r_flag, CY_da_flag,
+ CY_dr_flag, CY_dra_flag, CY_bdot_flag, CYfada_flag, CYfbetadr_flag};
// Cl ========= Aerodynamic l-moment quantities (lateral)
-enum {Clo_flag = 11000, Cl_beta_flag, Cl_betafCL_flag, Cl_p_flag, Cl_r_flag, Cl_rfCL_flag,
- Cl_da_flag, Cl_dr_flag, Clfada_flag, Clfbetadr_flag};
+enum {Clo_flag = 12000, Cl_beta_flag, Cl_p_flag, Cl_r_flag, Cl_da_flag,
+ Cl_dr_flag, Cl_daa_flag, Clfada_flag, Clfbetadr_flag};
// Cn ========= Aerodynamic n-moment quantities (lateral)
-enum {Cno_flag = 12000, Cn_beta_flag, Cn_betafCL_flag, Cn_p_flag, Cn_pfCL_flag, Cn_r_flag,
- Cn_rfCL_flag, Cn_da_flag, Cn_dr_flag, Cn_drfCL_flag, Cnfada_flag, Cnfbetadr_flag};
+enum {Cno_flag = 13000, Cn_beta_flag, Cn_p_flag, Cn_r_flag, Cn_da_flag,
+ Cn_dr_flag, Cn_q_flag, Cn_b3_flag, Cnfada_flag, Cnfbetadr_flag};
// gear ======= Landing gear model quantities
+// enum {xxx = 14000};
// ice ======== Ice model quantities
-enum {iceTime_flag = 15000, transientTime_flag, eta_final_flag,
- kCDo_flag, kCDK_flag, kCD_a_flag, kCD_de_flag,
+enum {iceTime_flag = 15000, transientTime_flag, eta_ice_final_flag,
+ beta_probe_wing_flag, beta_probe_tail_flag,
+ kCDo_flag, kCDK_flag, kCD_a_flag, kCD_adot_flag, kCD_q_flag, kCD_de_flag,
+ kCXo_flag, kCXK_flag, kCX_a_flag, kCX_a2_flag, kCX_a3_flag, kCX_adot_flag,
+ kCX_q_flag, kCX_de_flag, kCX_dr_flag, kCX_df_flag, kCX_adf_flag,
kCLo_flag, kCL_a_flag, kCL_adot_flag, kCL_q_flag, kCL_de_flag,
- kCmo_flag, kCm_a_flag, kCm_adot_flag, kCm_q_flag, kCm_de_flag,
- kCYo_flag, kCY_beta_flag, kCY_p_flag, kCY_r_flag, kCY_da_flag, kCY_dr_flag,
- kClo_flag, kCl_beta_flag, kCl_p_flag, kCl_r_flag, kCl_da_flag, kCl_dr_flag,
- kCno_flag, kCn_beta_flag, kCn_p_flag, kCn_r_flag, kCn_da_flag, kCn_dr_flag};
+ kCZo_flag, kCZ_a_flag, kCZ_a2_flag, kCZ_a3_flag, kCZ_adot_flag,
+ kCZ_q_flag, kCZ_de_flag, kCZ_deb2_flag, kCZ_df_flag, kCZ_adf_flag,
+ kCmo_flag, kCm_a_flag, kCm_a2_flag, kCm_adot_flag, kCm_q_flag,
+ kCm_de_flag, kCm_b2_flag, kCm_r_flag, kCm_df_flag,
+ kCYo_flag, kCY_beta_flag, kCY_p_flag, kCY_r_flag, kCY_da_flag,
+ kCY_dr_flag, kCY_dra_flag, kCY_bdot_flag,
+ kClo_flag, kCl_beta_flag, kCl_p_flag, kCl_r_flag, kCl_da_flag,
+ kCl_dr_flag, kCl_daa_flag,
+ kCno_flag, kCn_beta_flag, kCn_p_flag, kCn_r_flag, kCn_da_flag,
+ kCn_dr_flag, kCn_q_flag, kCn_b3_flag};
// record ===== Record desired quantites to file
-
-enum {Dx_pilot_record = 13000, Dy_pilot_record, Dz_pilot_record,
- Dx_cg_record, Dy_cg_record, Dz_cg_record,
- V_north_record, V_east_record, V_down_record,
- V_rel_wind_record, Dynamic_pressure_record,
- Alpha_record, Alpha_dot_record, Beta_record, Beta_dot_record, Gamma_record,
+enum {Simtime_record = 16000, dt_record,
+
+ Weight_record, Mass_record, I_xx_record, I_yy_record, I_zz_record, I_xz_record,
+
+ Dx_pilot_record, Dy_pilot_record, Dz_pilot_record,
+ Dx_cg_record, Dy_cg_record, Dz_cg_record,
+ Lat_geocentric_record, Lon_geocentric_record, Radius_to_vehicle_record,
+ Latitude_record, Longitude_record, Altitude_record,
+ Phi_record, Theta_record, Psi_record,
+
+ V_dot_north_record, V_dot_east_record, V_dot_down_record,
+ U_dot_body_record, V_dot_body_record, W_dot_body_record,
+ A_X_pilot_record, A_Y_pilot_record, A_Z_pilot_record,
+ A_X_cg_record, A_Y_cg_record, A_Z_cg_record,
+ N_X_pilot_record, N_Y_pilot_record, N_Z_pilot_record,
+ N_X_cg_record, N_Y_cg_record, N_Z_cg_record,
+ P_dot_body_record, Q_dot_body_record, R_dot_body_record,
+
+ V_north_record, V_east_record, V_down_record,
+ V_north_rel_ground_record, V_east_rel_ground_record, V_down_rel_ground_record,
+ V_north_airmass_record, V_east_airmass_record, V_down_airmass_record,
+ V_north_rel_airmass_record, V_east_rel_airmass_record, V_down_rel_airmass_record,
+ U_gust_record, V_gust_record, W_gust_record,
+ U_body_record, V_body_record, W_body_record,
+ V_rel_wind_record, V_true_kts_record, V_rel_ground_record,
+ V_inertial_record, V_ground_speed_record, V_equiv_record,
+ V_equiv_kts_record, V_calibrated_record, V_calibrated_kts_record,
+ P_local_record, Q_local_record, R_local_record,
P_body_record, Q_body_record, R_body_record,
- Phi_record, Theta_record, Psi_record, Theta_dot_record,
- density_record, Mass_record, Simtime_record, dt_record,
- elevator_record, aileron_record, rudder_record,
- CD_record, CDfaI_record, CDfadeI_record,
- CL_record, CLfaI_record, CLfadeI_record,
- Cm_record, CmfadeI_record,
+ P_total_record, Q_total_record, R_total_record,
+ Phi_dot_record, Theta_dot_record, Psi_dot_record,
+ Latitude_dot_record, Longitude_dot_record, Radius_dot_record,
+
+ Alpha_record, Alpha_deg_record, Alpha_dot_record, Alpha_dot_deg_record,
+ Beta_record, Beta_deg_record, Beta_dot_record, Beta_dot_deg_record,
+ Gamma_vert_record, Gamma_vert_deg_record, Gamma_horiz_record, Gamma_horiz_deg_record,
+
+ Density_record, V_sound_record, Mach_number_record,
+ Static_pressure_record, Total_pressure_record, Impact_pressure_record,
+ Dynamic_pressure_record,
+ Static_temperature_record, Total_temperature_record,
+
+ Gravity_record, Sea_level_radius_record, Earth_position_angle_record,
+ Runway_altitude_record, Runway_latitude_record, Runway_longitude_record,
+ Runway_heading_record, Radius_to_rwy_record,
+ D_pilot_north_of_rwy_record, D_pilot_east_of_rwy_record, D_pilot_above_rwy_record,
+ X_pilot_rwy_record, Y_pilot_rwy_record, H_pilot_rwy_record,
+ D_cg_north_of_rwy_record, D_cg_east_of_rwy_record, D_cg_above_rwy_record,
+ X_cg_rwy_record, Y_cg_rwy_record, H_cg_rwy_record,
+
+ Throttle_3_record, Throttle_pct_record,
+
+ Long_control_record, Long_trim_record, Long_trim_deg_record,
+ elevator_record, elevator_deg_record,
+ Lat_control_record, aileron_record, aileron_deg_record,
+ Rudder_pedal_record, rudder_record, rudder_deg_record,
+ Flap_handle_record, flap_record, flap_deg_record,
+
+ CD_record, CDfaI_record, CDfCLI_record, CDfadeI_record, CDfdfI_record, CDfadfI_record, CX_record,
+ CL_record, CLfaI_record, CLfadeI_record, CLfdfI_record, CLfadfI_record, CZ_record,
+ Cm_record, CmfaI_record, CmfadeI_record, CmfdfI_record, CmfadfI_record,
CY_record, CYfadaI_record, CYfbetadrI_record,
Cl_record, ClfadaI_record, ClfbetadrI_record,
Cn_record, CnfadaI_record, CnfbetadrI_record,
+
F_X_wind_record, F_Y_wind_record, F_Z_wind_record,
F_X_aero_record, F_Y_aero_record, F_Z_aero_record,
F_X_engine_record, F_Y_engine_record, F_Z_engine_record,
F_X_gear_record, F_Y_gear_record, F_Z_gear_record,
F_X_record, F_Y_record, F_Z_record,
+ F_north_record, F_east_record, F_down_record,
+
M_l_aero_record, M_m_aero_record, M_n_aero_record,
M_l_engine_record, M_m_engine_record, M_n_engine_record,
M_l_gear_record, M_m_gear_record, M_n_gear_record,
- M_l_rp_record, M_m_rp_record, M_n_rp_record};
+ M_l_rp_record, M_m_rp_record, M_n_rp_record,
+
+ CLclean_wing_record, CLiced_wing_record,
+ CLclean_tail_record, CLiced_tail_record,
+ Lift_clean_wing_record, Lift_iced_wing_record,
+ Lift_clean_tail_record, Lift_iced_tail_record,
+ Gamma_clean_wing_record, Gamma_iced_wing_record,
+ Gamma_clean_tail_record, Gamma_iced_tail_record,
+ w_clean_wing_record, w_iced_wing_record,
+ w_clean_tail_record, w_iced_tail_record,
+ V_total_clean_wing_record, V_total_iced_wing_record,
+ V_total_clean_tail_record, V_total_iced_tail_record,
+ beta_flow_clean_wing_record, beta_flow_clean_wing_deg_record,
+ beta_flow_iced_wing_record, beta_flow_iced_wing_deg_record,
+ beta_flow_clean_tail_record, beta_flow_clean_tail_deg_record,
+ beta_flow_iced_tail_record, beta_flow_iced_tail_deg_record,
+ Dbeta_flow_wing_record, Dbeta_flow_wing_deg_record,
+ Dbeta_flow_tail_record, Dbeta_flow_tail_deg_record,
+ pct_beta_flow_wing_record, pct_beta_flow_tail_record};
+
+// misc ======= Miscellaneous inputs
+enum {simpleHingeMomentCoef_flag = 17000, dfTimefdf_flag};
+
typedef struct
{
// ParseFile stuff [] Bipin to add more comments
ParseFile *airplane;
-#define airplane aircraft_->airplane
+#define airplane aircraft_->airplane
ParseFile *initParts;
-#define initParts aircraft_->initParts
+#define initParts aircraft_->initParts
ParseFile *geometryParts;
-#define geometryParts aircraft_->geometryParts
+#define geometryParts aircraft_->geometryParts
ParseFile *massParts;
-#define massParts aircraft_->massParts
- ParseFile *aeroParts;
-#define aeroParts aircraft_->aeroParts
+#define massParts aircraft_->massParts
+ ParseFile *aeroDragParts;
+#define aeroDragParts aircraft_->aeroDragParts
+ ParseFile *aeroLiftParts;
+#define aeroLiftParts aircraft_->aeroLiftParts
+ ParseFile *aeroPitchParts;
+#define aeroPitchParts aircraft_->aeroPitchParts
+ ParseFile *aeroSideforceParts;
+#define aeroSideforceParts aircraft_->aeroSideforceParts
+ ParseFile *aeroRollParts;
+#define aeroRollParts aircraft_->aeroRollParts
+ ParseFile *aeroYawParts;
+#define aeroYawParts aircraft_->aeroYawParts
ParseFile *engineParts;
-#define engineParts aircraft_->engineParts
+#define engineParts aircraft_->engineParts
ParseFile *gearParts;
-#define gearParts aircraft_->gearParts
+#define gearParts aircraft_->gearParts
ParseFile *recordParts;
-#define recordParts aircraft_->recordParts
+#define recordParts aircraft_->recordParts
/*= Keywords (token1) ===========================================*/
map <string,int> Keyword_map;
#define Keyword_map aircraft_->Keyword_map
- double CL;
- double CD;
- double Cm;
- double CY;
- double Cl;
- double Cn;
-
-#define CL aircraft_->CL
+ double CD, CX, CL, CZ, Cm, CY, Cl, Cn;
#define CD aircraft_->CD
+#define CX aircraft_->CX
+#define CL aircraft_->CL
+#define CZ aircraft_->CZ
#define Cm aircraft_->Cm
#define CY aircraft_->CY
#define Cl aircraft_->Cl
#define Cn aircraft_->Cn
-
+ double CXclean_wing, CXclean_tail, CXiced_wing, CXiced_tail;
+ double CLclean_wing, CLclean_tail, CLiced_wing, CLiced_tail;
+ double CZclean_wing, CZclean_tail, CZiced_wing, CZiced_tail;
+#define CXclean_wing aircraft_->CXclean_wing
+#define CXclean_tail aircraft_->CXclean_tail
+#define CXiced_wing aircraft_->CXiced_wing
+#define CXiced_tail aircraft_->CXiced_tail
+#define CLclean_wing aircraft_->CLclean_wing
+#define CLclean_tail aircraft_->CLclean_tail
+#define CLiced_wing aircraft_->CLiced_wing
+#define CLiced_tail aircraft_->CLiced_tail
+#define CZclean_wing aircraft_->CZclean_wing
+#define CZclean_tail aircraft_->CZclean_tail
+#define CZiced_wing aircraft_->CZiced_wing
+#define CZiced_tail aircraft_->CZiced_tail
+
/*========================================*/
- /* Variables (token2) - 14 groups (000210)*/
+ /* Variables (token2) - 17 groups (000329)*/
/*========================================*/
-
+
/* Variables (token2) ===========================================*/
/* init ========== Initial values for equations of motion =======*/
-
+
map <string,int> init_map;
#define init_map aircraft_->init_map
-
+
+ int recordRate;
+#define recordRate aircraft_->recordRate
+ double recordStartTime;
+#define recordStartTime aircraft_->recordStartTime
+ bool nondim_rate_V_rel_wind;
+#define nondim_rate_V_rel_wind aircraft_->nondim_rate_V_rel_wind
+ double dyn_on_speed;
+#define dyn_on_speed aircraft_->dyn_on_speed
+
+
/* Variables (token2) ===========================================*/
/* geometry ====== Aircraft-specific geometric quantities =======*/
map <string,int> geometry_map;
#define geometry_map aircraft_->geometry_map
- double bw;
- double cbar;
- double Sw;
+ double bw, cbar, Sw, ih, bh, ch, Sh;
#define bw aircraft_->bw
#define cbar aircraft_->cbar
#define Sw aircraft_->Sw
+#define ih aircraft_->ih
+#define bh aircraft_->bh
+#define ch aircraft_->ch
+#define Sh aircraft_->Sh
+
/* Variables (token2) ===========================================*/
/* controlSurface Control surface deflections and properties ===*/
map <string,int> controlSurface_map;
#define controlSurface_map aircraft_->controlSurface_map
- double demax;
- double demin;
- double damax;
- double damin;
- double drmax;
- double drmin;
-#define demax aircraft_->demax
-#define demin aircraft_->demin
-#define damax aircraft_->damax
-#define damin aircraft_->damin
-#define drmax aircraft_->drmax
-#define drmin aircraft_->drmin
-
- double aileron;
- double elevator;
- double rudder;
-#define aileron aircraft_->aileron
-#define elevator aircraft_->elevator
-#define rudder aircraft_->rudder
+ double demax, demin;
+ double damax, damin;
+ double drmax, drmin;
+#define demax aircraft_->demax
+#define demin aircraft_->demin
+#define damax aircraft_->damax
+#define damin aircraft_->damin
+#define drmax aircraft_->drmax
+#define drmin aircraft_->drmin
+
+ double aileron, elevator, rudder;
+#define aileron aircraft_->aileron
+#define elevator aircraft_->elevator
+#define rudder aircraft_->rudder
+ double flap;
+#define flap aircraft_->flap
+
+ bool set_Long_trim, zero_Long_trim;
+ double Long_trim_constant;
+#define set_Long_trim aircraft_->set_Long_trim
+#define Long_trim_constant aircraft_->Long_trim_constant
+#define zero_Long_trim aircraft_->zero_Long_trim
+
+ bool elevator_step;
+ double elevator_step_angle, elevator_step_startTime;
+#define elevator_step aircraft_->elevator_step
+#define elevator_step_angle aircraft_->elevator_step_angle
+#define elevator_step_startTime aircraft_->elevator_step_startTime
+
+ bool elevator_singlet;
+ double elevator_singlet_angle, elevator_singlet_startTime;
+ double elevator_singlet_duration;
+#define elevator_singlet aircraft_->elevator_singlet
+#define elevator_singlet_angle aircraft_->elevator_singlet_angle
+#define elevator_singlet_startTime aircraft_->elevator_singlet_startTime
+#define elevator_singlet_duration aircraft_->elevator_singlet_duration
+
+ bool elevator_doublet;
+ double elevator_doublet_angle, elevator_doublet_startTime;
+ double elevator_doublet_duration;
+#define elevator_doublet aircraft_->elevator_doublet
+#define elevator_doublet_angle aircraft_->elevator_doublet_angle
+#define elevator_doublet_startTime aircraft_->elevator_doublet_startTime
+#define elevator_doublet_duration aircraft_->elevator_doublet_duration
+
+ bool elevator_input;
+ string elevator_input_file;
+ double elevator_input_timeArray[1000];
+ double elevator_input_deArray[1000];
+ int elevator_input_ntime;
+ double elevator_input_startTime;
+#define elevator_input aircraft_->elevator_input
+#define elevator_input_file aircraft_->elevator_input_file
+#define elevator_input_timeArray aircraft_->elevator_input_timeArray
+#define elevator_input_deArray aircraft_->elevator_input_deArray
+#define elevator_input_ntime aircraft_->elevator_input_ntime
+#define elevator_input_startTime aircraft_->elevator_input_startTime
/* Variables (token2) ===========================================*/
/* mass =========== Aircraft-specific mass properties ===========*/
map <string,int> mass_map;
-#define mass_map aircraft_->mass_map
-
-
+#define mass_map aircraft_->mass_map
+
+ double Weight;
+#define Weight aircraft_->Weight
+
+
/* Variables (token2) ===========================================*/
/* engine ======== Propulsion data ==============================*/
double simpleSingleMaxThrust;
#define simpleSingleMaxThrust aircraft_->simpleSingleMaxThrust
+
/* Variables (token2) ===========================================*/
/* CD ============ Aerodynamic x-force quantities (longitudinal) */
map <string,int> CD_map;
#define CD_map aircraft_->CD_map
- double CDo;
- double CDK;
- double CD_a;
- double CD_de;
+ double CDo, CDK, CD_a, CD_adot, CD_q, CD_ih, CD_de;
#define CDo aircraft_->CDo
#define CDK aircraft_->CDK
#define CD_a aircraft_->CD_a
+#define CD_adot aircraft_->CD_adot
+#define CD_q aircraft_->CD_q
+#define CD_ih aircraft_->CD_ih
#define CD_de aircraft_->CD_de
string CDfa;
- int CDfaData;
double CDfa_aArray[100];
double CDfa_CDArray[100];
int CDfa_nAlpha;
double CDfaI;
#define CDfa aircraft_->CDfa
-#define CDfaData aircraft_->CDfaData
#define CDfa_aArray aircraft_->CDfa_aArray
#define CDfa_CDArray aircraft_->CDfa_CDArray
#define CDfa_nAlpha aircraft_->CDfa_nAlpha
#define CDfaI aircraft_->CDfaI
+ string CDfCL;
+ double CDfCL_CLArray[100];
+ double CDfCL_CDArray[100];
+ int CDfCL_nCL;
+ double CDfCLI;
+#define CDfCL aircraft_->CDfCL
+#define CDfCL_CLArray aircraft_->CDfCL_CLArray
+#define CDfCL_CDArray aircraft_->CDfCL_CDArray
+#define CDfCL_nCL aircraft_->CDfCL_nCL
+#define CDfCLI aircraft_->CDfCLI
string CDfade;
- int CDfadeData;
double CDfade_aArray[100][100];
double CDfade_deArray[100];
double CDfade_CDArray[100][100];
int CDfade_nde;
double CDfadeI;
#define CDfade aircraft_->CDfade
-#define CDfadeData aircraft_->CDfadeData
#define CDfade_aArray aircraft_->CDfade_aArray
#define CDfade_deArray aircraft_->CDfade_deArray
#define CDfade_CDArray aircraft_->CDfade_CDArray
#define CDfade_nAlphaArray aircraft_->CDfade_nAlphaArray
#define CDfade_nde aircraft_->CDfade_nde
#define CDfadeI aircraft_->CDfadeI
+ string CDfdf;
+ double CDfdf_dfArray[100];
+ double CDfdf_CDArray[100];
+ int CDfdf_ndf;
+ double CDfdfI;
+#define CDfdf aircraft_->CDfdf
+#define CDfdf_dfArray aircraft_->CDfdf_dfArray
+#define CDfdf_CDArray aircraft_->CDfdf_CDArray
+#define CDfdf_ndf aircraft_->CDfdf_ndf
+#define CDfdfI aircraft_->CDfdfI
+ string CDfadf;
+ double CDfadf_aArray[100][100];
+ double CDfadf_dfArray[100];
+ double CDfadf_CDArray[100][100];
+ int CDfadf_nAlphaArray[100];
+ int CDfadf_ndf;
+ double CDfadfI;
+#define CDfadf aircraft_->CDfadf
+#define CDfadf_aArray aircraft_->CDfadf_aArray
+#define CDfadf_dfArray aircraft_->CDfadf_dfArray
+#define CDfadf_CDArray aircraft_->CDfadf_CDArray
+#define CDfadf_nAlphaArray aircraft_->CDfadf_nAlphaArray
+#define CDfadf_ndf aircraft_->CDfadf_ndf
+#define CDfadfI aircraft_->CDfadfI
+ double CXo, CXK, CX_a, CX_a2, CX_a3, CX_adot;
+ double CX_q, CX_de, CX_dr, CX_df, CX_adf;
+#define CXo aircraft_->CXo
+#define CXK aircraft_->CXK
+#define CX_a aircraft_->CX_a
+#define CX_a2 aircraft_->CX_a2
+#define CX_a3 aircraft_->CX_a3
+#define CX_adot aircraft_->CX_adot
+#define CX_q aircraft_->CX_q
+#define CX_de aircraft_->CX_de
+#define CX_dr aircraft_->CX_dr
+#define CX_df aircraft_->CX_df
+#define CX_adf aircraft_->CX_adf
+
/* Variables (token2) ===========================================*/
/* CL ============ Aerodynamic z-force quantities (longitudinal) */
map <string,int> CL_map;
#define CL_map aircraft_->CL_map
- double CLo;
- double CL_a;
- double CL_adot;
- double CL_q;
- double CL_de;
+ double CLo, CL_a, CL_adot, CL_q, CL_ih, CL_de;
#define CLo aircraft_->CLo
#define CL_a aircraft_->CL_a
#define CL_adot aircraft_->CL_adot
#define CL_q aircraft_->CL_q
+#define CL_ih aircraft_->CL_ih
#define CL_de aircraft_->CL_de
string CLfa;
- int CLfaData;
double CLfa_aArray[100];
double CLfa_CLArray[100];
int CLfa_nAlpha;
double CLfaI;
#define CLfa aircraft_->CLfa
-#define CLfaData aircraft_->CLfaData
#define CLfa_aArray aircraft_->CLfa_aArray
#define CLfa_CLArray aircraft_->CLfa_CLArray
#define CLfa_nAlpha aircraft_->CLfa_nAlpha
#define CLfaI aircraft_->CLfaI
string CLfade;
- int CLfadeData;
double CLfade_aArray[100][100];
double CLfade_deArray[100];
double CLfade_CLArray[100][100];
int CLfade_nde;
double CLfadeI;
#define CLfade aircraft_->CLfade
-#define CLfadeData aircraft_->CLfadeData
#define CLfade_aArray aircraft_->CLfade_aArray
#define CLfade_deArray aircraft_->CLfade_deArray
#define CLfade_CLArray aircraft_->CLfade_CLArray
#define CLfade_nAlphaArray aircraft_->CLfade_nAlphaArray
#define CLfade_nde aircraft_->CLfade_nde
#define CLfadeI aircraft_->CLfadeI
+ string CLfdf;
+ double CLfdf_dfArray[100];
+ double CLfdf_CLArray[100];
+ int CLfdf_ndf;
+ double CLfdfI;
+#define CLfdf aircraft_->CLfdf
+#define CLfdf_dfArray aircraft_->CLfdf_dfArray
+#define CLfdf_CLArray aircraft_->CLfdf_CLArray
+#define CLfdf_ndf aircraft_->CLfdf_ndf
+#define CLfdfI aircraft_->CLfdfI
+ string CLfadf;
+ double CLfadf_aArray[100][100];
+ double CLfadf_dfArray[100];
+ double CLfadf_CLArray[100][100];
+ int CLfadf_nAlphaArray[100];
+ int CLfadf_ndf;
+ double CLfadfI;
+#define CLfadf aircraft_->CLfadf
+#define CLfadf_aArray aircraft_->CLfadf_aArray
+#define CLfadf_dfArray aircraft_->CLfadf_dfArray
+#define CLfadf_CLArray aircraft_->CLfadf_CLArray
+#define CLfadf_nAlphaArray aircraft_->CLfadf_nAlphaArray
+#define CLfadf_ndf aircraft_->CLfadf_ndf
+#define CLfadfI aircraft_->CLfadfI
+ double CZo, CZ_a, CZ_a2, CZ_a3, CZ_adot;
+ double CZ_q, CZ_de, CZ_deb2, CZ_df, CZ_adf;
+#define CZo aircraft_->CZo
+#define CZ_a aircraft_->CZ_a
+#define CZ_a2 aircraft_->CZ_a2
+#define CZ_a3 aircraft_->CZ_a3
+#define CZ_adot aircraft_->CZ_adot
+#define CZ_q aircraft_->CZ_q
+#define CZ_de aircraft_->CZ_de
+#define CZ_deb2 aircraft_->CZ_deb2
+#define CZ_df aircraft_->CZ_df
+#define CZ_adf aircraft_->CZ_adf
+
/* Variables (token2) ===========================================*/
/* Cm ============ Aerodynamic m-moment quantities (longitudinal) */
map <string,int> Cm_map;
#define Cm_map aircraft_->Cm_map
- double Cmo;
- double Cm_a;
- double Cm_adot;
- double Cm_q;
- double Cm_de;
+ double Cmo, Cm_a, Cm_a2, Cm_adot, Cm_q;
+ double Cm_ih, Cm_de, Cm_b2, Cm_r, Cm_df;
#define Cmo aircraft_->Cmo
#define Cm_a aircraft_->Cm_a
+#define Cm_a2 aircraft_->Cm_a2
#define Cm_adot aircraft_->Cm_adot
#define Cm_q aircraft_->Cm_q
+#define Cm_ih aircraft_->Cm_ih
#define Cm_de aircraft_->Cm_de
+#define Cm_b2 aircraft_->Cm_b2
+#define Cm_r aircraft_->Cm_r
+#define Cm_df aircraft_->Cm_df
+ string Cmfa;
+ double Cmfa_aArray[100];
+ double Cmfa_CmArray[100];
+ int Cmfa_nAlpha;
+ double CmfaI;
+#define Cmfa aircraft_->Cmfa
+#define Cmfa_aArray aircraft_->Cmfa_aArray
+#define Cmfa_CmArray aircraft_->Cmfa_CmArray
+#define Cmfa_nAlpha aircraft_->Cmfa_nAlpha
+#define CmfaI aircraft_->CmfaI
string Cmfade;
- int CmfadeData;
double Cmfade_aArray[100][100];
double Cmfade_deArray[100];
double Cmfade_CmArray[100][100];
int Cmfade_nde;
double CmfadeI;
#define Cmfade aircraft_->Cmfade
-#define CmfadeData aircraft_->CmfadeData
#define Cmfade_aArray aircraft_->Cmfade_aArray
#define Cmfade_deArray aircraft_->Cmfade_deArray
#define Cmfade_CmArray aircraft_->Cmfade_CmArray
#define Cmfade_nAlphaArray aircraft_->Cmfade_nAlphaArray
#define Cmfade_nde aircraft_->Cmfade_nde
#define CmfadeI aircraft_->CmfadeI
+ string Cmfdf;
+ double Cmfdf_dfArray[100];
+ double Cmfdf_CmArray[100];
+ int Cmfdf_ndf;
+ double CmfdfI;
+#define Cmfdf aircraft_->Cmfdf
+#define Cmfdf_dfArray aircraft_->Cmfdf_dfArray
+#define Cmfdf_CmArray aircraft_->Cmfdf_CmArray
+#define Cmfdf_ndf aircraft_->Cmfdf_ndf
+#define CmfdfI aircraft_->CmfdfI
+ string Cmfadf;
+ double Cmfadf_aArray[100][100];
+ double Cmfadf_dfArray[100];
+ double Cmfadf_CmArray[100][100];
+ int Cmfadf_nAlphaArray[100];
+ int Cmfadf_ndf;
+ double CmfadfI;
+#define Cmfadf aircraft_->Cmfadf
+#define Cmfadf_aArray aircraft_->Cmfadf_aArray
+#define Cmfadf_dfArray aircraft_->Cmfadf_dfArray
+#define Cmfadf_CmArray aircraft_->Cmfadf_CmArray
+#define Cmfadf_nAlphaArray aircraft_->Cmfadf_nAlphaArray
+#define Cmfadf_ndf aircraft_->Cmfadf_ndf
+#define CmfadfI aircraft_->CmfadfI
+
/* Variables (token2) ===========================================*/
/* CY ============ Aerodynamic y-force quantities (lateral) =====*/
map <string,int> CY_map;
#define CY_map aircraft_->CY_map
- double CYo;
- double CY_beta;
- double CY_p;
- double CY_r;
- double CY_da;
- double CY_dr;
+ double CYo, CY_beta, CY_p, CY_r, CY_da, CY_dr, CY_dra, CY_bdot;
#define CYo aircraft_->CYo
#define CY_beta aircraft_->CY_beta
#define CY_p aircraft_->CY_p
#define CY_r aircraft_->CY_r
#define CY_da aircraft_->CY_da
#define CY_dr aircraft_->CY_dr
+#define CY_dra aircraft_->CY_dra
+#define CY_bdot aircraft_->CY_bdot
string CYfada;
- int CYfadaData;
double CYfada_aArray[100][100];
double CYfada_daArray[100];
double CYfada_CYArray[100][100];
int CYfada_nda;
double CYfadaI;
#define CYfada aircraft_->CYfada
-#define CYfadaData aircraft_->CYfadaData
#define CYfada_aArray aircraft_->CYfada_aArray
#define CYfada_daArray aircraft_->CYfada_daArray
#define CYfada_CYArray aircraft_->CYfada_CYArray
#define CYfada_nda aircraft_->CYfada_nda
#define CYfadaI aircraft_->CYfadaI
string CYfbetadr;
- int CYfbetadrData;
double CYfbetadr_betaArray[100][100];
double CYfbetadr_drArray[100];
double CYfbetadr_CYArray[100][100];
int CYfbetadr_ndr;
double CYfbetadrI;
#define CYfbetadr aircraft_->CYfbetadr
-#define CYfbetadrData aircraft_->CYfbetadrData
#define CYfbetadr_betaArray aircraft_->CYfbetadr_betaArray
#define CYfbetadr_drArray aircraft_->CYfbetadr_drArray
#define CYfbetadr_CYArray aircraft_->CYfbetadr_CYArray
#define CYfbetadr_ndr aircraft_->CYfbetadr_ndr
#define CYfbetadrI aircraft_->CYfbetadrI
+
/* Variables (token2) ===========================================*/
/* Cl ============ Aerodynamic l-moment quantities (lateral) ====*/
map <string,int> Cl_map;
#define Cl_map aircraft_->Cl_map
- double Clo;
- double Cl_beta;
- double Cl_betafCL;
- double Cl_p;
- double Cl_r;
- double Cl_rfCL;
- double Cl_da;
- double Cl_dr;
+ double Clo, Cl_beta, Cl_p, Cl_r, Cl_da, Cl_dr, Cl_daa;
#define Clo aircraft_->Clo
#define Cl_beta aircraft_->Cl_beta
-#define Cl_betafCL aircraft_->Cl_betafCL
#define Cl_p aircraft_->Cl_p
#define Cl_r aircraft_->Cl_r
-#define Cl_rfCL aircraft_->Cl_rfCL
#define Cl_da aircraft_->Cl_da
#define Cl_dr aircraft_->Cl_dr
+#define Cl_daa aircraft_->Cl_daa
string Clfada;
- int ClfadaData;
double Clfada_aArray[100][100];
double Clfada_daArray[100];
double Clfada_ClArray[100][100];
int Clfada_nda;
double ClfadaI;
#define Clfada aircraft_->Clfada
-#define ClfadaData aircraft_->ClfadaData
#define Clfada_aArray aircraft_->Clfada_aArray
#define Clfada_daArray aircraft_->Clfada_daArray
#define Clfada_ClArray aircraft_->Clfada_ClArray
#define Clfada_nda aircraft_->Clfada_nda
#define ClfadaI aircraft_->ClfadaI
string Clfbetadr;
- int ClfbetadrData;
double Clfbetadr_betaArray[100][100];
double Clfbetadr_drArray[100];
double Clfbetadr_ClArray[100][100];
int Clfbetadr_ndr;
double ClfbetadrI;
#define Clfbetadr aircraft_->Clfbetadr
-#define ClfbetadrData aircraft_->ClfbetadrData
#define Clfbetadr_betaArray aircraft_->Clfbetadr_betaArray
#define Clfbetadr_drArray aircraft_->Clfbetadr_drArray
#define Clfbetadr_ClArray aircraft_->Clfbetadr_ClArray
#define Clfbetadr_ndr aircraft_->Clfbetadr_ndr
#define ClfbetadrI aircraft_->ClfbetadrI
+
/* Variables (token2) ===========================================*/
/* Cn ============ Aerodynamic n-moment quantities (lateral) ====*/
map <string,int> Cn_map;
#define Cn_map aircraft_->Cn_map
- double Cno;
- double Cn_beta;
- double Cn_p;
- double Cn_r;
- double Cn_da;
- double Cn_dr;
+ double Cno, Cn_beta, Cn_p, Cn_r, Cn_da, Cn_dr, Cn_q, Cn_b3;
#define Cno aircraft_->Cno
#define Cn_beta aircraft_->Cn_beta
#define Cn_p aircraft_->Cn_p
#define Cn_r aircraft_->Cn_r
#define Cn_da aircraft_->Cn_da
#define Cn_dr aircraft_->Cn_dr
+#define Cn_q aircraft_->Cn_q
+#define Cn_b3 aircraft_->Cn_b3
string Cnfada;
- int CnfadaData;
double Cnfada_aArray[100][100];
double Cnfada_daArray[100];
double Cnfada_CnArray[100][100];
int Cnfada_nda;
double CnfadaI;
#define Cnfada aircraft_->Cnfada
-#define CnfadaData aircraft_->CnfadaData
#define Cnfada_aArray aircraft_->Cnfada_aArray
#define Cnfada_daArray aircraft_->Cnfada_daArray
#define Cnfada_CnArray aircraft_->Cnfada_CnArray
#define Cnfada_nda aircraft_->Cnfada_nda
#define CnfadaI aircraft_->CnfadaI
string Cnfbetadr;
- int CnfbetadrData;
double Cnfbetadr_betaArray[100][100];
double Cnfbetadr_drArray[100];
double Cnfbetadr_CnArray[100][100];
int Cnfbetadr_ndr;
double CnfbetadrI;
#define Cnfbetadr aircraft_->Cnfbetadr
-#define CnfbetadrData aircraft_->CnfbetadrData
#define Cnfbetadr_betaArray aircraft_->Cnfbetadr_betaArray
#define Cnfbetadr_drArray aircraft_->Cnfbetadr_drArray
#define Cnfbetadr_CnArray aircraft_->Cnfbetadr_CnArray
#define Cnfbetadr_ndr aircraft_->Cnfbetadr_ndr
#define CnfbetadrI aircraft_->CnfbetadrI
+
/* Variables (token2) ===========================================*/
/* gear ========== Landing gear model quantities ================*/
#define gear_map aircraft_->gear_map
+
/* Variables (token2) ===========================================*/
/* ice =========== Ice model quantities ======================== */
map <string,int> ice_map;
#define ice_map aircraft_->ice_map
+ bool ice_model, ice_on, beta_model;
double iceTime;
double transientTime;
- double eta_final;
- double eta;
+ double eta_ice_final;
+ double eta_ice;
+ double x_probe_wing;
+ double x_probe_tail;
+#define ice_model aircraft_->ice_model
+#define ice_on aircraft_->ice_on
+#define beta_model aircraft_->beta_model
#define iceTime aircraft_->iceTime
#define transientTime aircraft_->transientTime
-#define eta_final aircraft_->eta_final
-#define eta aircraft_->eta
- double kCDo;
- double kCDK;
- double kCD_a;
- double kCD_de;
- double CDo_clean;
- double CDK_clean;
- double CD_a_clean;
- double CD_de_clean;
+#define eta_ice_final aircraft_->eta_ice_final
+#define eta_ice aircraft_->eta_ice
+#define x_probe_wing aircraft_->x_probe_wing
+#define x_probe_tail aircraft_->x_probe_tail
+ double kCDo, kCDK, kCD_a, kCD_adot, kCD_q, kCD_de;
+ double CDo_clean, CDK_clean, CD_a_clean, CD_adot_clean, CD_q_clean, CD_de_clean;
#define kCDo aircraft_->kCDo
#define kCDK aircraft_->kCDK
#define kCD_a aircraft_->kCD_a
+#define kCD_adot aircraft_->kCD_adot
+#define kCD_q aircraft_->kCD_q
#define kCD_de aircraft_->kCD_de
#define CDo_clean aircraft_->CDo_clean
#define CDK_clean aircraft_->CDK_clean
#define CD_a_clean aircraft_->CD_a_clean
+#define CD_adot_clean aircraft_->CD_adot_clean
+#define CD_q_clean aircraft_->CD_q_clean
#define CD_de_clean aircraft_->CD_de_clean
- double kCLo;
- double kCL_a;
- double kCL_adot;
- double kCL_q;
- double kCL_de;
- double CLo_clean;
- double CL_a_clean;
- double CL_adot_clean;
- double CL_q_clean;
- double CL_de_clean;
+ double kCXo, kCXK, kCX_a, kCX_a2, kCX_a3, kCX_adot;
+ double kCX_q, kCX_de, kCX_dr, kCX_df, kCX_adf;
+ double CXo_clean, CXK_clean, CX_a_clean, CX_a2_clean, CX_a3_clean, CX_adot_clean;
+ double CX_q_clean, CX_de_clean, CX_dr_clean, CX_df_clean, CX_adf_clean;
+#define kCXo aircraft_->kCXo
+#define kCXK aircraft_->kCXK
+#define kCX_a aircraft_->kCX_a
+#define kCX_a2 aircraft_->kCX_a2
+#define kCX_a3 aircraft_->kCX_a3
+#define kCX_adot aircraft_->kCX_adot
+#define kCX_q aircraft_->kCX_q
+#define kCX_de aircraft_->kCX_de
+#define kCX_dr aircraft_->kCX_dr
+#define kCX_df aircraft_->kCX_df
+#define kCX_adf aircraft_->kCX_adf
+#define CXo_clean aircraft_->CXo_clean
+#define CXK_clean aircraft_->CXK_clean
+#define CX_a_clean aircraft_->CX_a_clean
+#define CX_a2_clean aircraft_->CX_a2_clean
+#define CX_a3_clean aircraft_->CX_a3_clean
+#define CX_adot_clean aircraft_->CX_adot_clean
+#define CX_q_clean aircraft_->CX_q_clean
+#define CX_de_clean aircraft_->CX_de_clean
+#define CX_dr_clean aircraft_->CX_dr_clean
+#define CX_df_clean aircraft_->CX_df_clean
+#define CX_adf_clean aircraft_->CX_adf_clean
+ double kCLo, kCL_a, kCL_adot, kCL_q, kCL_de;
+ double CLo_clean, CL_a_clean, CL_adot_clean, CL_q_clean, CL_de_clean;
#define kCLo aircraft_->kCLo
#define kCL_a aircraft_->kCL_a
#define kCL_adot aircraft_->kCL_adot
#define CL_adot_clean aircraft_->CL_adot_clean
#define CL_q_clean aircraft_->CL_q_clean
#define CL_de_clean aircraft_->CL_de_clean
- double kCmo;
- double kCm_a;
- double kCm_adot;
- double kCm_q;
- double kCm_de;
- double Cmo_clean;
- double Cm_a_clean;
- double Cm_adot_clean;
- double Cm_q_clean;
- double Cm_de_clean;
+ double kCZo, kCZ_a, kCZ_a2, kCZ_a3, kCZ_adot, kCZ_q, kCZ_de, kCZ_deb2, kCZ_df, kCZ_adf;
+ double CZo_clean, CZ_a_clean, CZ_a2_clean, CZ_a3_clean, CZ_adot_clean;
+ double CZ_q_clean, CZ_de_clean, CZ_deb2_clean, CZ_df_clean, CZ_adf_clean;
+#define kCZo aircraft_->kCZo
+#define kCZ_a aircraft_->kCZ_a
+#define kCZ_a2 aircraft_->kCZ_a2
+#define kCZ_a3 aircraft_->kCZ_a3
+#define kCZ_adot aircraft_->kCZ_adot
+#define kCZ_q aircraft_->kCZ_q
+#define kCZ_de aircraft_->kCZ_de
+#define kCZ_deb2 aircraft_->kCZ_deb2
+#define kCZ_df aircraft_->kCZ_df
+#define kCZ_adf aircraft_->kCZ_adf
+#define CZo_clean aircraft_->CZo_clean
+#define CZ_a_clean aircraft_->CZ_a_clean
+#define CZ_a2_clean aircraft_->CZ_a2_clean
+#define CZ_a3_clean aircraft_->CZ_a3_clean
+#define CZ_adot_clean aircraft_->CZ_adot_clean
+#define CZ_q_clean aircraft_->CZ_q_clean
+#define CZ_de_clean aircraft_->CZ_de_clean
+#define CZ_deb2_clean aircraft_->CZ_deb2_clean
+#define CZ_df_clean aircraft_->CZ_df_clean
+#define CZ_adf_clean aircraft_->CZ_adf_clean
+ double kCmo, kCm_a, kCm_a2, kCm_adot, kCm_q, kCm_de, kCm_b2, kCm_r, kCm_df;
+ double Cmo_clean, Cm_a_clean, Cm_a2_clean, Cm_adot_clean, Cm_q_clean;
+ double Cm_de_clean, Cm_b2_clean, Cm_r_clean, Cm_df_clean;
#define kCmo aircraft_->kCmo
#define kCm_a aircraft_->kCm_a
+#define kCm_a2 aircraft_->kCm_a2
#define kCm_adot aircraft_->kCm_adot
#define kCm_q aircraft_->kCm_q
#define kCm_de aircraft_->kCm_de
+#define kCm_b2 aircraft_->kCm_b2
+#define kCm_r aircraft_->kCm_r
+#define kCm_df aircraft_->kCm_df
#define Cmo_clean aircraft_->Cmo_clean
#define Cm_a_clean aircraft_->Cm_a_clean
+#define Cm_a2_clean aircraft_->Cm_a2_clean
#define Cm_adot_clean aircraft_->Cm_adot_clean
#define Cm_q_clean aircraft_->Cm_q_clean
#define Cm_de_clean aircraft_->Cm_de_clean
- double kCYo;
- double kCY_beta;
- double kCY_p;
- double kCY_r;
- double kCY_da;
- double kCY_dr;
- double CYo_clean;
- double CY_beta_clean;
- double CY_p_clean;
- double CY_r_clean;
- double CY_da_clean;
- double CY_dr_clean;
+#define Cm_b2_clean aircraft_->Cm_b2_clean
+#define Cm_r_clean aircraft_->Cm_r_clean
+#define Cm_df_clean aircraft_->Cm_df_clean
+ double kCYo, kCY_beta, kCY_p, kCY_r, kCY_da, kCY_dr, kCY_dra, kCY_bdot;
+ double CYo_clean, CY_beta_clean, CY_p_clean, CY_r_clean, CY_da_clean;
+ double CY_dr_clean, CY_dra_clean, CY_bdot_clean;
#define kCYo aircraft_->kCYo
#define kCY_beta aircraft_->kCY_beta
#define kCY_p aircraft_->kCY_p
#define kCY_r aircraft_->kCY_r
#define kCY_da aircraft_->kCY_da
#define kCY_dr aircraft_->kCY_dr
+#define kCY_dra aircraft_->kCY_dra
+#define kCY_bdot aircraft_->kCY_bdot
#define CYo_clean aircraft_->CYo_clean
#define CY_beta_clean aircraft_->CY_beta_clean
#define CY_p_clean aircraft_->CY_p_clean
#define CY_r_clean aircraft_->CY_r_clean
#define CY_da_clean aircraft_->CY_da_clean
#define CY_dr_clean aircraft_->CY_dr_clean
- double kClo;
- double kCl_beta;
- double kCl_p;
- double kCl_r;
- double kCl_da;
- double kCl_dr;
- double Clo_clean;
- double Cl_beta_clean;
- double Cl_p_clean;
- double Cl_r_clean;
- double Cl_da_clean;
- double Cl_dr_clean;
+#define CY_dra_clean aircraft_->CY_dra_clean
+#define CY_bdot_clean aircraft_->CY_bdot_clean
+ double kClo, kCl_beta, kCl_p, kCl_r, kCl_da, kCl_dr, kCl_daa;
+ double Clo_clean, Cl_beta_clean, Cl_p_clean, Cl_r_clean, Cl_da_clean;
+ double Cl_dr_clean, Cl_daa_clean;
#define kClo aircraft_->kClo
#define kCl_beta aircraft_->kCl_beta
#define kCl_p aircraft_->kCl_p
#define kCl_r aircraft_->kCl_r
#define kCl_da aircraft_->kCl_da
#define kCl_dr aircraft_->kCl_dr
+#define kCl_daa aircraft_->kCl_daa
#define Clo_clean aircraft_->Clo_clean
#define Cl_beta_clean aircraft_->Cl_beta_clean
#define Cl_p_clean aircraft_->Cl_p_clean
#define Cl_r_clean aircraft_->Cl_r_clean
#define Cl_da_clean aircraft_->Cl_da_clean
#define Cl_dr_clean aircraft_->Cl_dr_clean
- double kCno;
- double kCn_beta;
- double kCn_p;
- double kCn_r;
- double kCn_da;
- double kCn_dr;
- double Cno_clean;
- double Cn_beta_clean;
- double Cn_p_clean;
- double Cn_r_clean;
- double Cn_da_clean;
- double Cn_dr_clean;
+#define Cl_daa_clean aircraft_->Cl_daa_clean
+ double kCno, kCn_beta, kCn_p, kCn_r, kCn_da, kCn_dr, kCn_q, kCn_b3;
+ double Cno_clean, Cn_beta_clean, Cn_p_clean, Cn_r_clean, Cn_da_clean;
+ double Cn_dr_clean, Cn_q_clean, Cn_b3_clean;
#define kCno aircraft_->kCno
#define kCn_beta aircraft_->kCn_beta
#define kCn_p aircraft_->kCn_p
#define kCn_r aircraft_->kCn_r
#define kCn_da aircraft_->kCn_da
#define kCn_dr aircraft_->kCn_dr
+#define kCn_q aircraft_->kCn_q
+#define kCn_b3 aircraft_->kCn_b3
#define Cno_clean aircraft_->Cno_clean
#define Cn_beta_clean aircraft_->Cn_beta_clean
#define Cn_p_clean aircraft_->Cn_p_clean
#define Cn_r_clean aircraft_->Cn_r_clean
#define Cn_da_clean aircraft_->Cn_da_clean
#define Cn_dr_clean aircraft_->Cn_dr_clean
+#define Cn_q_clean aircraft_->Cn_q_clean
+#define Cn_b3_clean aircraft_->Cn_b3_clean
+
/* Variables (token2) ===========================================*/
/* record ======== Record desired quantites to file =============*/
map <string,int> record_map;
#define record_map aircraft_->record_map
- /***** Forces *******/
-
+ /***** Angles ******/
+ double Alpha_deg, Alpha_dot_deg, Beta_deg, Beta_dot_deg;
+#define Alpha_deg aircraft_->Alpha_deg
+#define Alpha_dot_deg aircraft_->Alpha_dot_deg
+#define Beta_deg aircraft_->Beta_deg
+#define Beta_dot_deg aircraft_->Beta_dot_deg
+ double Gamma_vert_deg, Gamma_horiz_deg;
+#define Gamma_vert_deg aircraft_->Gamma_vert_deg
+#define Gamma_horiz_deg aircraft_->Gamma_horiz_deg
+
+ /** Control Inputs **/
+ double Long_trim_deg, elevator_tab, elevator_deg, aileron_deg, rudder_deg;
+#define Long_trim_deg aircraft_->Long_trim_deg
+#define elevator_tab aircraft_->elevator_tab
+#define elevator_deg aircraft_->elevator_deg
+#define aileron_deg aircraft_->aileron_deg
+#define rudder_deg aircraft_->rudder_deg
+ double flap_deg;
+#define flap_deg aircraft_->flap_deg
+
+ /***** Forces ******/
double F_X_wind, F_Y_wind, F_Z_wind;
-
#define F_X_wind aircraft_->F_X_wind
#define F_Y_wind aircraft_->F_Y_wind
#define F_Z_wind aircraft_->F_Z_wind
+ double Lift_clean_wing, Lift_iced_wing;
+ double Lift_clean_tail, Lift_iced_tail;
+#define Lift_clean_wing aircraft_->Lift_clean_wing
+#define Lift_iced_wing aircraft_->Lift_iced_wing
+#define Lift_clean_tail aircraft_->Lift_clean_tail
+#define Lift_iced_tail aircraft_->Lift_iced_tail
+ double Gamma_clean_wing, Gamma_iced_wing;
+ double Gamma_clean_tail, Gamma_iced_tail;
+#define Gamma_clean_wing aircraft_->Gamma_clean_wing
+#define Gamma_iced_wing aircraft_->Gamma_iced_wing
+#define Gamma_clean_tail aircraft_->Gamma_clean_tail
+#define Gamma_iced_tail aircraft_->Gamma_iced_tail
+ double w_clean_wing, w_iced_wing;
+ double w_clean_tail, w_iced_tail;
+#define w_clean_wing aircraft_->w_clean_wing
+#define w_iced_wing aircraft_->w_iced_wing
+#define w_clean_tail aircraft_->w_clean_tail
+#define w_iced_tail aircraft_->w_iced_tail
+ double V_total_clean_wing, V_total_iced_wing;
+ double V_total_clean_tail, V_total_iced_tail;
+#define V_total_clean_wing aircraft_->V_total_clean_wing
+#define V_total_iced_wing aircraft_->V_total_iced_wing
+#define V_total_clean_tail aircraft_->V_total_clean_tail
+#define V_total_iced_tail aircraft_->V_total_iced_tail
+ double beta_flow_clean_wing, beta_flow_clean_wing_deg;
+ double beta_flow_iced_wing, beta_flow_iced_wing_deg;
+ double beta_flow_clean_tail, beta_flow_clean_tail_deg;
+ double beta_flow_iced_tail, beta_flow_iced_tail_deg;
+#define beta_flow_clean_wing aircraft_->beta_flow_clean_wing
+#define beta_flow_clean_wing_deg aircraft_->beta_flow_clean_wing_deg
+#define beta_flow_iced_wing aircraft_->beta_flow_iced_wing
+#define beta_flow_iced_wing_deg aircraft_->beta_flow_iced_wing_deg
+#define beta_flow_clean_tail aircraft_->beta_flow_clean_tail
+#define beta_flow_clean_tail_deg aircraft_->beta_flow_clean_tail_deg
+#define beta_flow_iced_tail aircraft_->beta_flow_iced_tail
+#define beta_flow_iced_tail_deg aircraft_->beta_flow_iced_tail_deg
+ double Dbeta_flow_wing, Dbeta_flow_wing_deg;
+ double Dbeta_flow_tail, Dbeta_flow_tail_deg;
+#define Dbeta_flow_wing aircraft_->Dbeta_flow_wing
+#define Dbeta_flow_wing_deg aircraft_->Dbeta_flow_wing_deg
+#define Dbeta_flow_tail aircraft_->Dbeta_flow_tail
+#define Dbeta_flow_tail_deg aircraft_->Dbeta_flow_tail_deg
+ double pct_beta_flow_wing, pct_beta_flow_tail;
+#define pct_beta_flow_wing aircraft_->pct_beta_flow_wing
+#define pct_beta_flow_tail aircraft_->pct_beta_flow_tail
+
+
+ /* Variables (token2) ===========================================*/
+ /* misc ========== Miscellaneous input commands =================*/
+
+ map <string,int> misc_map;
+#define misc_map aircraft_->misc_map
+
+ double simpleHingeMomentCoef;
+#define simpleHingeMomentCoef aircraft_->simpleHingeMomentCoef
+ string dfTimefdf;
+ double dfTimefdf_dfArray[100];
+ double dfTimefdf_TimeArray[100];
+ int dfTimefdf_ndf;
+#define dfTimefdf aircraft_->dfTimefdf
+#define dfTimefdf_dfArray aircraft_->dfTimefdf_dfArray
+#define dfTimefdf_TimeArray aircraft_->dfTimefdf_TimeArray
+#define dfTimefdf_ndf aircraft_->dfTimefdf_ndf
+
+ /* Other variables (not tokens) =================================*/
- /* Miscellaneous ================================================*/
+ double convert_x, convert_y, convert_z;
+#define convert_x aircraft_->convert_x
+#define convert_y aircraft_->convert_y
+#define convert_z aircraft_->convert_z
- int conversion1, conversion2, conversion3;
- double confac1, confac2, confac3;
+ double cbar_2U, b_2U, ch_2U;
+#define cbar_2U aircraft_->cbar_2U
+#define b_2U aircraft_->b_2U
+#define ch_2U aircraft_->ch_2U
-#define conversion1 aircraft_->conversion1
-#define conversion2 aircraft_->conversion2
-#define conversion3 aircraft_->conversion3
-#define confac1 aircraft_->confac1
-#define confac2 aircraft_->confac2
-#define confac3 aircraft_->confac3
+ int ndf;
+ double dfArray[100];
+ double TimeArray[100];
+#define ndf aircraft_->ndf
+#define dfArray aircraft_->dfArray
+#define TimeArray aircraft_->TimeArray
ofstream fout;
} AIRCRAFT;
-// usually defined in the first program that includes uiuc_aircraft.h
-extern AIRCRAFT *aircraft_;
+extern AIRCRAFT *aircraft_; // usually defined in the first program that includes uiuc_aircraft.h
#endif // endif _AIRCRAFT_H
typedef struct
{
- string real_aircraft_dir;
- #define aircraft_dir aircraftdir_->real_aircraft_dir
+ string aircraft_dir;
+ #define aircraft_dir aircraftdir_->aircraft_dir
} AIRCRAFTDIR;
-// usually defined in the first program that includes uiuc_aircraft.h
-extern AIRCRAFTDIR *aircraftdir_;
+extern AIRCRAFTDIR *aircraftdir_; // usually defined in the first program that includes uiuc_aircraft.h
#endif // endif _AIRCRAFTDIR_H
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_betaprobe.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: Computes flow angle, beta, for use in ice detection
+ scheme
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 05/15/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: CLclean_wing
+ CLiced_wing
+ CLclean_tail
+ CLiced_tail
+
+----------------------------------------------------------------------
+
+ OUTPUTS: Dbeta_flow_wing
+ Dbeta_flow_tail
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_wrapper
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_betaprobe.h"
+
+
+void uiuc_betaprobe()
+{
+ if (CX && CZ)
+ {
+ CLclean_wing = CXclean_wing * sin(Alpha) - CZclean_wing * cos(Alpha);
+ CLiced_wing = CXiced_wing * sin(Alpha) - CZiced_wing * cos(Alpha);
+ CLclean_tail = CXclean_tail * sin(Alpha) - CZclean_tail * cos(Alpha);
+ CLiced_tail = CXiced_tail * sin(Alpha) - CZiced_tail * cos(Alpha);
+ }
+
+ /* calculate lift per unit span*/
+ Lift_clean_wing = CLclean_wing * Dynamic_pressure * Sw / bw;
+ Lift_iced_wing = CLiced_wing * Dynamic_pressure * Sw / bw;
+ Lift_clean_tail = CLclean_tail * Dynamic_pressure * Sh / bh;
+ Lift_iced_tail = CLiced_tail * Dynamic_pressure * Sh / bh;
+
+ Gamma_clean_wing = Lift_clean_wing / (Density * V_rel_wind);
+ Gamma_iced_wing = Lift_iced_wing / (Density * V_rel_wind);
+ Gamma_clean_tail = Lift_clean_tail / (Density * V_rel_wind);
+ Gamma_iced_tail = Lift_iced_tail / (Density * V_rel_wind);
+
+ w_clean_wing = Gamma_clean_wing / (2 * PI * x_probe_wing);
+ w_iced_wing = Gamma_iced_wing / (2 * PI * x_probe_wing);
+ w_clean_tail = Gamma_clean_tail / (2 * PI * x_probe_tail);
+ w_iced_tail = Gamma_iced_tail / (2 * PI * x_probe_tail);
+
+ V_total_clean_wing = sqrt(w_clean_wing*w_clean_wing +
+ V_rel_wind*V_rel_wind -
+ 2*w_clean_wing*V_rel_wind *
+ cos(PI/2 + Alpha));
+ V_total_iced_wing = sqrt(w_iced_wing*w_iced_wing +
+ V_rel_wind*V_rel_wind -
+ 2*w_iced_wing*V_rel_wind *
+ cos(PI/2 + Alpha));
+ V_total_clean_tail = sqrt(w_clean_tail*w_clean_tail +
+ V_rel_wind*V_rel_wind -
+ 2*w_clean_tail*V_rel_wind *
+ cos(PI/2 + Alpha));
+ V_total_iced_tail = sqrt(w_iced_tail*w_iced_tail +
+ V_rel_wind*V_rel_wind -
+ 2*w_iced_tail*V_rel_wind *
+ cos(PI/2 + Alpha));
+
+ beta_flow_clean_wing = asin((w_clean_wing / V_total_clean_wing) *
+ sin (PI/2 + Alpha));
+ beta_flow_iced_wing = asin((w_iced_wing / V_total_iced_wing) *
+ sin (PI/2 + Alpha));
+ beta_flow_clean_tail = asin((w_clean_tail / V_total_clean_tail) *
+ sin (PI/2 + Alpha));
+ beta_flow_iced_tail = asin((w_iced_tail / V_total_iced_tail) *
+ sin (PI/2 + Alpha));
+
+ Dbeta_flow_wing = fabs(beta_flow_clean_wing - beta_flow_iced_wing);
+ Dbeta_flow_tail = fabs(beta_flow_clean_tail - beta_flow_iced_tail);
+
+ pct_beta_flow_wing = beta_flow_iced_wing / beta_flow_clean_wing;
+ pct_beta_flow_tail = beta_flow_iced_tail / beta_flow_clean_tail;
+}
+
+//end uiuc_betaprobe.cpp
--- /dev/null
+#ifndef _BETAPROBE_H_
+#define _BETAPROBE_H_
+
+#include "uiuc_aircraft.h"
+#include "../FDM/LaRCsim/ls_constants.h"
+#include "../FDM/LaRCsim/ls_generic.h"
+#include <math.h>
+
+void uiuc_betaprobe();
+
+#endif // _BETAPROBE_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_coef_drag.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: computes aggregated aerodynamic drag coefficient
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES: Roskam, Jan. Airplane Flight Dynamics and Automatic
+ Flight Controls, Part I. Lawrence, KS: DARcorporation,
+ 1995.
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/15/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: -Alpha
+ -elevator
+ -drag coefficient components
+ -icing parameters
+
+----------------------------------------------------------------------
+
+ OUTPUTS: -CD
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_coefficients.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: uiuc_1Dinterpolation
+ uiuc_2Dinterpolation
+ uiuc_ice_filter
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_coef_drag.h"
+
+
+void uiuc_coef_drag()
+{
+ string linetoken1;
+ string linetoken2;
+ stack command_list;
+
+ command_list = aeroDragParts -> getCommands();
+
+ for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
+ {
+ linetoken1 = aeroDragParts -> getToken(*command_line, 1);
+ linetoken2 = aeroDragParts -> getToken(*command_line, 2);
+
+ switch (CD_map[linetoken2])
+ {
+ case CDo_flag:
+ {
+ if (ice_on)
+ {
+ CDo = uiuc_ice_filter(CDo_clean,kCDo);
+ }
+ CD += CDo;
+ break;
+ }
+ case CDK_flag:
+ {
+ if (ice_on)
+ {
+ CDK = uiuc_ice_filter(CDK_clean,kCDK);
+ }
+ CD += CDK * CL * CL;
+ break;
+ }
+ case CD_a_flag:
+ {
+ if (ice_on)
+ {
+ CD_a = uiuc_ice_filter(CD_a_clean,kCD_a);
+ }
+ CD += CD_a * Alpha;
+ break;
+ }
+ case CD_adot_flag:
+ {
+ if (ice_on)
+ {
+ CD_adot = uiuc_ice_filter(CD_adot_clean,kCD_adot);
+ }
+ /* CD_adot must be mulitplied by cbar/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ CD += CD_adot * Alpha_dot * cbar_2U;
+ break;
+ }
+ case CD_q_flag:
+ {
+ if (ice_on)
+ {
+ CD_q = uiuc_ice_filter(CD_q_clean,kCD_q);
+ }
+ /* CD_q must be mulitplied by cbar/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ /* why multiply by Theta_dot instead of Q_body?
+ see note in coef_lift.cpp */
+ CD += CD_q * Theta_dot * cbar_2U;
+ break;
+ }
+ case CD_ih_flag:
+ {
+ CD += CD_ih * ih;
+ break;
+ }
+ case CD_de_flag:
+ {
+ if (ice_on)
+ {
+ CD_de = uiuc_ice_filter(CD_de_clean,kCD_de);
+ }
+ CD += CD_de * elevator;
+ break;
+ }
+ case CDfa_flag:
+ {
+ CDfaI = uiuc_1Dinterpolation(CDfa_aArray,
+ CDfa_CDArray,
+ CDfa_nAlpha,
+ Alpha);
+ CD += CDfaI;
+ break;
+ }
+ case CDfCL_flag:
+ {
+ CDfCLI = uiuc_1Dinterpolation(CDfCL_CLArray,
+ CDfCL_CDArray,
+ CDfCL_nCL,
+ CL);
+ CD += CDfCLI;
+ break;
+ }
+ case CDfdf_flag:
+ {
+ CDfdfI = uiuc_1Dinterpolation(CDfdf_dfArray,
+ CDfdf_CDArray,
+ CDfdf_ndf,
+ flap);
+ CD += CDfdfI;
+ break;
+ }
+ case CDfade_flag:
+ {
+ CDfadeI = uiuc_2Dinterpolation(CDfade_aArray,
+ CDfade_deArray,
+ CDfade_CDArray,
+ CDfade_nAlphaArray,
+ CDfade_nde,
+ Alpha,
+ elevator);
+ CD += CDfadeI;
+ break;
+ }
+ case CDfadf_flag:
+ {
+ CDfadfI = uiuc_2Dinterpolation(CDfadf_aArray,
+ CDfadf_dfArray,
+ CDfadf_CDArray,
+ CDfadf_nAlphaArray,
+ CDfadf_ndf,
+ Alpha,
+ flap);
+ CD += CDfadfI;
+ break;
+ }
+ case CXo_flag:
+ {
+ if (ice_on)
+ {
+ CXo = uiuc_ice_filter(CXo_clean,kCXo);
+ if (beta_model)
+ {
+ CXclean_wing += CXo_clean;
+ CXclean_tail += CXo_clean;
+ CXiced_wing += CXo;
+ CXiced_tail += CXo;
+ }
+ }
+ CX += CXo;
+ break;
+ }
+ case CXK_flag:
+ {
+ if (ice_on)
+ {
+ CXK = uiuc_ice_filter(CXK_clean,kCXK);
+ if (beta_model)
+ {
+ CXclean_wing += CXK_clean * CLclean_wing * CLclean_wing;
+ CXclean_tail += CXK_clean * CLclean_tail * CLclean_tail;
+ CXiced_wing += CXK * CLiced_wing * CLiced_wing;
+ CXiced_tail += CXK * CLiced_tail * CLiced_tail;
+ }
+ }
+ CX += CXK * CZ * CZ;
+ break;
+ }
+ case CX_a_flag:
+ {
+ if (ice_on)
+ {
+ CX_a = uiuc_ice_filter(CX_a_clean,kCX_a);
+ if (beta_model)
+ {
+ CXclean_wing += CX_a_clean * Alpha;
+ CXclean_tail += CX_a_clean * Alpha;
+ CXiced_wing += CX_a * Alpha;
+ CXiced_tail += CX_a * Alpha;
+ }
+ }
+ CX += CX_a * Alpha;
+ break;
+ }
+ case CX_a2_flag:
+ {
+ if (ice_on)
+ {
+ CX_a2 = uiuc_ice_filter(CX_a2_clean,kCX_a2);
+ if (beta_model)
+ {
+ CXclean_wing += CX_a2_clean * Alpha * Alpha;
+ CXclean_tail += CX_a2_clean * Alpha * Alpha;
+ CXiced_wing += CX_a2 * Alpha * Alpha;
+ CXiced_tail += CX_a2 * Alpha * Alpha;
+ }
+ }
+ CX += CX_a2 * Alpha * Alpha;
+ break;
+ }
+ case CX_a3_flag:
+ {
+ if (ice_on)
+ {
+ CX_a3 = uiuc_ice_filter(CX_a3_clean,kCX_a3);
+ if (beta_model)
+ {
+ CXclean_wing += CX_a3_clean * Alpha * Alpha * Alpha;
+ CXclean_tail += CX_a3_clean * Alpha * Alpha * Alpha;
+ CXiced_wing += CX_a3 * Alpha * Alpha * Alpha;
+ CXiced_tail += CX_a3 * Alpha * Alpha * Alpha;
+ }
+ }
+ CX += CX_a3 * Alpha * Alpha * Alpha;
+ break;
+ }
+ case CX_adot_flag:
+ {
+ if (ice_on)
+ {
+ CX_adot = uiuc_ice_filter(CX_adot_clean,kCX_adot);
+ if (beta_model)
+ {
+ CXclean_wing += CX_adot_clean * Alpha_dot * cbar_2U;
+ CXclean_tail += CX_adot_clean * Alpha_dot * ch_2U;
+ CXiced_wing += CX * Alpha_dot * cbar_2U;
+ CXiced_tail += CX * Alpha_dot * ch_2U;
+ }
+ }
+ /* CX_adot must be mulitplied by cbar/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ CX += CX_adot * Alpha_dot * cbar_2U;
+ break;
+ }
+ case CX_q_flag:
+ {
+ if (ice_on)
+ {
+ CX_q = uiuc_ice_filter(CX_q_clean,kCX_q);
+ if (beta_model)
+ {
+ CXclean_wing += CX_q_clean * Q_body * cbar_2U;
+ CXclean_tail += CX_q_clean * Q_body * ch_2U;
+ CXiced_wing += CX_q * Q_body * cbar_2U;
+ CXiced_tail += CX_q * Q_body * ch_2U;
+ }
+ }
+ /* CX_q must be mulitplied by cbar/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ CX += CX_q * Q_body * cbar_2U;
+ break;
+ }
+ case CX_de_flag:
+ {
+ if (ice_on)
+ {
+ CX_de = uiuc_ice_filter(CX_de_clean,kCX_de);
+ if (beta_model)
+ {
+ CXclean_wing += CX_de_clean * elevator;
+ CXclean_tail += CX_de_clean * elevator;
+ CXiced_wing += CX_de * elevator;
+ CXiced_tail += CX_de * elevator;
+ }
+ }
+ CX += CX_de * elevator;
+ break;
+ }
+ case CX_dr_flag:
+ {
+ if (ice_on)
+ {
+ CX_dr = uiuc_ice_filter(CX_dr_clean,kCX_dr);
+ if (beta_model)
+ {
+ CXclean_wing += CX_dr_clean * rudder;
+ CXclean_tail += CX_dr_clean * rudder;
+ CXiced_wing += CX_dr * rudder;
+ CXiced_tail += CX_dr * rudder;
+ }
+ }
+ CX += CX_dr * rudder;
+ break;
+ }
+ case CX_df_flag:
+ {
+ if (ice_on)
+ {
+ CX_df = uiuc_ice_filter(CX_df_clean,kCX_df);
+ if (beta_model)
+ {
+ CXclean_wing += CX_df_clean * flap;
+ CXclean_tail += CX_df_clean * flap;
+ CXiced_wing += CX * flap;
+ CXiced_tail += CX * flap;
+ }
+ }
+ CX += CX_df * flap;
+ break;
+ }
+ case CX_adf_flag:
+ {
+ if (ice_on)
+ {
+ CX_adf = uiuc_ice_filter(CX_adf_clean,kCX_adf);
+ if (beta_model)
+ {
+ CXclean_wing += CX_adf_clean * Alpha * flap;
+ CXclean_tail += CX_adf_clean * Alpha * flap;
+ CXiced_wing += CX_adf * Alpha * flap;
+ CXiced_tail += CX_adf * Alpha * flap;
+ }
+ }
+ CX += CX_adf * Alpha * flap;
+ break;
+ }
+ };
+ } // end CD map
+
+ return;
+}
+
+// end uiuc_coef_drag.cpp
--- /dev/null
+#ifndef _COEF_DRAG_H_
+#define _COEF_DRAG_H_
+
+#include "uiuc_parsefile.h"
+#include "uiuc_aircraft.h"
+#include "uiuc_1Dinterpolation.h"
+#include "uiuc_2Dinterpolation.h"
+#include "uiuc_ice.h"
+#include "../FDM/LaRCsim/ls_generic.h"
+
+
+void uiuc_coef_drag();
+
+#endif // _COEF_DRAG_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_coef_lift.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: computes aggregated aerodynamic lift coefficient
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES: Roskam, Jan. Airplane Flight Dynamics and Automatic
+ Flight Controls, Part I. Lawrence, KS: DARcorporation,
+ 1995.
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/15/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: -Alpha
+ -elevator
+ -lift coefficient components
+ -icing parameters
+ -cbar_2U multiplier
+
+----------------------------------------------------------------------
+
+ OUTPUTS: -CL
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_coefficients.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: uiuc_1Dinterpolation
+ uiuc_2Dinterpolation
+ uiuc_ice_filter
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_coef_lift.h"
+
+
+void uiuc_coef_lift()
+{
+ string linetoken1;
+ string linetoken2;
+ stack command_list;
+
+ command_list = aeroLiftParts -> getCommands();
+
+ for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
+ {
+ linetoken1 = aeroLiftParts -> getToken(*command_line, 1);
+ linetoken2 = aeroLiftParts -> getToken(*command_line, 2);
+
+ switch (CL_map[linetoken2])
+ {
+ case CLo_flag:
+ {
+ if (ice_on)
+ {
+ CLo = uiuc_ice_filter(CLo_clean,kCLo);
+ if (beta_model)
+ {
+ CLclean_wing += CLo_clean;
+ CLclean_tail += CLo_clean;
+ CLiced_wing += CLo;
+ CLiced_tail += CLo;
+ }
+ }
+ CL += CLo;
+ break;
+ }
+ case CL_a_flag:
+ {
+ if (ice_on)
+ {
+ CL_a = uiuc_ice_filter(CL_a_clean,kCL_a);
+ if (beta_model)
+ {
+ CLclean_wing += CL_a_clean * Alpha;
+ CLclean_tail += CL_a_clean * Alpha;
+ CLiced_wing += CL_a * Alpha;
+ CLiced_tail += CL_a * Alpha;
+ }
+ }
+ CL += CL_a * Alpha;
+ break;
+ }
+ case CL_adot_flag:
+ {
+ if (ice_on)
+ {
+ CL_adot = uiuc_ice_filter(CL_adot_clean,kCL_adot);
+ if (beta_model)
+ {
+ CLclean_wing += CL_adot_clean * Alpha_dot * cbar_2U;
+ CLclean_tail += CL_adot_clean * Alpha_dot * ch_2U;
+ CLiced_wing += CL_adot * Alpha_dot * cbar_2U;
+ CLiced_tail += CL_adot * Alpha_dot * ch_2U;
+ }
+ }
+ /* CL_adot must be mulitplied by cbar/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ CL += CL_adot * Alpha_dot * cbar_2U;
+ break;
+ }
+ case CL_q_flag:
+ {
+ if (ice_on)
+ {
+ CL_q = uiuc_ice_filter(CL_q_clean,kCL_q);
+ if (beta_model)
+ {
+ CLclean_wing += CL_q_clean * Theta_dot * cbar_2U;
+ CLclean_tail += CL_q_clean * Theta_dot * ch_2U;
+ CLiced_wing += CL_q * Theta_dot * cbar_2U;
+ CLiced_tail += CL_q * Theta_dot * ch_2U;
+ }
+ }
+ /* CL_q must be mulitplied by cbar/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ /* why multiply by Theta_dot instead of Q_body?
+ that is what is done in c172_aero.c; assume it
+ has something to do with axes systems */
+ CL += CL_q * Theta_dot * cbar_2U;
+ break;
+ }
+ case CL_ih_flag:
+ {
+ CL += CL_ih * ih;
+ break;
+ }
+ case CL_de_flag:
+ {
+ if (ice_on)
+ {
+ CL_de = uiuc_ice_filter(CL_de_clean,kCL_de);
+ if (beta_model)
+ {
+ CLclean_wing += CL_de_clean * elevator;
+ CLclean_tail += CL_de_clean * elevator;
+ CLiced_wing += CL_de * elevator;
+ CLiced_tail += CL_de * elevator;
+ }
+ }
+ CL += CL_de * elevator;
+ break;
+ }
+ case CLfa_flag:
+ {
+ CLfaI = uiuc_1Dinterpolation(CLfa_aArray,
+ CLfa_CLArray,
+ CLfa_nAlpha,
+ Alpha);
+ CL += CLfaI;
+ break;
+ }
+ case CLfade_flag:
+ {
+ CLfadeI = uiuc_2Dinterpolation(CLfade_aArray,
+ CLfade_deArray,
+ CLfade_CLArray,
+ CLfade_nAlphaArray,
+ CLfade_nde,
+ Alpha,
+ elevator);
+ CL += CLfadeI;
+ break;
+ }
+ case CLfdf_flag:
+ {
+ CLfdfI = uiuc_1Dinterpolation(CLfdf_dfArray,
+ CLfdf_CLArray,
+ CLfdf_ndf,
+ flap);
+ CL += CLfdfI;
+ break;
+ }
+ case CLfadf_flag:
+ {
+ CLfadfI = uiuc_2Dinterpolation(CLfadf_aArray,
+ CLfadf_dfArray,
+ CLfadf_CLArray,
+ CLfadf_nAlphaArray,
+ CLfadf_ndf,
+ Alpha,
+ flap);
+ CL += CLfadfI;
+ break;
+ }
+ case CZo_flag:
+ {
+ if (ice_on)
+ {
+ CZo = uiuc_ice_filter(CZo_clean,kCZo);
+ if (beta_model)
+ {
+ CZclean_wing += CZo_clean;
+ CZclean_tail += CZo_clean;
+ CZiced_wing += CZo;
+ CZiced_tail += CZo;
+ }
+ }
+ CZ += CZo;
+ break;
+ }
+ case CZ_a_flag:
+ {
+ if (ice_on)
+ {
+ CZ_a = uiuc_ice_filter(CZ_a_clean,kCZ_a);
+ if (beta_model)
+ {
+ CZclean_wing += CZ_a_clean * Alpha;
+ CZclean_tail += CZ_a_clean * Alpha;
+ CZiced_wing += CZ_a * Alpha;
+ CZiced_tail += CZ_a * Alpha;
+ }
+ }
+ CZ += CZ_a * Alpha;
+ break;
+ }
+ case CZ_a2_flag:
+ {
+ if (ice_on)
+ {
+ CZ_a2 = uiuc_ice_filter(CZ_a2_clean,kCZ_a2);
+ if (beta_model)
+ {
+ CZclean_wing += CZ_a2_clean * Alpha * Alpha;
+ CZclean_tail += CZ_a2_clean * Alpha * Alpha;
+ CZiced_wing += CZ_a2 * Alpha * Alpha;
+ CZiced_tail += CZ_a2 * Alpha * Alpha;
+ }
+ }
+ CZ += CZ_a2 * Alpha * Alpha;
+ break;
+ }
+ case CZ_a3_flag:
+ {
+ if (ice_on)
+ {
+ CZ_a3 = uiuc_ice_filter(CZ_a3_clean,kCZ_a3);
+ if (beta_model)
+ {
+ CZclean_wing += CZ_a3_clean * Alpha * Alpha * Alpha;
+ CZclean_tail += CZ_a3_clean * Alpha * Alpha * Alpha;
+ CZiced_wing += CZ_a3 * Alpha * Alpha * Alpha;
+ CZiced_tail += CZ_a3 * Alpha * Alpha * Alpha;
+ }
+ }
+ CZ += CZ_a3 * Alpha * Alpha * Alpha;
+ break;
+ }
+ case CZ_adot_flag:
+ {
+ if (ice_on)
+ {
+ CZ_adot = uiuc_ice_filter(CZ_adot_clean,kCZ_adot);
+ if (beta_model)
+ {
+ CZclean_wing += CZ_adot_clean * Alpha_dot * cbar_2U;
+ CZclean_tail += CZ_adot_clean * Alpha_dot * ch_2U;
+ CZiced_wing += CZ_adot * Alpha_dot * cbar_2U;
+ CZiced_tail += CZ_adot * Alpha_dot * ch_2U;
+ }
+ }
+ /* CZ_adot must be mulitplied by cbar/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ CZ += CZ_adot * Alpha_dot * cbar_2U;
+ break;
+ }
+ case CZ_q_flag:
+ {
+ if (ice_on)
+ {
+ CZ_q = uiuc_ice_filter(CZ_q_clean,kCZ_q);
+ if (beta_model)
+ {
+ CZclean_wing += CZ_q_clean * Q_body * cbar_2U;
+ CZclean_tail += CZ_q_clean * Q_body * ch_2U;
+ CZiced_wing += CZ_q * Q_body * cbar_2U;
+ CZiced_tail += CZ_q * Q_body * ch_2U;
+ }
+ }
+ /* CZ_q must be mulitplied by cbar/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ CZ += CZ_q * Q_body * cbar_2U;
+ break;
+ }
+ case CZ_de_flag:
+ {
+ if (ice_on)
+ {
+ CZ_de = uiuc_ice_filter(CZ_de_clean,kCZ_de);
+ if (beta_model)
+ {
+ CZclean_wing += CZ_de_clean * elevator;
+ CZclean_tail += CZ_de_clean * elevator;
+ CZiced_wing += CZ_de * elevator;
+ CZiced_tail += CZ_de * elevator;
+ }
+ }
+ CZ += CZ_de * elevator;
+ break;
+ }
+ case CZ_deb2_flag:
+ {
+ if (ice_on)
+ {
+ CZ_deb2 = uiuc_ice_filter(CZ_deb2_clean,kCZ_deb2);
+ if (beta_model)
+ {
+ CZclean_wing += CZ_deb2_clean * elevator * Beta * Beta;
+ CZclean_tail += CZ_deb2_clean * elevator * Beta * Beta;
+ CZiced_wing += CZ_deb2 * elevator * Beta * Beta;
+ CZiced_tail += CZ_deb2 * elevator * Beta * Beta;
+ }
+ }
+ CZ += CZ_deb2 * elevator * Beta * Beta;
+ break;
+ }
+ case CZ_df_flag:
+ {
+ if (ice_on)
+ {
+ CZ_df = uiuc_ice_filter(CZ_df_clean,kCZ_df);
+ if (beta_model)
+ {
+ CZclean_wing += CZ_df_clean * flap;
+ CZclean_tail += CZ_df_clean * flap;
+ CZiced_wing += CZ_df * flap;
+ CZiced_tail += CZ_df * flap;
+ }
+ }
+ CZ += CZ_df * flap;
+ break;
+ }
+ case CZ_adf_flag:
+ {
+ if (ice_on)
+ {
+ CZ_adf = uiuc_ice_filter(CZ_adf_clean,kCZ_adf);
+ if (beta_model)
+ {
+ CZclean_wing += CZ_adf_clean * Alpha * flap;
+ CZclean_tail += CZ_adf_clean * Alpha * flap;
+ CZiced_wing += CZ_adf * Alpha * flap;
+ CZiced_tail += CZ_adf * Alpha * flap;
+ }
+ }
+ CZ += CZ_adf * Alpha * flap;
+ break;
+ }
+ };
+ } // end CL map
+
+ return;
+}
+
+// end uiuc_coef_lift.cpp
--- /dev/null
+#ifndef _COEF_LIFT_H_
+#define _COEF_LIFT_H_
+
+#include "uiuc_parsefile.h"
+#include "uiuc_aircraft.h"
+#include "uiuc_1Dinterpolation.h"
+#include "uiuc_2Dinterpolation.h"
+#include "uiuc_ice.h"
+#include "../FDM/LaRCsim/ls_generic.h"
+
+
+void uiuc_coef_lift();
+
+#endif // _COEF_LIFT_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_coef_pitch.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: computes aggregated aerodynamic pitch coefficient
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES: Roskam, Jan. Airplane Flight Dynamics and Automatic
+ Flight Controls, Part I. Lawrence, KS: DARcorporation,
+ 1995.
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/15/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: -Alpha
+ -elevator
+ -pitch coefficient components
+ -icing parameters
+ -cbar_2U multiplier
+
+----------------------------------------------------------------------
+
+ OUTPUTS: -Cm
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_coefficients.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: uiuc_1Dinterpolation
+ uiuc_2Dinterpolation
+ uiuc_ice_filter
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_coef_pitch.h"
+
+
+void uiuc_coef_pitch()
+{
+ string linetoken1;
+ string linetoken2;
+ stack command_list;
+
+ command_list = aeroPitchParts -> getCommands();
+
+ for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
+ {
+ linetoken1 = aeroPitchParts -> getToken(*command_line, 1);
+ linetoken2 = aeroPitchParts -> getToken(*command_line, 2);
+
+ switch(Cm_map[linetoken2])
+ {
+ case Cmo_flag:
+ {
+ if (ice_on)
+ {
+ Cmo = uiuc_ice_filter(Cmo_clean,kCmo);
+ }
+ Cm += Cmo;
+ break;
+ }
+ case Cm_a_flag:
+ {
+ if (ice_on)
+ {
+ Cm_a = uiuc_ice_filter(Cm_a_clean,kCm_a);
+ }
+ Cm += Cm_a * Alpha;
+ break;
+ }
+ case Cm_a2_flag:
+ {
+ if (ice_on)
+ {
+ Cm_a2 = uiuc_ice_filter(Cm_a2_clean,kCm_a2);
+ }
+ Cm += Cm_a2 * Alpha * Alpha;
+ break;
+ }
+ case Cm_adot_flag:
+ {
+ if (ice_on)
+ {
+ Cm_adot = uiuc_ice_filter(Cm_adot_clean,kCm_adot);
+ }
+ /* Cm_adot must be mulitplied by cbar/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ Cm += Cm_adot * Alpha_dot * cbar_2U;
+ break;
+ }
+ case Cm_q_flag:
+ {
+ if (ice_on)
+ {
+ Cm_q = uiuc_ice_filter(Cm_q_clean,kCm_q);
+ }
+ /* Cm_q must be mulitplied by cbar/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ Cm += Cm_q * Q_body * cbar_2U;
+ break;
+ }
+ case Cm_ih_flag:
+ {
+ Cm += Cm_ih * ih;
+ break;
+ }
+ case Cm_de_flag:
+ {
+ if (ice_on)
+ {
+ Cm_de = uiuc_ice_filter(Cm_de_clean,kCm_de);
+ }
+ Cm += Cm_de * elevator;
+ break;
+ }
+ case Cm_b2_flag:
+ {
+ if (ice_on)
+ {
+ Cm_b2 = uiuc_ice_filter(Cm_b2_clean,kCm_b2);
+ }
+ Cm += Cm_b2 * Beta * Beta;
+ break;
+ }
+ case Cm_r_flag:
+ {
+ if (ice_on)
+ {
+ Cm_r = uiuc_ice_filter(Cm_r_clean,kCm_r);
+ }
+ Cm += Cm_r * R_body * b_2U;
+ break;
+ }
+ case Cm_df_flag:
+ {
+ if (ice_on)
+ {
+ Cm_df = uiuc_ice_filter(Cm_df_clean,kCm_df);
+ }
+ Cm += Cm_df * flap;
+ break;
+ }
+ case Cmfa_flag:
+ {
+ CmfaI = uiuc_1Dinterpolation(Cmfa_aArray,
+ Cmfa_CmArray,
+ Cmfa_nAlpha,
+ Alpha);
+ Cm += CmfaI;
+ break;
+ }
+ case Cmfade_flag:
+ {
+ CmfadeI = uiuc_2Dinterpolation(Cmfade_aArray,
+ Cmfade_deArray,
+ Cmfade_CmArray,
+ Cmfade_nAlphaArray,
+ Cmfade_nde,
+ Alpha,
+ elevator);
+ Cm += CmfadeI;
+ break;
+ }
+ case Cmfdf_flag:
+ {
+ CmfdfI = uiuc_1Dinterpolation(Cmfdf_dfArray,
+ Cmfdf_CmArray,
+ Cmfdf_ndf,
+ flap);
+ Cm += CmfdfI;
+ break;
+ }
+ case Cmfadf_flag:
+ {
+ CmfadfI = uiuc_2Dinterpolation(Cmfadf_aArray,
+ Cmfadf_dfArray,
+ Cmfadf_CmArray,
+ Cmfadf_nAlphaArray,
+ Cmfadf_ndf,
+ Alpha,
+ flap);
+ Cm += CmfadfI;
+ break;
+ }
+ };
+ } // end Cm map
+
+ return;
+}
+
+// end uiuc_coef_pitch.cpp
--- /dev/null
+#ifndef _COEF_PITCH_H_
+#define _COEF_PITCH_H_
+
+#include "uiuc_parsefile.h"
+#include "uiuc_aircraft.h"
+#include "uiuc_1Dinterpolation.h"
+#include "uiuc_2Dinterpolation.h"
+#include "uiuc_ice.h"
+#include "../FDM/LaRCsim/ls_generic.h"
+
+
+void uiuc_coef_pitch();
+
+#endif // _COEF_PITCH_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_coef_roll.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: computes aggregated aerodynamic roll coefficient
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES: Roskam, Jan. Airplane Flight Dynamics and Automatic
+ Flight Controls, Part I. Lawrence, KS: DARcorporation,
+ 1995.
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/15/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: -Alpha
+ -aileron
+ -rudder
+ -roll coefficient components
+ -icing parameters
+ -b_2U multiplier
+
+----------------------------------------------------------------------
+
+ OUTPUTS: -Cl
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_coefficients.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: uiuc_1Dinterpolation
+ uiuc_2Dinterpolation
+ uiuc_ice_filter
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_coef_roll.h"
+
+
+void uiuc_coef_roll()
+{
+ string linetoken1;
+ string linetoken2;
+ stack command_list;
+
+ command_list = aeroRollParts -> getCommands();
+
+ for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
+ {
+ linetoken1 = aeroRollParts -> getToken(*command_line, 1);
+ linetoken2 = aeroRollParts -> getToken(*command_line, 2);
+
+ switch(Cl_map[linetoken2])
+ {
+ case Clo_flag:
+ {
+ if (ice_on)
+ {
+ Clo = uiuc_ice_filter(Clo_clean,kClo);
+ }
+ Cl += Clo;
+ break;
+ }
+ case Cl_beta_flag:
+ {
+ if (ice_on)
+ {
+ Cl_beta = uiuc_ice_filter(Cl_beta_clean,kCl_beta);
+ }
+ Cl += Cl_beta * Beta;
+ break;
+ }
+ case Cl_p_flag:
+ {
+ if (ice_on)
+ {
+ Cl_p = uiuc_ice_filter(Cl_p_clean,kCl_p);
+ }
+ /* Cl_p must be mulitplied by b/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ Cl += Cl_p * P_body * b_2U;
+ break;
+ }
+ case Cl_r_flag:
+ {
+ if (ice_on)
+ {
+ Cl_r = uiuc_ice_filter(Cl_r_clean,kCl_r);
+ }
+ /* Cl_r must be mulitplied by b/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ Cl += Cl_r * R_body * b_2U;
+ break;
+ }
+ case Cl_da_flag:
+ {
+ if (ice_on)
+ {
+ Cl_da = uiuc_ice_filter(Cl_da_clean,kCl_da);
+ }
+ Cl += Cl_da * aileron;
+ break;
+ }
+ case Cl_dr_flag:
+ {
+ if (ice_on)
+ {
+ Cl_dr = uiuc_ice_filter(Cl_dr_clean,kCl_dr);
+ }
+ Cl += Cl_dr * rudder;
+ break;
+ }
+ case Cl_daa_flag:
+ {
+ if (ice_on)
+ {
+ Cl_daa = uiuc_ice_filter(Cl_daa_clean,kCl_daa);
+ }
+ Cl += Cl_daa * aileron * Alpha;
+ break;
+ }
+ case Clfada_flag:
+ {
+ ClfadaI = uiuc_2Dinterpolation(Clfada_aArray,
+ Clfada_daArray,
+ Clfada_ClArray,
+ Clfada_nAlphaArray,
+ Clfada_nda,
+ Alpha,
+ aileron);
+ Cl += ClfadaI;
+ break;
+ }
+ case Clfbetadr_flag:
+ {
+ ClfbetadrI = uiuc_2Dinterpolation(Clfbetadr_betaArray,
+ Clfbetadr_drArray,
+ Clfbetadr_ClArray,
+ Clfbetadr_nBetaArray,
+ Clfbetadr_ndr,
+ Beta,
+ rudder);
+ Cl += ClfbetadrI;
+ break;
+ }
+ };
+ } // end Cl map
+
+ return;
+}
+
+// end uiuc_coef_roll.cpp
--- /dev/null
+#ifndef _COEF_ROLL_H_
+#define _COEF_ROLL_H_
+
+#include "uiuc_parsefile.h"
+#include "uiuc_aircraft.h"
+#include "uiuc_1Dinterpolation.h"
+#include "uiuc_2Dinterpolation.h"
+#include "uiuc_ice.h"
+#include "../FDM/LaRCsim/ls_generic.h"
+
+
+void uiuc_coef_roll();
+
+#endif // _COEF_ROLL_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_coef_sideforce.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: computes aggregated aerodynamic sideforce coefficient
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES: Roskam, Jan. Airplane Flight Dynamics and Automatic
+ Flight Controls, Part I. Lawrence, KS: DARcorporation,
+ 1995.
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/15/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: -Alpha
+ -aileron
+ -rudder
+ -sideforce coefficient components
+ -icing parameters
+ -b_2U multiplier
+
+----------------------------------------------------------------------
+
+ OUTPUTS: -CY
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_coefficients.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: uiuc_1Dinterpolation
+ uiuc_2Dinterpolation
+ uiuc_ice_filter
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_coef_sideforce.h"
+
+
+void uiuc_coef_sideforce()
+{
+ string linetoken1;
+ string linetoken2;
+ stack command_list;
+
+ command_list = aeroSideforceParts -> getCommands();
+
+ for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
+ {
+ linetoken1 = aeroSideforceParts -> getToken(*command_line, 1);
+ linetoken2 = aeroSideforceParts -> getToken(*command_line, 2);
+
+ switch(CY_map[linetoken2])
+ {
+ case CYo_flag:
+ {
+ if (ice_on)
+ {
+ CYo = uiuc_ice_filter(CYo_clean,kCYo);
+ }
+ CY += CYo;
+ break;
+ }
+ case CY_beta_flag:
+ {
+ if (ice_on)
+ {
+ CY_beta = uiuc_ice_filter(CY_beta_clean,kCY_beta);
+ }
+ CY += CY_beta * Beta;
+ break;
+ }
+ case CY_p_flag:
+ {
+ if (ice_on)
+ {
+ CY_p = uiuc_ice_filter(CY_p_clean,kCY_p);
+ }
+ /* CY_p must be mulitplied by b/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ CY += CY_p * P_body * b_2U;
+ break;
+ }
+ case CY_r_flag:
+ {
+ if (ice_on)
+ {
+ CY_r = uiuc_ice_filter(CY_r_clean,kCY_r);
+ }
+ /* CY_r must be mulitplied by b/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ CY += CY_r * R_body * b_2U;
+ break;
+ }
+ case CY_da_flag:
+ {
+ if (ice_on)
+ {
+ CY_da = uiuc_ice_filter(CY_da_clean,kCY_da);
+ }
+ CY += CY_da * aileron;
+ break;
+ }
+ case CY_dr_flag:
+ {
+ if (ice_on)
+ {
+ CY_dr = uiuc_ice_filter(CY_dr_clean,kCY_dr);
+ }
+ CY += CY_dr * rudder;
+ break;
+ }
+ case CY_dra_flag:
+ {
+ if (ice_on)
+ {
+ CY_dra = uiuc_ice_filter(CY_dra_clean,kCY_dra);
+ }
+ CY += CY_dra * rudder * Alpha;
+ break;
+ }
+ case CY_bdot_flag:
+ {
+ if (ice_on)
+ {
+ CY_bdot = uiuc_ice_filter(CY_bdot_clean,kCY_bdot);
+ }
+ CY += CY_bdot * Beta_dot * b_2U;
+ break;
+ }
+ case CYfada_flag:
+ {
+ CYfadaI = uiuc_2Dinterpolation(CYfada_aArray,
+ CYfada_daArray,
+ CYfada_CYArray,
+ CYfada_nAlphaArray,
+ CYfada_nda,
+ Alpha,
+ aileron);
+ CY += CYfadaI;
+ break;
+ }
+ case CYfbetadr_flag:
+ {
+ CYfbetadrI = uiuc_2Dinterpolation(CYfbetadr_betaArray,
+ CYfbetadr_drArray,
+ CYfbetadr_CYArray,
+ CYfbetadr_nBetaArray,
+ CYfbetadr_ndr,
+ Beta,
+ rudder);
+ CY += CYfbetadrI;
+ break;
+ }
+ };
+ } // end CY map
+
+ return;
+}
+
+// end uiuc_coef_sideforce.cpp
--- /dev/null
+#ifndef _COEF_SIDEFORCE_H_
+#define _COEF_SIDEFORCE_H_
+
+#include "uiuc_parsefile.h"
+#include "uiuc_aircraft.h"
+#include "uiuc_1Dinterpolation.h"
+#include "uiuc_2Dinterpolation.h"
+#include "uiuc_ice.h"
+#include "../FDM/LaRCsim/ls_generic.h"
+
+
+void uiuc_coef_sideforce();
+
+#endif // _COEF_SIDEFORCE_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_coef_yaw.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: computes aggregated aerodynamic yaw coefficient
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES: Roskam, Jan. Airplane Flight Dynamics and Automatic
+ Flight Controls, Part I. Lawrence, KS: DARcorporation,
+ 1995.
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/15/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: -Alpha
+ -aileron
+ -rudder
+ -yaw coefficient components
+ -icing parameters
+ -b_2U multiplier
+
+----------------------------------------------------------------------
+
+ OUTPUTS: -Cn
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_coefficients.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: uiuc_1Dinterpolation
+ uiuc_2Dinterpolation
+ uiuc_ice_filter
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_coef_yaw.h"
+
+
+void uiuc_coef_yaw()
+{
+ string linetoken1;
+ string linetoken2;
+ stack command_list;
+
+ command_list = aeroYawParts -> getCommands();
+
+ for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
+ {
+ linetoken1 = aeroYawParts -> getToken(*command_line, 1);
+ linetoken2 = aeroYawParts -> getToken(*command_line, 2);
+
+ switch(Cn_map[linetoken2])
+ {
+ case Cno_flag:
+ {
+ if (ice_on)
+ {
+ Cno = uiuc_ice_filter(Cno_clean,kCno);
+ }
+ Cn += Cno;
+ break;
+ }
+ case Cn_beta_flag:
+ {
+ if (ice_on)
+ {
+ Cn_beta = uiuc_ice_filter(Cn_beta_clean,kCn_beta);
+ }
+ Cn += Cn_beta * Beta;
+ break;
+ }
+ case Cn_p_flag:
+ {
+ if (ice_on)
+ {
+ Cn_p = uiuc_ice_filter(Cn_p_clean,kCn_p);
+ }
+ /* Cn_p must be mulitplied by b/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ Cn += Cn_p * P_body * b_2U;
+ break;
+ }
+ case Cn_r_flag:
+ {
+ if (ice_on)
+ {
+ Cn_r = uiuc_ice_filter(Cn_r_clean,kCn_r);
+ }
+ /* Cn_r must be mulitplied by b/2U
+ (see Roskam Control book, Part 1, pg. 147) */
+ Cn += Cn_r * R_body * b_2U;
+ break;
+ }
+ case Cn_da_flag:
+ {
+ if (ice_on)
+ {
+ Cn_da = uiuc_ice_filter(Cn_da_clean,kCn_da);
+ }
+ Cn += Cn_da * aileron;
+ break;
+ }
+ case Cn_dr_flag:
+ {
+ if (ice_on)
+ {
+ Cn_dr = uiuc_ice_filter(Cn_dr_clean,kCn_dr);
+ }
+ Cn += Cn_dr * rudder;
+ break;
+ }
+ case Cn_q_flag:
+ {
+ if (ice_on)
+ {
+ Cn_q = uiuc_ice_filter(Cn_q_clean,kCn_q);
+ }
+ Cn += Cn_q * Q_body * cbar_2U;
+ break;
+ }
+ case Cn_b3_flag:
+ {
+ if (ice_on)
+ {
+ Cn_b3 = uiuc_ice_filter(Cn_b3_clean,kCn_b3);
+ }
+ Cn += Cn_b3 * Beta * Beta * Beta;
+ break;
+ }
+ case Cnfada_flag:
+ {
+ CnfadaI = uiuc_2Dinterpolation(Cnfada_aArray,
+ Cnfada_daArray,
+ Cnfada_CnArray,
+ Cnfada_nAlphaArray,
+ Cnfada_nda,
+ Alpha,
+ aileron);
+ Cn += CnfadaI;
+ break;
+ }
+ case Cnfbetadr_flag:
+ {
+ CnfbetadrI = uiuc_2Dinterpolation(Cnfbetadr_betaArray,
+ Cnfbetadr_drArray,
+ Cnfbetadr_CnArray,
+ Cnfbetadr_nBetaArray,
+ Cnfbetadr_ndr,
+ Beta,
+ rudder);
+ Cn += CnfbetadrI;
+ break;
+ }
+ };
+ } // end Cn map
+
+ return;
+}
+
+// end uiuc_coef_yaw.cpp
--- /dev/null
+#ifndef _COEF_YAW_H_
+#define _COEF_YAW_H_
+
+#include "uiuc_parsefile.h"
+#include "uiuc_aircraft.h"
+#include "uiuc_1Dinterpolation.h"
+#include "uiuc_2Dinterpolation.h"
+#include "uiuc_ice.h"
+#include "../FDM/LaRCsim/ls_generic.h"
+
+
+void uiuc_coef_yaw();
+
+#endif // _COEF_YAW_H_
----------------------------------------------------------------------
- REFERENCES: Roskam, Jan. Airplane Flight Dynamics and Automatic
- Flight Controls, Part I. Lawrence, KS: DARcorporation,
- 1995.
+ REFERENCES:
----------------------------------------------------------------------
function from CLfade, CDfade, Cmfade,
CYfada, CYfbetadr, Clfada, Clfbetadr,
Cnfada, and Cnfbetadr switches
+ 04/15/2000 (JS) broke up into multiple
+ uiuc_coef_xxx functions
----------------------------------------------------------------------
----------------------------------------------------------------------
- INPUTS: -Alpha
- -aileron
- -elevator
- -rudder
- -coefficient components
+ INPUTS: -V_rel_wind (or U_body)
+ -dyn_on_speed
+ -ice on/off
+ -phugoid on/off
----------------------------------------------------------------------
----------------------------------------------------------------------
- CALLED BY: ?
+ CALLED BY: uiuc_wrapper
----------------------------------------------------------------------
- CALLS TO: uiuc_1Dinterpolation
- uiuc_2Dinterpolation
- uiuc_ice
+ CALLS TO: uiuc_coef_lift
+ uiuc_coef_drag
+ uiuc_coef_pitch
+ uiuc_coef_sideforce
+ uiuc_coef_roll
+ uiuc_coef_yaw
+ uiuc_controlInput
----------------------------------------------------------------------
#include "uiuc_coefficients.h"
-/* set speed at which dynamic pressure terms will be accounted for
- since if velocity is too small, coefficients will go to infinity */
-
-#define ON_VELOCITY 33 /* 20 kts */
-
-
void uiuc_coefficients()
{
- string linetoken1;
- string linetoken2;
- stack command_list;
- double cbar_2U = 0, b_2U = 0;
- double slope = 0;
- bool ice_on = false;
-
- // determine if speed is sufficient to compute dynamic pressure
- if (U_body > ON_VELOCITY)
+ // calculate rate derivative nondimensionalization factors
+ // check if speed is sufficient to compute dynamic pressure terms
+ if (nondim_rate_V_rel_wind) // c172_aero uses V_rel_wind
{
- cbar_2U = cbar / (2.0 * U_body);
- b_2U = bw / (2.0 * U_body);
+ if (V_rel_wind > dyn_on_speed)
+ {
+ cbar_2U = cbar / (2.0 * V_rel_wind);
+ b_2U = bw / (2.0 * V_rel_wind);
+ ch_2U = ch / (2.0 * V_rel_wind);
+ }
+ else
+ {
+ cbar_2U = 0.0;
+ b_2U = 0.0;
+ ch_2U = 0.0;
+ }
}
- else
+ else // use U_body which is probably more correct
{
- cbar_2U = 0.0;
- b_2U = 0.0;
+ if (U_body > dyn_on_speed)
+ {
+ cbar_2U = cbar / (2.0 * U_body);
+ b_2U = bw / (2.0 * U_body);
+ ch_2U = ch / (2.0 * U_body);
+ }
+ else
+ {
+ cbar_2U = 0.0;
+ b_2U = 0.0;
+ ch_2U = 0.0;
+ }
}
- //check to see if icing model engaged and set flag
- if (Simtime >= iceTime)
+ // check to see if icing model engaged
+ if (ice_model)
{
- ice_on = true;
+ uiuc_ice_eta();
}
- // slowly increase icing severity over period of transientTime
- if (Simtime >= iceTime && Simtime < (iceTime + transientTime))
+ // check to see if phugoid mode engaged
+ if (elevator_step || elevator_singlet || elevator_doublet || elevator_input)
{
- slope = eta_final / transientTime;
- eta = slope * (Simtime - iceTime);
- }
- else
- {
- eta = eta_final;
+ uiuc_controlInput();
}
- CL = CD = Cm = CY = Cl = Cn = 0.0;
- command_list = aeroParts -> getCommands();
-
-
- for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
- {
- linetoken1 = aeroParts -> getToken(*command_line, 1); // function parameters gettoken(string,tokenNo);
- linetoken2 = aeroParts -> getToken(*command_line, 2); // 2 represents token No 2
-
- switch (Keyword_map[linetoken1])
- {
- case CD_flag:
- {
- switch(CD_map[linetoken2])
- {
- case CDo_flag:
- {
- if (ice_on == true)
- {
- CDo = uiuc_ice(CDo_clean,kCDo,eta);
- }
- CD += CDo;
- break;
- }
- case CDK_flag:
- {
- if (ice_on == true)
- {
- CDK = uiuc_ice(CDK_clean,kCDK,eta);
- }
- CD += CDK * CL * CL;
- break;
- }
- case CD_a_flag:
- {
- if (ice_on == true)
- {
- CD_a = uiuc_ice(CD_a_clean,kCD_a,eta);
- }
- CD += CD_a * Alpha;
- break;
- }
- case CD_de_flag:
- {
- if (ice_on == true)
- {
- CD_de = uiuc_ice(CD_de_clean,kCD_de,eta);
- }
- CD += CD_de * elevator;
- break;
- }
- case CDfa_flag:
- {
- CDfaI = uiuc_1Dinterpolation(CDfa_aArray,
- CDfa_CDArray,
- CDfa_nAlpha,
- Alpha);
- CD += CDfaI;
- break;
- }
- case CDfade_flag:
- {
- CDfadeI = uiuc_2Dinterpolation(CDfade_aArray,
- CDfade_deArray,
- CDfade_CDArray,
- CDfade_nAlphaArray,
- CDfade_nde,
- Alpha,
- elevator);
- CD += CDfadeI;
- break;
- }
- };
- break;
- } // end CD map
- case CL_flag:
- {
- switch(CL_map[linetoken2])
- {
- case CLo_flag:
- {
- if (ice_on == true)
- {
- CLo = uiuc_ice(CLo_clean,kCLo,eta);
- }
- CL += CLo;
- break;
- }
- case CL_a_flag:
- {
- if (ice_on == true)
- {
- CL_a = uiuc_ice(CL_a_clean,kCL_a,eta);
- }
- CL += CL_a * Alpha;
- break;
- }
- case CL_adot_flag:
- {
- if (ice_on == true)
- {
- CL_adot = uiuc_ice(CL_adot_clean,kCL_a,eta);
- }
- /* CL_adot must be mulitplied by cbar/2U
- (see Roskam Control book, Part 1, pg. 147) */
- CL += CL_adot * Alpha_dot * cbar_2U;
- break;
- }
- case CL_q_flag:
- {
- if (ice_on == true)
- {
- CL_q = uiuc_ice(CL_q_clean,kCL_q,eta);
- }
- /* CL_q must be mulitplied by cbar/2U
- (see Roskam Control book, Part 1, pg. 147) */
- /* why multiply by Theta_dot instead of Q_body?
- that is what is done in c172_aero.c; assume it
- has something to do with axes systems */
- CL += CL_q * Theta_dot * cbar_2U;
- break;
- }
- case CL_de_flag:
- {
- if (ice_on == true)
- {
- CL_de = uiuc_ice(CL_de_clean,kCL_de,eta);
- }
- CL += CL_de * elevator;
- break;
- }
- case CLfa_flag:
- {
- CLfaI = uiuc_1Dinterpolation(CLfa_aArray,
- CLfa_CLArray,
- CLfa_nAlpha,
- Alpha);
- CL += CLfaI;
- break;
- }
- case CLfade_flag:
- {
- CLfadeI = uiuc_2Dinterpolation(CLfade_aArray,
- CLfade_deArray,
- CLfade_CLArray,
- CLfade_nAlphaArray,
- CLfade_nde,
- Alpha,
- elevator);
- CL += CLfadeI;
- break;
- }
- };
- break;
- } // end CL map
- case Cm_flag:
- {
- switch(Cm_map[linetoken2])
- {
- case Cmo_flag:
- {
- if (ice_on == true)
- {
- Cmo = uiuc_ice(Cmo_clean,kCmo,eta);
- }
- Cm += Cmo;
- break;
- }
- case Cm_a_flag:
- {
- if (ice_on == true)
- {
- Cm_a = uiuc_ice(Cm_a_clean,kCm_a,eta);
- }
- Cm += Cm_a * Alpha;
- break;
- }
- case Cm_adot_flag:
- {
- if (ice_on == true)
- {
- Cm_adot = uiuc_ice(Cm_adot_clean,kCm_a,eta);
- }
- /* Cm_adot must be mulitplied by cbar/2U
- (see Roskam Control book, Part 1, pg. 147) */
- Cm += Cm_adot * Alpha_dot * cbar_2U;
- break;
- }
- case Cm_q_flag:
- {
- if (ice_on == true)
- {
- Cm_q = uiuc_ice(Cm_q_clean,kCm_q,eta);
- }
- /* Cm_q must be mulitplied by cbar/2U
- (see Roskam Control book, Part 1, pg. 147) */
- Cm += Cm_q * Q_body * cbar_2U;
- break;
- }
- case Cm_de_flag:
- {
- if (ice_on == true)
- {
- Cm_de = uiuc_ice(Cm_de_clean,kCm_de,eta);
- }
- Cm += Cm_de * elevator;
- break;
- }
- case Cmfade_flag:
- {
- CmfadeI = uiuc_2Dinterpolation(Cmfade_aArray,
- Cmfade_deArray,
- Cmfade_CmArray,
- Cmfade_nAlphaArray,
- Cmfade_nde,
- Alpha,
- elevator);
- Cm += CmfadeI;
- break;
- }
- };
- break;
- } // end Cm map
- case CY_flag:
- {
- switch(CY_map[linetoken2])
- {
- case CYo_flag:
- {
- if (ice_on == true)
- {
- CYo = uiuc_ice(CYo_clean,kCYo,eta);
- }
- CY += CYo;
- break;
- }
- case CY_beta_flag:
- {
- if (ice_on == true)
- {
- CY_beta = uiuc_ice(CY_beta_clean,kCY_beta,eta);
- }
- CY += CY_beta * Beta;
- break;
- }
- case CY_p_flag:
- {
- if (ice_on == true)
- {
- CY_p = uiuc_ice(CY_p_clean,kCY_p,eta);
- }
- /* CY_p must be mulitplied by b/2U
- (see Roskam Control book, Part 1, pg. 147) */
- CY += CY_p * P_body * b_2U;
- break;
- }
- case CY_r_flag:
- {
- if (ice_on == true)
- {
- CY_r = uiuc_ice(CY_r_clean,kCY_r,eta);
- }
- /* CY_r must be mulitplied by b/2U
- (see Roskam Control book, Part 1, pg. 147) */
- CY += CY_r * R_body * b_2U;
- break;
- }
- case CY_da_flag:
- {
- if (ice_on == true)
- {
- CY_da = uiuc_ice(CY_da_clean,kCY_da,eta);
- }
- CY += CY_da * aileron;
- break;
- }
- case CY_dr_flag:
- {
- if (ice_on == true)
- {
- CY_dr = uiuc_ice(CY_dr_clean,kCY_dr,eta);
- }
- CY += CY_dr * rudder;
- break;
- }
- case CYfada_flag:
- {
- CYfadaI = uiuc_2Dinterpolation(CYfada_aArray,
- CYfada_daArray,
- CYfada_CYArray,
- CYfada_nAlphaArray,
- CYfada_nda,
- Alpha,
- aileron);
- CY += CYfadaI;
- break;
- }
- case CYfbetadr_flag:
- {
- CYfbetadrI = uiuc_2Dinterpolation(CYfbetadr_betaArray,
- CYfbetadr_drArray,
- CYfbetadr_CYArray,
- CYfbetadr_nBetaArray,
- CYfbetadr_ndr,
- Beta,
- rudder);
- CY += CYfbetadrI;
- break;
- }
- };
- break;
- } // end CY map
- case Cl_flag:
- {
- switch(Cl_map[linetoken2])
- {
- case Clo_flag:
- {
- if (ice_on == true)
- {
- Clo = uiuc_ice(Clo_clean,kClo,eta);
- }
- Cl += Clo;
- break;
- }
- case Cl_beta_flag:
- {
- if (ice_on == true)
- {
- Cl_beta = uiuc_ice(Cl_beta_clean,kCl_beta,eta);
- }
- Cl += Cl_beta * Beta;
- break;
- }
- case Cl_p_flag:
- {
- if (ice_on == true)
- {
- Cl_p = uiuc_ice(Cl_p_clean,kCl_p,eta);
- }
- /* Cl_p must be mulitplied by b/2U
- (see Roskam Control book, Part 1, pg. 147) */
- Cl += Cl_p * P_body * b_2U;
- break;
- }
- case Cl_r_flag:
- {
- if (ice_on == true)
- {
- Cl_r = uiuc_ice(Cl_r_clean,kCl_r,eta);
- }
- /* Cl_r must be mulitplied by b/2U
- (see Roskam Control book, Part 1, pg. 147) */
- Cl += Cl_r * R_body * b_2U;
- break;
- }
- case Cl_da_flag:
- {
- if (ice_on == true)
- {
- Cl_da = uiuc_ice(Cl_da_clean,kCl_da,eta);
- }
- Cl += Cl_da * aileron;
- break;
- }
- case Cl_dr_flag:
- {
- if (ice_on == true)
- {
- Cl_dr = uiuc_ice(Cl_dr_clean,kCl_dr,eta);
- }
- Cl += Cl_dr * rudder;
- break;
- }
- case Clfada_flag:
- {
- ClfadaI = uiuc_2Dinterpolation(Clfada_aArray,
- Clfada_daArray,
- Clfada_ClArray,
- Clfada_nAlphaArray,
- Clfada_nda,
- Alpha,
- aileron);
- Cl += ClfadaI;
- break;
- }
- case Clfbetadr_flag:
- {
- ClfbetadrI = uiuc_2Dinterpolation(Clfbetadr_betaArray,
- Clfbetadr_drArray,
- Clfbetadr_ClArray,
- Clfbetadr_nBetaArray,
- Clfbetadr_ndr,
- Beta,
- rudder);
- Cl += ClfbetadrI;
- break;
- }
- };
- break;
- } // end Cl map
- case Cn_flag:
- {
- switch(Cn_map[linetoken2])
- {
- case Cno_flag:
- {
- if (ice_on == true)
- {
- Cno = uiuc_ice(Cno_clean,kCno,eta);
- }
- Cn += Cno;
- break;
- }
- case Cn_beta_flag:
- {
- if (ice_on == true)
- {
- Cn_beta = uiuc_ice(Cn_beta_clean,kCn_beta,eta);
- }
- Cn += Cn_beta * Beta;
- break;
- }
- case Cn_p_flag:
- {
- if (ice_on == true)
- {
- Cn_p = uiuc_ice(Cn_p_clean,kCn_p,eta);
- }
- /* Cn_p must be mulitplied by b/2U
- (see Roskam Control book, Part 1, pg. 147) */
- Cn += Cn_p * P_body * b_2U;
- break;
- }
- case Cn_r_flag:
- {
- if (ice_on == true)
- {
- Cn_r = uiuc_ice(Cn_r_clean,kCn_r,eta);
- }
- /* Cn_r must be mulitplied by b/2U
- (see Roskam Control book, Part 1, pg. 147) */
- Cn += Cn_r * R_body * b_2U;
- break;
- }
- case Cn_da_flag:
- {
- if (ice_on == true)
- {
- Cn_da = uiuc_ice(Cn_da_clean,kCn_da,eta);
- }
- Cn += Cn_da * aileron;
- break;
- }
- case Cn_dr_flag:
- {
- if (ice_on == true)
- {
- Cn_dr = uiuc_ice(Cn_dr_clean,kCn_dr,eta);
- }
- Cn += Cn_dr * rudder;
- break;
- }
- case Cnfada_flag:
- {
- CnfadaI = uiuc_2Dinterpolation(Cnfada_aArray,
- Cnfada_daArray,
- Cnfada_CnArray,
- Cnfada_nAlphaArray,
- Cnfada_nda,
- Alpha,
- aileron);
- Cn += CnfadaI;
- break;
- }
- case Cnfbetadr_flag:
- {
- CnfbetadrI = uiuc_2Dinterpolation(Cnfbetadr_betaArray,
- Cnfbetadr_drArray,
- Cnfbetadr_CnArray,
- Cnfbetadr_nBetaArray,
- Cnfbetadr_ndr,
- Beta,
- rudder);
- Cn += CnfbetadrI;
- break;
- }
- };
- break;
- } // end Cn map
- };
- } // end keyword map
+ CD = CX = CL = CZ = Cm = CY = Cl = Cn = 0.0;
+ CLclean_wing = CLiced_wing = CLclean_tail = CLiced_tail = 0.0;
+ CZclean_wing = CZiced_wing = CZclean_tail = CZiced_tail = 0.0;
+ CXclean_wing = CXiced_wing = CXclean_tail = CXiced_tail = 0.0;
+
+ uiuc_coef_lift();
+ uiuc_coef_drag();
+ uiuc_coef_pitch();
+ uiuc_coef_sideforce();
+ uiuc_coef_roll();
+ uiuc_coef_yaw();
return;
}
+#ifndef _COEFFICIENTS_H_
+#define _COEFFICIENTS_H_
-#include "uiuc_parsefile.h"
#include "uiuc_aircraft.h"
-#include "uiuc_1Dinterpolation.h"
-#include "uiuc_2Dinterpolation.h"
-#include "uiuc_ice.h"
+#include "uiuc_controlInput.h"
+#include "uiuc_coef_drag.h"
+#include "uiuc_coef_lift.h"
+#include "uiuc_coef_pitch.h"
+#include "uiuc_coef_sideforce.h"
+#include "uiuc_coef_roll.h"
+#include "uiuc_coef_yaw.h"
#include "../LaRCsim/ls_generic.h"
-extern "C" SCALAR Simtime;
void uiuc_coefficients();
+
+#endif // _COEFFICIENTS_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_controlInput.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: sets control surface deflections for specified input
+ modes
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/08/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: -Simtime
+ -deflection times
+ -deflection angles
+
+----------------------------------------------------------------------
+
+ OUTPUTS: -elevator deflection
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_coefficients.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_controlInput.h"
+#include <iostream.h>
+
+void uiuc_controlInput()
+{
+ // elevator step input
+ if (elevator_step)
+ {
+ if (Simtime >= elevator_step_startTime)
+ {
+ elevator = elevator + elevator_step_angle;
+ }
+ }
+
+ // elevator singlet input
+ if (elevator_singlet)
+ {
+ if (Simtime >= elevator_singlet_startTime &&
+ Simtime <= (elevator_singlet_startTime + elevator_singlet_duration))
+ {
+ elevator = elevator + elevator_singlet_angle;
+ }
+ }
+
+ // elevator doublet input
+ if (elevator_doublet)
+ {
+ if (Simtime >= elevator_doublet_startTime &&
+ Simtime <= (elevator_doublet_startTime + elevator_doublet_duration/2))
+ {
+ elevator = elevator + elevator_doublet_angle;
+ }
+ else if (Simtime >= (elevator_doublet_startTime + elevator_doublet_duration/2) &&
+ Simtime <= (elevator_doublet_startTime + elevator_doublet_duration))
+ {
+ elevator = elevator - elevator_doublet_angle;
+ }
+ }
+
+ // elevator input
+ if (elevator_input)
+ {
+ double elevator_input_endTime = elevator_input_timeArray[elevator_input_ntime];
+ if (Simtime >= elevator_input_startTime &&
+ Simtime <= (elevator_input_startTime + elevator_input_endTime))
+ {
+ double time = Simtime - elevator_input_startTime;
+ elevator = elevator +
+ uiuc_1Dinterpolation(elevator_input_timeArray,
+ elevator_input_deArray,
+ elevator_input_ntime,
+ time);
+ }
+ }
+ return;
+}
+
+// end uiuc_controlInput.cpp
--- /dev/null
+#ifndef _CONTROLINPUT_H_
+#define _CONTROLINPUT_H_
+
+#include "uiuc_aircraft.h"
+#include "uiuc_1Dinterpolation.h"
+
+extern double Simtime;
+
+
+void uiuc_controlInput();
+
+#endif // _CONTROLINPUT_H_
----------------------------------------------------------------------
- INPUTS: -coversion type
+ INPUTS: -conversion type
----------------------------------------------------------------------
{
case 0:
{
+ /* no conversion, multiply by 1 */
factor = 1;
break;
}
case 1:
{
+ /* convert from degrees to radians */
factor = DEG_TO_RAD;
break;
}
----------------------------------------------------------------------
- REFERENCES: based on portions of c172_engine.c, called from ls_model
+ REFERENCES: simple and c172 models based on portions of
+ c172_engine.c, called from ls_model;
+ cherokee model based on cherokee_engine.c
----------------------------------------------------------------------
string linetoken1;
string linetoken2;
- /* [] mss questions: why do this here ... and then undo it later?
- ... does Throttle[3] get modified? */
Throttle[3] = Throttle_pct;
command_list = engineParts -> getCommands();
-
+
+ /*
if (command_list.begin() == command_list.end())
{
cerr << "ERROR: Engine not specified. Aircraft cannot fly without the engine" << endl;
exit(-1);
}
+ */
for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
{
//cout << *command_line << endl;
- linetoken1 = engineParts -> getToken(*command_line, 1); // function parameters gettoken(string,tokenNo);
- linetoken2 = engineParts -> getToken(*command_line, 2); // 2 represents token No 2
+ linetoken1 = engineParts -> getToken(*command_line, 1);
+ linetoken2 = engineParts -> getToken(*command_line, 2);
switch(engine_map[linetoken2])
- {
- case simpleSingle_flag:
- {
- //c172 engine lines ... looks like 0.83 is just a thrust reduction
- /* F_X_engine = Throttle[3]*350/0.83; */
- /* F_Z_engine = Throttle[3]*4.9/0.83; */
- /* M_m_engine = F_X_engine*0.734*cbar; */
- F_X_engine = Throttle[3]*simpleSingleMaxThrust;
- break;
- }
- case c172_flag:
- {
- F_X_engine = Throttle[3]*350/0.83;
- F_Z_engine = Throttle[3]*4.9/0.83;
- M_m_engine = F_X_engine*0.734*cbar;
- break;
- }
- };
-
- Throttle_pct = Throttle[3];
- return;
+ {
+ case simpleSingle_flag:
+ {
+ F_X_engine = Throttle[3] * simpleSingleMaxThrust;
+ break;
+ }
+ case c172_flag:
+ {
+ //c172 engine lines ... looks like 0.83 is just a thrust increase
+ F_X_engine = Throttle[3] * 350 / 0.83;
+ F_Z_engine = Throttle[3] * 4.9 / 0.83;
+ M_m_engine = F_X_engine * 0.734 * cbar;
+ break;
+ }
+ case cherokee_flag:
+ {
+ static float
+ dP = (180.0-117.0)*745.7, // Watts
+ dn = (2700.0-2350.0)/60.0, // d_rpm (I mean d_rps, in seconds)
+ D = 6.17*0.3048, // prop diameter
+ dPh = (58.0-180.0)*745.7, // change of power as function of height
+ dH = 25000.0*0.3048;
+
+ float
+ n, // [rps]
+ H, // altitude [m]
+ J, // advance ratio (ratio of horizontal speed to prop tip speed)
+ T, // thrust [N]
+ V, // velocity [m/s]
+ P, // power [W]
+ eta_engine; // engine efficiency
+
+ /* assumption -> 0.0 <= Throttle[3] <=1.0 */
+ P = fabs(Throttle[3]) * 180.0 * 745.7; /*180.0*745.7 ->max avail power [W]*/
+ n = dn/dP * (P-117.0*745.7) + 2350.0/60.0;
+
+ /* V [m/s] */
+ V = (V_rel_wind < 10.0 ? 10.0 : V_rel_wind*0.3048);
+ J = V / n / D;
+
+ /* Propeller efficiency */
+ eta_engine = (J < 0.7 ? ((0.8-0.55)/(.7-.3)*(J-0.3) + 0.55) :
+ (J > 0.85 ? ((0.6-0.8)/(1.0-0.85)*(J-0.85) + 0.8) : 0.8));
+
+ /* power on Altitude */
+ H = Altitude * 0.3048; /* H == Altitude [m] */
+ P *= (dPh/dH * H + 180.0*745.7) / (180.0*745.7);
+ T = eta_engine * P/V; /* Thrust [N] */
+
+ /*assumption: Engine's line of thrust passes through cg */
+ F_X_engine = T * 0.2248; /* F_X_engine in lb */
+ F_Y_engine = 0.0;
+ F_Z_engine = 0.0;
+ break;
+ }
+ };
}
+ return;
}
// end uiuc_engine.cpp
#define _ENGINE_H_
#include "uiuc_aircraft.h"
-#include "uiuc_warnings_errors.h" /* for cerr, exit() */
#include "../LaRCsim/ls_generic.h"
#include "../LaRCsim/ls_cockpit.h"
void uiuc_engine();
-
#endif // _ENGINE_H_
----------------------------------------------------------------------
HISTORY: 02/22/2000 initial release
+ 04/25/2000 (JS) added uiuc_ice_eta function
+ (removed from uiuc_coefficients)
----------------------------------------------------------------------
VARIABLES:
-------------------------------------------------string ----------------------
+----------------------------------------------------------------------
+
+ INPUTS: uiuc_ice_eta:
+ -Simtime
+ -icing times
+ -final icing severity (eta_ice_final)
- INPUTS: -clean aero coefficient
+ uiuc_ice_filter:
+ -clean aero coefficient
-icing parameter for that coefficient (kC)
- -icing severity (eta)
+ -icing severity (eta_ice)
----------------------------------------------------------------------
- OUTPUTS: -iced aero coefficient
+ OUTPUTS: uiuc_ice_eta:
+ -icing severity (eta_ice)
+
+ uiuc_ice_filter:
+ -iced aero coefficient
----------------------------------------------------------------------
- CALLED BY: uiuc_coefficients.cpp
+ CALLED BY: uiuc_coefficients
+ uiuc_coef_drag
+ uiuc_coef_lift
+ uiuc_coef_pitch
+ uiuc_coef_sideforce
+ uiuc_coef_roll
+ uiuc_coef_yaw
----------------------------------------------------------------------
#include "uiuc_ice.h"
-double uiuc_ice( double Ca_clean, double kCa, double eta_temp )
+void uiuc_ice_eta()
+{
+ double slope = 0;
+
+ if (Simtime >= iceTime)
+ {
+ // set ice_on flag
+ ice_on = true;
+
+ // slowly increase icing severity over period of transientTime
+ if (Simtime < (iceTime + transientTime))
+ {
+ slope = eta_ice_final / transientTime;
+ eta_ice = slope * (Simtime - iceTime);
+ }
+ else
+ {
+ eta_ice = eta_ice_final;
+ }
+ }
+ return;
+}
+
+
+double uiuc_ice_filter( double Ca_clean, double kCa )
{
double Ca_iced = 0;
//cout << "Ice Model Engaged" << endl;
- Ca_iced = Ca_clean * (1 + kCa * eta_temp);
+ Ca_iced = Ca_clean * (1 + kCa * eta_ice);
return Ca_iced;
}
#ifndef _ICE_H_
#define _ICE_H_
-double uiuc_ice( double Ca_clean, double kCa, double eta_temp );
+#include "uiuc_aircraft.h"
+
+extern double Simtime;
+
+
+void uiuc_ice_eta();
+
+double uiuc_ice_filter( double Ca_clean, double kCa );
#endif // _ICE_H_
/**********************************************************************
- *
- * FILENAME: uiuc_initializemaps.cpp
- *
- * ----------------------------------------------------------------------
- *
- * DESCRIPTION: Initializes the maps for various keywords
- *
- * ----------------------------------------------------------------------
- *
- * STATUS: alpha version
- *
- * ----------------------------------------------------------------------
- *
- * REFERENCES:
- *
- * ----------------------------------------------------------------------
- *
- * HISTORY: 01/26/2000 initial release
- *
- * ----------------------------------------------------------------------
- *
- * AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
- *
- * ----------------------------------------------------------------------
- *
- * VARIABLES:
- *
- * ----------------------------------------------------------------------
- *
- * INPUTS: *
- *
- * ----------------------------------------------------------------------
- *
- * OUTPUTS: *
- *
- * ----------------------------------------------------------------------
- *
- * CALLED BY: uiuc_wrapper.cpp
- *
- * ----------------------------------------------------------------------
- *
- * CALLS TO: *
- *
- * ----------------------------------------------------------------------
- *
- * COPYRIGHT: (C) 2000 by Michael Selig
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
- * USA or view http://www.gnu.org/copyleft/gpl.html.
- *
- ***********************************************************************/
+
+ FILENAME: uiuc_initializemaps.cpp
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the maps for various keywords
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 01/26/2000 initial release
+ 04/08/2000 broke up into multiple map_xxxx functions
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_wrapper.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
#include "uiuc_initializemaps.h"
-void uiuc_initializemaps ()
+
+void uiuc_initializemaps()
{
- uiuc_initializemaps1();
- uiuc_initializemaps2();
- uiuc_initializemaps3();
- uiuc_initializemaps4();
+ uiuc_map_keyword();
+ uiuc_map_init();
+ uiuc_map_geometry();
+ uiuc_map_controlSurface();
+ uiuc_map_mass();
+ uiuc_map_engine();
+ uiuc_map_CD();
+ uiuc_map_CL();
+ uiuc_map_Cm();
+ uiuc_map_CY();
+ uiuc_map_Croll();
+ uiuc_map_Cn();
+ // uiuc_map_gear();
+ uiuc_map_ice();
+ uiuc_map_record1();
+ uiuc_map_record2();
+ uiuc_map_record3();
+ uiuc_map_record4();
+ uiuc_map_record5();
+ uiuc_map_misc();
}
// end uiuc_initializemaps.cpp
#define _INITIALIZEMAPS_H_
#include "uiuc_aircraft.h"
+#include "uiuc_map_keyword.h"
+#include "uiuc_map_init.h"
+#include "uiuc_map_geometry.h"
+#include "uiuc_map_controlSurface.h"
+#include "uiuc_map_mass.h"
+#include "uiuc_map_engine.h"
+#include "uiuc_map_CD.h"
+#include "uiuc_map_CL.h"
+#include "uiuc_map_Cm.h"
+#include "uiuc_map_CY.h"
+#include "uiuc_map_Croll.h"
+#include "uiuc_map_Cn.h"
+#include "uiuc_map_ice.h"
+#include "uiuc_map_record1.h"
+#include "uiuc_map_record2.h"
+#include "uiuc_map_record3.h"
+#include "uiuc_map_record4.h"
+#include "uiuc_map_record5.h"
+#include "uiuc_map_misc.h"
void uiuc_initializemaps();
-/* split this routine up into smaller chunks so it can be digested by
- average machines */
-void uiuc_initializemaps1();
-void uiuc_initializemaps2();
-void uiuc_initializemaps3();
-void uiuc_initializemaps4();
-
#endif // _INITIALIZEMAPS_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_CD.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the CD map
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/08/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_CD.h"
+
+
+void uiuc_map_CD()
+{
+ CD_map["CDo"] = CDo_flag ;
+ CD_map["CDK"] = CDK_flag ;
+ CD_map["CD_a"] = CD_a_flag ;
+ CD_map["CD_adot"] = CD_adot_flag ;
+ CD_map["CD_q"] = CD_q_flag ;
+ CD_map["CD_ih"] = CD_ih_flag ;
+ CD_map["CD_de"] = CD_de_flag ;
+ CD_map["CDfa"] = CDfa_flag ;
+ CD_map["CDfCL"] = CDfCL_flag ;
+ CD_map["CDfade"] = CDfade_flag ;
+ CD_map["CDfdf"] = CDfdf_flag ;
+ CD_map["CDfadf"] = CDfadf_flag ;
+ CD_map["CXo"] = CXo_flag ;
+ CD_map["CXK"] = CXK_flag ;
+ CD_map["CX_a"] = CX_a_flag ;
+ CD_map["CX_a2"] = CX_a2_flag ;
+ CD_map["CX_a3"] = CX_a3_flag ;
+ CD_map["CX_adot"] = CX_adot_flag ;
+ CD_map["CX_q"] = CX_q_flag ;
+ CD_map["CX_de"] = CX_de_flag ;
+ CD_map["CX_dr"] = CX_dr_flag ;
+ CD_map["CX_df"] = CX_df_flag ;
+ CD_map["CX_adf"] = CX_adf_flag ;
+}
+
+// end uiuc_map_CD.cpp
--- /dev/null
+#ifndef _MAP_CD_H_
+#define _MAP_CD_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_CD();
+
+#endif // _MAP_CD_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_CL.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the CL map
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/08/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_CL.h"
+
+
+void uiuc_map_CL()
+{
+ CL_map["CLo"] = CLo_flag ;
+ CL_map["CL_a"] = CL_a_flag ;
+ CL_map["CL_adot"] = CL_adot_flag ;
+ CL_map["CL_q"] = CL_q_flag ;
+ CL_map["CL_ih"] = CL_ih_flag ;
+ CL_map["CL_de"] = CL_de_flag ;
+ CL_map["CLfa"] = CLfa_flag ;
+ CL_map["CLfade"] = CLfade_flag ;
+ CL_map["CLfdf"] = CLfdf_flag ;
+ CL_map["CLfadf"] = CLfadf_flag ;
+ CL_map["CZo"] = CZo_flag ;
+ CL_map["CZ_a"] = CZ_a_flag ;
+ CL_map["CZ_a2"] = CZ_a2_flag ;
+ CL_map["CZ_a3"] = CZ_a3_flag ;
+ CL_map["CZ_adot"] = CZ_adot_flag ;
+ CL_map["CZ_q"] = CZ_q_flag ;
+ CL_map["CZ_de"] = CZ_de_flag ;
+ CL_map["CZ_deb2"] = CZ_deb2_flag ;
+ CL_map["CZ_df"] = CZ_df_flag ;
+ CL_map["CZ_adf"] = CZ_adf_flag ;
+}
+
+// end uiuc_map_CL.cpp
--- /dev/null
+#ifndef _MAP_CL_H_
+#define _MAP_CL_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_CL();
+
+#endif // _MAP_CL_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_CY.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the CY map
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/08/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_CY.h"
+
+
+void uiuc_map_CY()
+{
+ CY_map["CYo"] = CYo_flag ;
+ CY_map["CY_beta"] = CY_beta_flag ;
+ CY_map["CY_p"] = CY_p_flag ;
+ CY_map["CY_r"] = CY_r_flag ;
+ CY_map["CY_da"] = CY_da_flag ;
+ CY_map["CY_dr"] = CY_dr_flag ;
+ CY_map["CY_dra"] = CY_dra_flag ;
+ CY_map["CY_bdot"] = CY_bdot_flag ;
+ CY_map["CYfada"] = CYfada_flag ;
+ CY_map["CYfbetadr"] = CYfbetadr_flag ;
+}
+
+// end uiuc_map_CY.cpp
--- /dev/null
+#ifndef _MAP_CY_H_
+#define _MAP_CY_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_CY();
+
+#endif // _MAP_CY_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_Cm.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the Cm map
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/08/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_Cm.h"
+
+
+void uiuc_map_Cm()
+{
+ Cm_map["Cmo"] = Cmo_flag ;
+ Cm_map["Cm_a"] = Cm_a_flag ;
+ Cm_map["Cm_a2"] = Cm_a2_flag ;
+ Cm_map["Cm_adot"] = Cm_adot_flag ;
+ Cm_map["Cm_q"] = Cm_q_flag ;
+ Cm_map["Cm_ih"] = Cm_ih_flag ;
+ Cm_map["Cm_de"] = Cm_de_flag ;
+ Cm_map["Cm_b2"] = Cm_b2_flag ;
+ Cm_map["Cm_r"] = Cm_r_flag ;
+ Cm_map["Cm_df"] = Cm_df_flag ;
+ Cm_map["Cmfa"] = Cmfa_flag ;
+ Cm_map["Cmfade"] = Cmfade_flag ;
+ Cm_map["Cmfdf"] = Cmfdf_flag ;
+ Cm_map["Cmfadf"] = Cmfadf_flag ;
+}
+
+// end uiuc_map_Cm.cpp
--- /dev/null
+#ifndef _MAP_CM_H_
+#define _MAP_CM_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_Cm();
+
+#endif // _MAP_CM_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_Cn.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the Cn map
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/08/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_Cn.h"
+
+
+void uiuc_map_Cn()
+{
+ Cn_map["Cno"] = Cno_flag ;
+ Cn_map["Cn_beta"] = Cn_beta_flag ;
+ Cn_map["Cn_p"] = Cn_p_flag ;
+ Cn_map["Cn_r"] = Cn_r_flag ;
+ Cn_map["Cn_da"] = Cn_da_flag ;
+ Cn_map["Cn_dr"] = Cn_dr_flag ;
+ Cn_map["Cn_q"] = Cn_q_flag ;
+ Cn_map["Cn_b3"] = Cn_b3_flag ;
+ Cn_map["Cnfada"] = Cnfada_flag ;
+ Cn_map["Cnfbetadr"] = Cnfbetadr_flag ;
+}
+
+// end uiuc_map_Cn.cpp
--- /dev/null
+#ifndef _MAP_CN_H_
+#define _MAP_CN_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_Cn();
+
+#endif // _MAP_CN_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_Croll.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the Cl map
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/08/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_Croll.h"
+
+
+void uiuc_map_Croll()
+{
+ Cl_map["Clo"] = Clo_flag ;
+ Cl_map["Cl_beta"] = Cl_beta_flag ;
+ Cl_map["Cl_p"] = Cl_p_flag ;
+ Cl_map["Cl_r"] = Cl_r_flag ;
+ Cl_map["Cl_da"] = Cl_da_flag ;
+ Cl_map["Cl_dr"] = Cl_dr_flag ;
+ Cl_map["Cl_daa"] = Cl_daa_flag ;
+ Cl_map["Clfada"] = Clfada_flag ;
+ Cl_map["Clfbetadr"] = Clfbetadr_flag ;
+}
+
+// end uiuc_map_Croll.cpp
--- /dev/null
+#ifndef _MAP_CROLL_H_
+#define _MAP_CROLL_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_Croll();
+
+#endif // _MAP_CROLL_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_controlSurface.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the control surface map
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/08/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_controlSurface.h"
+
+
+void uiuc_map_controlSurface()
+{
+ controlSurface_map["de"] = de_flag ;
+ controlSurface_map["da"] = da_flag ;
+ controlSurface_map["dr"] = dr_flag ;
+ controlSurface_map["set_Long_trim"] = set_Long_trim_flag ;
+ controlSurface_map["set_Long_trim_deg"]= set_Long_trim_deg_flag ;
+ controlSurface_map["zero_Long_trim"] = zero_Long_trim_flag ;
+ controlSurface_map["elevator_step"] = elevator_step_flag ;
+ controlSurface_map["elevator_singlet"] = elevator_singlet_flag ;
+ controlSurface_map["elevator_doublet"] = elevator_doublet_flag ;
+ controlSurface_map["elevator_input"] = elevator_input_flag ;
+}
+
+// end uiuc_map_controlSurface.cpp
--- /dev/null
+#ifndef _MAP_CONTROLSURFACE_H_
+#define _MAP_CONTROLSURFACE_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_controlSurface();
+
+#endif // _MAP_CONTROLSURFACE_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_engine.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the engine map
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/08/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_engine.h"
+
+
+void uiuc_map_engine()
+{
+ engine_map["simpleSingle"] = simpleSingle_flag ;
+ engine_map["c172"] = c172_flag ;
+ engine_map["cherokee"] = cherokee_flag ;
+}
+
+// end uiuc_map_engine.cpp
--- /dev/null
+#ifndef _MAP_ENGINE_H_
+#define _MAP_ENGINE_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_engine();
+
+#endif // _MAP_ENGINE_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_geometry.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the geometry map
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/08/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_geometry.h"
+
+
+void uiuc_map_geometry()
+{
+ geometry_map["bw"] = bw_flag ;
+ geometry_map["cbar"] = cbar_flag ;
+ geometry_map["Sw"] = Sw_flag ;
+ geometry_map["ih"] = ih_flag ;
+ geometry_map["bh"] = bh_flag ;
+ geometry_map["ch"] = ch_flag ;
+ geometry_map["Sh"] = Sh_flag ;
+}
+
+// end uiuc_map_geometry.cpp
--- /dev/null
+#ifndef _MAP_GEOMETRY_H_
+#define _MAP_GEOMETRY_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_geometry();
+
+#endif // _MAP_GEOMETRY_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_ice.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the ice map
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/08/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_ice.h"
+
+
+void uiuc_map_ice()
+{
+ ice_map["iceTime"] = iceTime_flag ;
+ ice_map["transientTime"] = transientTime_flag ;
+ ice_map["eta_ice_final"] = eta_ice_final_flag ;
+ ice_map["kCDo"] = kCDo_flag ;
+ ice_map["kCDK"] = kCDK_flag ;
+ ice_map["kCD_a"] = kCD_a_flag ;
+ ice_map["kCD_adot"] = kCD_adot_flag ;
+ ice_map["kCD_q"] = kCD_q_flag ;
+ ice_map["kCD_de"] = kCD_de_flag ;
+ ice_map["kCXo"] = kCXo_flag ;
+ ice_map["kCXK"] = kCXK_flag ;
+ ice_map["kCX_a"] = kCX_a_flag ;
+ ice_map["kCX_a2"] = kCX_a2_flag ;
+ ice_map["kCX_a3"] = kCX_a3_flag ;
+ ice_map["kCX_adot"] = kCX_adot_flag ;
+ ice_map["kCX_q"] = kCX_q_flag ;
+ ice_map["kCX_de"] = kCX_de_flag ;
+ ice_map["kCX_dr"] = kCX_dr_flag ;
+ ice_map["kCX_df"] = kCX_df_flag ;
+ ice_map["kCX_adf"] = kCX_adf_flag ;
+ ice_map["kCLo"] = kCLo_flag ;
+ ice_map["kCL_a"] = kCL_a_flag ;
+ ice_map["kCL_adot"] = kCL_adot_flag ;
+ ice_map["kCL_q"] = kCL_q_flag ;
+ ice_map["kCL_de"] = kCL_de_flag ;
+ ice_map["kCZo"] = kCZo_flag ;
+ ice_map["kCZ_a"] = kCZ_a_flag ;
+ ice_map["kCZ_a2"] = kCZ_a2_flag ;
+ ice_map["kCZ_a3"] = kCZ_a3_flag ;
+ ice_map["kCZ_adot"] = kCZ_adot_flag ;
+ ice_map["kCZ_q"] = kCZ_q_flag ;
+ ice_map["kCZ_de"] = kCZ_de_flag ;
+ ice_map["kCZ_deb2"] = kCZ_deb2_flag ;
+ ice_map["kCZ_df"] = kCZ_df_flag ;
+ ice_map["kCZ_adf"] = kCZ_adf_flag ;
+ ice_map["kCmo"] = kCmo_flag ;
+ ice_map["kCm_a"] = kCm_a_flag ;
+ ice_map["kCm_a2"] = kCm_a2_flag ;
+ ice_map["kCm_adot"] = kCm_adot_flag ;
+ ice_map["kCm_q"] = kCm_q_flag ;
+ ice_map["kCm_de"] = kCm_de_flag ;
+ ice_map["kCm_b2"] = kCm_b2_flag ;
+ ice_map["kCm_r"] = kCm_r_flag ;
+ ice_map["kCm_df"] = kCm_df_flag ;
+ ice_map["kCYo"] = kCYo_flag ;
+ ice_map["kCY_beta"] = kCY_beta_flag ;
+ ice_map["kCY_p"] = kCY_p_flag ;
+ ice_map["kCY_r"] = kCY_r_flag ;
+ ice_map["kCY_da"] = kCY_da_flag ;
+ ice_map["kCY_dr"] = kCY_dr_flag ;
+ ice_map["kCY_dra"] = kCY_dra_flag ;
+ ice_map["kCY_bdot"] = kCY_bdot_flag ;
+ ice_map["kClo"] = kClo_flag ;
+ ice_map["kCl_beta"] = kCl_beta_flag ;
+ ice_map["kCl_p"] = kCl_p_flag ;
+ ice_map["kCl_r"] = kCl_r_flag ;
+ ice_map["kCl_da"] = kCl_da_flag ;
+ ice_map["kCl_dr"] = kCl_dr_flag ;
+ ice_map["kCl_daa"] = kCl_daa_flag ;
+ ice_map["kCno"] = kCno_flag ;
+ ice_map["kCn_beta"] = kCn_beta_flag ;
+ ice_map["kCn_p"] = kCn_p_flag ;
+ ice_map["kCn_r"] = kCn_r_flag ;
+ ice_map["kCn_da"] = kCn_da_flag ;
+ ice_map["kCn_dr"] = kCn_dr_flag ;
+ ice_map["kCn_q"] = kCn_q_flag ;
+ ice_map["kCn_b3"] = kCn_b3_flag ;
+ ice_map["beta_probe_wing"] = beta_probe_wing_flag ;
+ ice_map["beta_probe_tail"] = beta_probe_tail_flag ;
+}
+
+// end uiuc_map_ice.cpp
--- /dev/null
+#ifndef _MAP_ICE_H_
+#define _MAP_ICE_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_ice();
+
+#endif // _MAP_ICE_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_init.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the init map
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/08/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_init.h"
+
+
+void uiuc_map_init()
+{
+ init_map["Dx_pilot"] = Dx_pilot_flag ;
+ init_map["Dy_pilot"] = Dy_pilot_flag ;
+ init_map["Dz_pilot"] = Dz_pilot_flag ;
+ init_map["Dx_cg"] = Dx_cg_flag ;
+ init_map["Dy_cg"] = Dy_cg_flag ;
+ init_map["Dz_cg"] = Dz_cg_flag ;
+ init_map["Altitude"] = Altitude_flag ;
+ init_map["V_north"] = V_north_flag ;
+ init_map["V_east"] = V_east_flag ;
+ init_map["V_down"] = V_down_flag ;
+ init_map["P_body"] = P_body_flag ;
+ init_map["Q_body"] = Q_body_flag ;
+ init_map["R_body"] = R_body_flag ;
+ init_map["Phi"] = Phi_flag ;
+ init_map["Theta"] = Theta_flag ;
+ init_map["Psi"] = Psi_flag ;
+ init_map["Long_trim"] = Long_trim_flag ;
+ init_map["recordRate"] = recordRate_flag ;
+ init_map["recordStartTime"] = recordStartTime_flag ;
+ init_map["nondim_rate_V_rel_wind"]= nondim_rate_V_rel_wind_flag;
+ init_map["dyn_on_speed"] = dyn_on_speed_flag ;
+}
+
+// end uiuc_map_init.cpp
--- /dev/null
+#ifndef _MAP_INIT_H_
+#define _MAP_INIT_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_init();
+
+#endif // _MAP_INIT_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_keyword.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the main keyword map
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/08/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_keyword.h"
+
+
+void uiuc_map_keyword()
+{
+ Keyword_map["init"] = init_flag ;
+ Keyword_map["geometry"] = geometry_flag ;
+ Keyword_map["controlSurface"] = controlSurface_flag ;
+ Keyword_map["mass"] = mass_flag ;
+ Keyword_map["engine"] = engine_flag ;
+ Keyword_map["CD"] = CD_flag ;
+ Keyword_map["CL"] = CL_flag ;
+ Keyword_map["Cm"] = Cm_flag ;
+ Keyword_map["CY"] = CY_flag ;
+ Keyword_map["Cl"] = Cl_flag ;
+ Keyword_map["Cn"] = Cn_flag ;
+ Keyword_map["gear"] = gear_flag ;
+ Keyword_map["ice"] = ice_flag ;
+ Keyword_map["record"] = record_flag ;
+ Keyword_map["misc"] = misc_flag ;
+}
+
+// end uiuc_map_keyword.cpp
--- /dev/null
+#ifndef _MAP_KEYWORD_H_
+#define _MAP_KEYWORD_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_keyword();
+
+#endif // _MAP_KEYWORD_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_mass.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the mass map
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/08/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_mass.h"
+
+
+void uiuc_map_mass()
+{
+ mass_map["Weight"] = Weight_flag ;
+ mass_map["Mass"] = Mass_flag ;
+ mass_map["I_xx"] = I_xx_flag ;
+ mass_map["I_yy"] = I_yy_flag ;
+ mass_map["I_zz"] = I_zz_flag ;
+ mass_map["I_xz"] = I_xz_flag ;
+}
+
+// end uiuc_map_mass.cpp
--- /dev/null
+#ifndef _MAP_MASS_H_
+#define _MAP_MASS_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_mass();
+
+#endif // _MAP_MASS_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_misc.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the misc map
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 04/08/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_misc.h"
+
+
+void uiuc_map_misc()
+{
+ misc_map["simpleHingeMomentCoef"] = simpleHingeMomentCoef_flag ;
+ misc_map["dfTimefdf"] = dfTimefdf_flag ;
+}
+
+// end uiuc_map_misc.cpp
--- /dev/null
+#ifndef _MAP_MISC_H_
+#define _MAP_MISC_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_misc();
+
+#endif // _MAP_MISC_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_record1.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the record maps for time, mass, geometry,
+ positions, and accelerations
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 06/03/2000 file creation
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_record1.h"
+
+
+void uiuc_map_record1()
+{
+ /************************* Time ************************/
+ record_map["Simtime"] = Simtime_record ;
+ record_map["dt"] = dt_record ;
+
+
+ /************************* Mass ************************/
+ record_map["Weight"] = Weight_record ;
+ record_map["Mass"] = Mass_record ;
+ record_map["I_xx"] = I_xx_record ;
+ record_map["I_yy"] = I_yy_record ;
+ record_map["I_zz"] = I_zz_record ;
+ record_map["I_xz"] = I_xz_record ;
+
+
+ /*********************** Geometry **********************/
+ // pilot reference locations
+ record_map["Dx_pilot"] = Dx_pilot_record ;
+ record_map["Dy_pilot"] = Dy_pilot_record ;
+ record_map["Dz_pilot"] = Dz_pilot_record ;
+
+ // cg reference locations
+ record_map["Dx_cg"] = Dx_cg_record ;
+ record_map["Dy_cg"] = Dy_cg_record ;
+ record_map["Dz_cg"] = Dz_cg_record ;
+
+
+ /********************** Positions **********************/
+ // geocentric positions
+ record_map["Lat_geocentric"] = Lat_geocentric_record ;
+ record_map["Lon_geocentric"] = Lon_geocentric_record ;
+ record_map["Radius_to_vehicle"] = Radius_to_vehicle_record ;
+
+ // geodetic positions
+ record_map["Latitude"] = Latitude_record ;
+ record_map["Longitude"] = Longitude_record ;
+ record_map["Altitude"] = Altitude_record ;
+
+ // Euler angles
+ record_map["Phi"] = Phi_record ;
+ record_map["Theta"] = Theta_record ;
+ record_map["Psi"] = Psi_record ;
+
+
+ /******************** Accelerations ********************/
+ // accelerations in local axes
+ record_map["V_dot_north"] = V_dot_north_record ;
+ record_map["V_dot_east"] = V_dot_east_record ;
+ record_map["V_dot_down"] = V_dot_down_record ;
+
+ // accelerations in body axes
+ record_map["U_dot_body"] = U_dot_body_record ;
+ record_map["V_dot_body"] = V_dot_body_record ;
+ record_map["W_dot_body"] = W_dot_body_record ;
+
+ // acceleration of pilot
+ record_map["A_X_pilot"] = A_X_pilot_record ;
+ record_map["A_Y_pilot"] = A_Y_pilot_record ;
+ record_map["A_Z_pilot"] = A_Z_pilot_record ;
+
+ // acceleration of cg
+ record_map["A_X_cg"] = A_X_cg_record ;
+ record_map["A_Y_cg"] = A_Y_cg_record ;
+ record_map["A_Z_cg"] = A_Z_cg_record ;
+
+ // acceleration of pilot
+ record_map["N_X_pilot"] = N_X_pilot_record ;
+ record_map["N_Y_pilot"] = N_Y_pilot_record ;
+ record_map["N_Z_pilot"] = N_Z_pilot_record ;
+
+ // acceleration of cg
+ record_map["N_X_cg"] = N_X_cg_record ;
+ record_map["N_Y_cg"] = N_Y_cg_record ;
+ record_map["N_Z_cg"] = N_Z_cg_record ;
+
+ // moment acceleration rates
+ record_map["P_dot_body"] = P_dot_body_record ;
+ record_map["Q_dot_body"] = Q_dot_body_record ;
+ record_map["R_dot_body"] = R_dot_body_record ;
+}
+
+// end uiuc_map_record1.cpp
--- /dev/null
+#ifndef _MAP_RECORD1_H_
+#define _MAP_RECORD1_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_record1();
+
+#endif // _MAP_RECORD1_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_record2.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the record maps for velocities and angles
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 06/03/2000 file creation
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_record2.h"
+
+
+void uiuc_map_record2()
+{
+ /********************** Velocities *********************/
+ // local velocities
+ record_map["V_north"] = V_north_record ;
+ record_map["V_east"] = V_east_record ;
+ record_map["V_down"] = V_down_record ;
+
+ // local velocities wrt ground
+ record_map["V_north_rel_ground"] = V_north_rel_ground_record ;
+ record_map["V_east_rel_ground"] = V_east_rel_ground_record ;
+ record_map["V_down_rel_ground"] = V_down_rel_ground_record ;
+
+ // steady airmass velocities
+ record_map["V_north_airmass"] = V_north_airmass_record ;
+ record_map["V_east_airmass"] = V_east_airmass_record ;
+ record_map["V_down_airmass"] = V_down_airmass_record ;
+
+ // local velocities wrt steady airmass
+ record_map["V_north_rel_airmass"] = V_north_rel_airmass_record ;
+ record_map["V_east_rel_airmass"] = V_east_rel_airmass_record ;
+ record_map["V_down_rel_airmass"] = V_down_rel_airmass_record ;
+
+ // local linear turbulence velocities
+ record_map["U_gust"] = U_gust_record ;
+ record_map["V_gust"] = V_gust_record ;
+ record_map["W_gust"] = W_gust_record ;
+
+ // wind velocities in body axis
+ record_map["U_body"] = U_body_record ;
+ record_map["V_body"] = V_body_record ;
+ record_map["W_body"] = W_body_record ;
+
+ // other velocities
+ record_map["V_rel_wind"] = V_rel_wind_record ;
+ record_map["V_true_kts"] = V_true_kts_record ;
+ record_map["V_rel_ground"] = V_rel_ground_record ;
+ record_map["V_inertial"] = V_inertial_record ;
+ record_map["V_ground_speed"] = V_ground_speed_record ;
+ record_map["V_equiv"] = V_equiv_record ;
+ record_map["V_equiv_kts"] = V_equiv_kts_record ;
+ record_map["V_calibrated"] = V_calibrated_record ;
+ record_map["V_calibrated_kts"] = V_calibrated_kts_record ;
+
+ // angular rates in local axis
+ record_map["P_local"] = P_local_record ;
+ record_map["Q_local"] = Q_local_record ;
+ record_map["R_local"] = R_local_record ;
+
+ // angular rates in body axis
+ record_map["P_body"] = P_body_record ;
+ record_map["Q_body"] = Q_body_record ;
+ record_map["R_body"] = R_body_record ;
+
+ // difference between local and body angular rates
+ record_map["P_total"] = P_total_record ;
+ record_map["Q_total"] = Q_total_record ;
+ record_map["R_total"] = R_total_record ;
+
+ // Euler rates
+ record_map["Phi_dot"] = Phi_dot_record ;
+ record_map["Theta_dot"] = Theta_dot_record ;
+ record_map["Psi_dot"] = Psi_dot_record ;
+
+ // Geocentric rates
+ record_map["Latitude_dot"] = Latitude_dot_record ;
+ record_map["Longitude_dot"] = Longitude_dot_record ;
+ record_map["Radius_dot"] = Radius_dot_record ;
+
+
+ /************************ Angles ***********************/
+ record_map["Alpha"] = Alpha_record ;
+ record_map["Alpha_deg"] = Alpha_deg_record ;
+ record_map["Alpha_dot"] = Alpha_dot_record ;
+ record_map["Alpha_dot_deg"] = Alpha_dot_deg_record ;
+ record_map["Beta"] = Beta_record ;
+ record_map["Beta_deg"] = Beta_deg_record ;
+ record_map["Beta_dot"] = Beta_dot_record ;
+ record_map["Beta_dot_deg"] = Beta_dot_deg_record ;
+ record_map["Gamma_vert"] = Gamma_vert_record ;
+ record_map["Gamma_vert_deg"] = Gamma_vert_deg_record ;
+ record_map["Gamma_horiz"] = Gamma_horiz_record ;
+ record_map["Gamma_horiz_deg"] = Gamma_horiz_deg_record ;
+}
+
+// end uiuc_map_record2.cpp
--- /dev/null
+#ifndef _MAP_RECORD2_H_
+#define _MAP_RECORD2_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_record2();
+
+#endif // _MAP_RECORD2_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_record3.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the record maps for atmospheric properties,
+ Earth properties, engine inputs, and control inputs
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 06/03/2000 file creation
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_record3.h"
+
+
+void uiuc_map_record3()
+{
+ /**************** Atmospheric Properties ***************/
+ record_map["Density"] = Density_record ;
+ record_map["V_sound"] = V_sound_record ;
+ record_map["Mach_number"] = Mach_number_record ;
+
+ // pressures
+ record_map["Static_pressure"] = Static_pressure_record ;
+ record_map["Total_pressure"] = Total_pressure_record ;
+ record_map["Impact_pressure"] = Impact_pressure_record ;
+ record_map["Dynamic_pressure"] = Dynamic_pressure_record ;
+
+ // temperatures
+ record_map["Static_temperature"]= Static_temperature_record ;
+ record_map["Total_temperature"] = Total_temperature_record ;
+
+
+ /******************** Earth Properties *****************/
+ record_map["Gravity"] = Gravity_record ;
+ record_map["Sea_level_radius"] = Sea_level_radius_record ;
+ record_map["Earth_position_angle"]= Earth_position_angle_record;
+
+ // runway positions
+ record_map["Runway_altitude"] = Runway_altitude_record ;
+ record_map["Runway_latitude"] = Runway_latitude_record ;
+ record_map["Runway_longitude"] = Runway_longitude_record ;
+ record_map["Runway_heading"] = Runway_heading_record ;
+ record_map["Radius_to_rwy"] = Radius_to_rwy_record ;
+
+ // pilot relative to runway in local axis
+ record_map["D_pilot_north_of_rwy"]= D_pilot_north_of_rwy_record;
+ record_map["D_pilot_east_of_rwy"] = D_pilot_east_of_rwy_record ;
+ record_map["D_pilot_above_rwy"] = D_pilot_above_rwy_record ;
+
+ // pilot relative to runway in runway axis
+ record_map["X_pilot_rwy"] = X_pilot_rwy_record ;
+ record_map["Y_pilot_rwy"] = Y_pilot_rwy_record ;
+ record_map["H_pilot_rwy"] = H_pilot_rwy_record ;
+
+ // cg relative to runway in local axis
+ record_map["D_cg_north_of_rwy"] = D_cg_north_of_rwy_record ;
+ record_map["D_cg_east_of_rwy"] = D_cg_east_of_rwy_record ;
+ record_map["D_cg_above_rwy"] = D_cg_above_rwy_record ;
+
+ // cg relative to runway in runway axis
+ record_map["X_cg_rwy"] = X_cg_rwy_record ;
+ record_map["Y_cg_rwy"] = Y_cg_rwy_record ;
+ record_map["H_cg_rwy"] = H_cg_rwy_record ;
+
+
+ /********************* Engine Inputs *******************/
+ record_map["Throttle_3"] = Throttle_3_record ;
+ record_map["Throttle_pct"] = Throttle_pct_record ;
+
+
+ /******************** Control Inputs *******************/
+ record_map["Long_control"] = Long_control_record ;
+ record_map["Long_trim"] = Long_trim_record ;
+ record_map["Long_trim_deg"] = Long_trim_deg_record ;
+ record_map["elevator"] = elevator_record ;
+ record_map["elevator_deg"] = elevator_deg_record ;
+ record_map["Lat_control"] = Lat_control_record ;
+ record_map["aileron"] = aileron_record ;
+ record_map["aileron_deg"] = aileron_deg_record ;
+ record_map["Rudder_pedal"] = Rudder_pedal_record ;
+ record_map["rudder"] = rudder_record ;
+ record_map["rudder_deg"] = rudder_deg_record ;
+ record_map["Flap_handle"] = Flap_handle_record ;
+ record_map["flap"] = flap_record ;
+ record_map["flap_deg" ] = flap_deg_record ;
+}
+
+// end uiuc_map_record3.cpp
--- /dev/null
+#ifndef _MAP_RECORD3_H_
+#define _MAP_RECORD3_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_record3();
+
+#endif // _MAP_RECORD3_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_record4.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the record maps for aerodynamic
+ coefficients and ice detection parameters
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 06/03/2000 file creation
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_record4.h"
+
+
+void uiuc_map_record4()
+{
+ /****************** Aero Coefficients ******************/
+ record_map["CD"] = CD_record ;
+ record_map["CDfaI"] = CDfaI_record ;
+ record_map["CDfCLI"] = CDfCLI_record ;
+ record_map["CDfadeI"] = CDfadeI_record ;
+ record_map["CDfdfI"] = CDfdfI_record ;
+ record_map["CDfadfI"] = CDfadfI_record ;
+ record_map["CX"] = CX_record ;
+ record_map["CL"] = CL_record ;
+ record_map["CLfaI"] = CLfaI_record ;
+ record_map["CLfadeI"] = CLfadeI_record ;
+ record_map["CLfdfI"] = CLfdfI_record ;
+ record_map["CLfadfI"] = CLfadfI_record ;
+ record_map["CZ"] = CZ_record ;
+ record_map["Cm"] = Cm_record ;
+ record_map["CmfaI"] = CmfaI_record ;
+ record_map["CmfadeI"] = CmfadeI_record ;
+ record_map["CmfdfI"] = CmfdfI_record ;
+ record_map["CmfadfI"] = CmfadfI_record ;
+ record_map["CY"] = CY_record ;
+ record_map["CYfadaI"] = CYfadaI_record ;
+ record_map["CYfbetadrI"] = CYfbetadrI_record ;
+ record_map["Cl"] = Cl_record ;
+ record_map["ClfadaI"] = ClfadaI_record ;
+ record_map["ClfbetadrI"] = ClfbetadrI_record ;
+ record_map["Cn"] = Cn_record ;
+ record_map["CnfadaI"] = CnfadaI_record ;
+ record_map["CnfbetadrI"] = CnfbetadrI_record ;
+
+
+ /******************** Ice Detection ********************/
+ record_map["CLclean_wing"] = CLclean_wing_record ;
+ record_map["CLiced_wing"] = CLiced_wing_record ;
+ record_map["CLclean_tail"] = CLclean_tail_record ;
+ record_map["CLiced_tail"] = CLiced_tail_record ;
+ record_map["Lift_clean_wing"] = Lift_clean_wing_record ;
+ record_map["Lift_iced_wing"] = Lift_iced_wing_record ;
+ record_map["Lift_clean_tail"] = Lift_clean_tail_record ;
+ record_map["Lift_iced_tail"] = Lift_iced_tail_record ;
+ record_map["Gamma_clean_wing"] = Gamma_clean_wing_record ;
+ record_map["Gamma_iced_wing"] = Gamma_iced_wing_record ;
+ record_map["Gamma_clean_tail"] = Gamma_clean_tail_record ;
+ record_map["Gamma_iced_tail"] = Gamma_iced_tail_record ;
+ record_map["w_clean_wing"] = w_clean_wing_record ;
+ record_map["w_iced_wing"] = w_iced_wing_record ;
+ record_map["w_clean_tail"] = w_clean_tail_record ;
+ record_map["w_iced_tail"] = w_iced_tail_record ;
+ record_map["V_total_clean_wing"] = V_total_clean_wing_record ;
+ record_map["V_total_iced_wing"] = V_total_iced_wing_record ;
+ record_map["V_total_clean_tail"] = V_total_clean_tail_record ;
+ record_map["V_total_iced_tail"] = V_total_iced_tail_record ;
+ record_map["beta_flow_clean_wing"] = beta_flow_clean_wing_record ;
+ record_map["beta_flow_clean_wing_deg"]= beta_flow_clean_wing_deg_record;
+ record_map["beta_flow_iced_wing"] = beta_flow_iced_wing_record ;
+ record_map["beta_flow_iced_wing_deg"] = beta_flow_iced_wing_deg_record ;
+ record_map["beta_flow_clean_tail"] = beta_flow_clean_tail_record ;
+ record_map["beta_flow_clean_tail_deg"]= beta_flow_clean_tail_deg_record;
+ record_map["beta_flow_iced_tail"] = beta_flow_iced_tail_record ;
+ record_map["beta_flow_iced_tail_deg"] = beta_flow_iced_tail_deg_record ;
+ record_map["Dbeta_flow_wing"] = Dbeta_flow_wing_record ;
+ record_map["Dbeta_flow_wing_deg"] = Dbeta_flow_wing_deg_record ;
+ record_map["Dbeta_flow_tail"] = Dbeta_flow_tail_record ;
+ record_map["Dbeta_flow_tail_deg"] = Dbeta_flow_tail_deg_record ;
+ record_map["pct_beta_flow_wing"] = pct_beta_flow_wing_record ;
+ record_map["pct_beta_flow_tail"] = pct_beta_flow_tail_record ;
+}
+
+// end uiuc_map_record4.cpp
--- /dev/null
+#ifndef _MAP_RECORD4_H_
+#define _MAP_RECORD4_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_record4();
+
+#endif // _MAP_RECORD4_H_
--- /dev/null
+/**********************************************************************
+
+ FILENAME: uiuc_map_record5.cpp
+
+----------------------------------------------------------------------
+
+ DESCRIPTION: initializes the record maps for forces and moments
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 06/03/2000 file creation
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+ Jeff Scott <jscott@mail.com>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: none
+
+----------------------------------------------------------------------
+
+ OUTPUTS: none
+
+----------------------------------------------------------------------
+
+ CALLED BY: uiuc_initializemaps.cpp
+
+----------------------------------------------------------------------
+
+ CALLS TO: none
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
+
+#include "uiuc_map_record5.h"
+
+
+void uiuc_map_record5()
+{
+ /************************ Forces ***********************/
+ // aero forces in local axis
+ record_map["F_X_wind"] = F_X_wind_record ;
+ record_map["F_Y_wind"] = F_Y_wind_record ;
+ record_map["F_Z_wind"] = F_Z_wind_record ;
+
+ // aero forces in body axis
+ record_map["F_X_aero"] = F_X_aero_record ;
+ record_map["F_Y_aero"] = F_Y_aero_record ;
+ record_map["F_Z_aero"] = F_Z_aero_record ;
+
+ // engine forces
+ record_map["F_X_engine"] = F_X_engine_record ;
+ record_map["F_Y_engine"] = F_Y_engine_record ;
+ record_map["F_Z_engine"] = F_Z_engine_record ;
+
+ // gear forces
+ record_map["F_X_gear"] = F_X_gear_record ;
+ record_map["F_Y_gear"] = F_Y_gear_record ;
+ record_map["F_Z_gear"] = F_Z_gear_record ;
+
+ // total forces in body axis
+ record_map["F_X"] = F_X_record ;
+ record_map["F_Y"] = F_Y_record ;
+ record_map["F_Z"] = F_Z_record ;
+
+ // total forces in local axis
+ record_map["F_north"] = F_north_record ;
+ record_map["F_east"] = F_east_record ;
+ record_map["F_down"] = F_down_record ;
+
+
+ /*********************** Moments ***********************/
+ // aero moments
+ record_map["M_l_aero"] = M_l_aero_record ;
+ record_map["M_m_aero"] = M_m_aero_record ;
+ record_map["M_n_aero"] = M_n_aero_record ;
+
+ // engine moments
+ record_map["M_l_engine"] = M_l_engine_record ;
+ record_map["M_m_engine"] = M_m_engine_record ;
+ record_map["M_n_engine"] = M_n_engine_record ;
+
+ // gear moments
+ record_map["M_l_gear"] = M_l_gear_record ;
+ record_map["M_m_gear"] = M_m_gear_record ;
+ record_map["M_n_gear"] = M_n_gear_record ;
+
+ // total moments
+ record_map["M_l_rp"] = M_l_rp_record ;
+ record_map["M_m_rp"] = M_m_rp_record ;
+ record_map["M_n_rp"] = M_n_rp_record ;
+}
+
+// end uiuc_map_record5.cpp
--- /dev/null
+#ifndef _MAP_RECORD5_H_
+#define _MAP_RECORD5_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_record5();
+
+#endif // _MAP_RECORD5_H_
uiuc_2DdataFileReader
02/02/2000 (JS) added record options for 1D and
2D interpolated variables
+ 03/28/2000 (JS) streamlined conversion factors for
+ file readers -- since they are global
+ variables, it is not necessary to put
+ them in the function calls
+ 03/29/2000 (JS) added Cmfa and Weight flags;
+ added misc map; added Dx_cg (etc) to init
+ map
+ 04/01/2000 (JS) added throttle, longitudinal, lateral,
+ and rudder inputs to record map
+ 04/05/2000 (JS) added Altitude to init and record
+ maps; added zero_Long_trim to
+ controlSurface map
----------------------------------------------------------------------
----------------------------------------------------------------------
- CALLED BY: uiuc_wrapper.cpp
+ CALLED BY: uiuc_wrapper.cpp
----------------------------------------------------------------------
**********************************************************************/
#include "uiuc_menu.h"
+#include <iostream.h>
bool check_float(string &token)
{
- float value;
- istrstream stream(token.c_str());
- return (stream >> value);
+ float value;
+ istrstream stream(token.c_str());
+ return (stream >> value);
}
-void uiuc_menu (string aircraft_name)
+void uiuc_menu( string aircraft_name )
{
stack command_list;
double token_value;
- int token_value1, token_value2, token_value3;
+ int token_value_recordRate;
+ int token_value_convert1, token_value_convert2, token_value_convert3;
string linetoken1;
string linetoken2;
string linetoken4;
string linetoken5;
string linetoken6;
-
+
+
+ /* the following default setting should eventually be moved to a default or uiuc_init routine */
+
+ recordRate = 1; /* record every time step, default */
+ recordStartTime = 0; /* record from beginning of simulation */
+
+/* set speed at which dynamic pressure terms will be accounted for,
+ since if velocity is too small, coefficients will go to infinity */
+ dyn_on_speed = 33; /* 20 kts, default */
+
+
+
/* Read the file and get the list of commands */
airplane = new ParseFile(aircraft_name); /* struct that includes all lines of the input file */
command_list = airplane -> getCommands();
/* structs to include all parts included in the input file for specific keyword groups */
- initParts = new ParseFile();
- geometryParts = new ParseFile();
- massParts = new ParseFile();
- engineParts = new ParseFile();
- aeroParts = new ParseFile();
- gearParts = new ParseFile();
- recordParts = new ParseFile();
+ initParts = new ParseFile();
+ geometryParts = new ParseFile();
+ massParts = new ParseFile();
+ engineParts = new ParseFile();
+ aeroDragParts = new ParseFile();
+ aeroLiftParts = new ParseFile();
+ aeroPitchParts = new ParseFile();
+ aeroSideforceParts = new ParseFile();
+ aeroRollParts = new ParseFile();
+ aeroYawParts = new ParseFile();
+ gearParts = new ParseFile();
+ recordParts = new ParseFile();
if (command_list.begin() == command_list.end())
{
exit(-1);
}
-
for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
{
cout << *command_line << endl;
-
+
linetoken1 = airplane -> getToken (*command_line, 1);
linetoken2 = airplane -> getToken (*command_line, 2);
linetoken3 = airplane -> getToken (*command_line, 3);
istrstream token5(linetoken5.c_str());
istrstream token6(linetoken6.c_str());
- token4 >> token_value1;
- token5 >> token_value2;
- token6 >> token_value3;
-
switch (Keyword_map[linetoken1])
{
case init_flag:
initParts -> storeCommands (*command_line);
break;
}
+ case Dx_cg_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ Dx_cg = token_value;
+ initParts -> storeCommands (*command_line);
+ break;
+ }
+ case Dy_cg_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ Dy_cg = token_value;
+ initParts -> storeCommands (*command_line);
+ break;
+ }
+ case Dz_cg_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ Dz_cg = token_value;
+ initParts -> storeCommands (*command_line);
+ break;
+ }
+ case Altitude_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ Altitude = token_value;
+ initParts -> storeCommands (*command_line);
+ break;
+ }
case V_north_flag:
{
if (check_float(linetoken3))
initParts -> storeCommands (*command_line);
break;
}
+ case Long_trim_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ Long_trim = token_value;
+ initParts -> storeCommands (*command_line);
+ break;
+ }
+ case recordRate_flag:
+ {
+ //can't use check_float since variable is integer
+ token3 >> token_value_recordRate;
+ recordRate = 120 / token_value_recordRate;
+ break;
+ }
+ case recordStartTime_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ recordStartTime = token_value;
+ break;
+ }
+ case nondim_rate_V_rel_wind_flag:
+ {
+ nondim_rate_V_rel_wind = true;
+ break;
+ }
+ case dyn_on_speed_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ dyn_on_speed = token_value;
+ break;
+ }
default:
{
uiuc_warnings_errors(2, *command_line);
geometryParts -> storeCommands (*command_line);
break;
}
+ case ih_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ ih = token_value;
+ geometryParts -> storeCommands (*command_line);
+ break;
+ }
+ case bh_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ bh = token_value;
+ geometryParts -> storeCommands (*command_line);
+ break;
+ }
+ case ch_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ ch = token_value;
+ geometryParts -> storeCommands (*command_line);
+ break;
+ }
+ case Sh_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ Sh = token_value;
+ geometryParts -> storeCommands (*command_line);
+ break;
+ }
default:
{
uiuc_warnings_errors(2, *command_line);
};
break;
} // end geometry map
-
-
+
+
case controlSurface_flag:
{
switch(controlSurface_map[linetoken2])
drmin = token_value;
break;
}
+ case set_Long_trim_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ set_Long_trim = true;
+ elevator_tab = token_value;
+ break;
+ }
+ case set_Long_trim_deg_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ set_Long_trim = true;
+ elevator_tab = token_value * DEG_TO_RAD;
+ break;
+ }
+ case zero_Long_trim_flag:
+ {
+ zero_Long_trim = true;
+ break;
+ }
+ case elevator_step_flag:
+ {
+ // set step input flag
+ elevator_step = true;
+
+ // read in step angle in degrees and convert
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ elevator_step_angle = token_value * DEG_TO_RAD;
+
+ // read in step start time
+ if (check_float(linetoken4))
+ token4 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ elevator_step_startTime = token_value;
+ break;
+ }
+ case elevator_singlet_flag:
+ {
+ // set singlet input flag
+ elevator_singlet = true;
+
+ // read in singlet angle in degrees and convert
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ elevator_singlet_angle = token_value * DEG_TO_RAD;
+
+ // read in singlet start time
+ if (check_float(linetoken4))
+ token4 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ elevator_singlet_startTime = token_value;
+
+ // read in singlet duration
+ if (check_float(linetoken5))
+ token5 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ elevator_singlet_duration = token_value;
+ break;
+ }
+ case elevator_doublet_flag:
+ {
+ // set doublet input flag
+ elevator_doublet = true;
+
+ // read in doublet angle in degrees and convert
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ elevator_doublet_angle = token_value * DEG_TO_RAD;
+
+ // read in doublet start time
+ if (check_float(linetoken4))
+ token4 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ elevator_doublet_startTime = token_value;
+
+ // read in doublet duration
+ if (check_float(linetoken5))
+ token5 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ elevator_doublet_duration = token_value;
+ break;
+ }
+ case elevator_input_flag:
+ {
+ elevator_input = true;
+ elevator_input_file = linetoken3;
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ convert_y = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ uiuc_1DdataFileReader(elevator_input_file,
+ elevator_input_timeArray,
+ elevator_input_deArray,
+ elevator_input_ntime);
+ token6 >> token_value;
+ elevator_input_startTime = token_value;
+ break;
+ }
default:
{
uiuc_warnings_errors(2, *command_line);
};
break;
} // end controlSurface map
-
-
+
+
case mass_flag:
{
switch(mass_map[linetoken2])
{
+ case Weight_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ Weight = token_value;
+ Mass = Weight * INVG;
+ massParts -> storeCommands (*command_line);
+ break;
+ }
case Mass_flag:
{
if (check_float(linetoken3))
engineParts -> storeCommands (*command_line);
break;
}
-
case c172_flag:
{
engineParts -> storeCommands (*command_line);
break;
}
-
+ case cherokee_flag:
+ {
+ engineParts -> storeCommands (*command_line);
+ break;
+ }
default:
{
uiuc_warnings_errors(2, *command_line);
CDo = token_value;
CDo_clean = CDo;
- aeroParts -> storeCommands (*command_line);
+ aeroDragParts -> storeCommands (*command_line);
break;
}
case CDK_flag:
CDK = token_value;
CDK_clean = CDK;
- aeroParts -> storeCommands (*command_line);
+ aeroDragParts -> storeCommands (*command_line);
break;
}
case CD_a_flag:
CD_a = token_value;
CD_a_clean = CD_a;
- aeroParts -> storeCommands (*command_line);
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ case CD_adot_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CD_adot = token_value;
+ CD_adot_clean = CD_adot;
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ case CD_q_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CD_q = token_value;
+ CD_q_clean = CD_q;
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ case CD_ih_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CD_ih = token_value;
+ aeroDragParts -> storeCommands (*command_line);
break;
}
case CD_de_flag:
CD_de = token_value;
CD_de_clean = CD_de;
- aeroParts -> storeCommands (*command_line);
+ aeroDragParts -> storeCommands (*command_line);
break;
}
case CDfa_flag:
{
CDfa = linetoken3;
- conversion1 = token_value1;
- conversion2 = token_value2;
- confac1 = uiuc_convert(conversion1);
- confac2 = uiuc_convert(conversion2);
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ convert_y = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
/* call 1D File Reader with file name (CDfa) and conversion
factors; function returns array of alphas (aArray) and
corresponding CD values (CDArray) and max number of
terms in arrays (nAlpha) */
- CDfaData = uiuc_1DdataFileReader(CDfa,
- confac2, /* x */
- confac1, /* y */
- CDfa_aArray,
- CDfa_CDArray,
- CDfa_nAlpha);
- aeroParts -> storeCommands (*command_line);
+ uiuc_1DdataFileReader(CDfa,
+ CDfa_aArray,
+ CDfa_CDArray,
+ CDfa_nAlpha);
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ case CDfCL_flag:
+ {
+ CDfCL = linetoken3;
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ convert_y = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ /* call 1D File Reader with file name (CDfCL) and conversion
+ factors; function returns array of CLs (CLArray) and
+ corresponding CD values (CDArray) and max number of
+ terms in arrays (nCL) */
+ uiuc_1DdataFileReader(CDfCL,
+ CDfCL_CLArray,
+ CDfCL_CDArray,
+ CDfCL_nCL);
+ aeroDragParts -> storeCommands (*command_line);
break;
}
case CDfade_flag:
{
CDfade = linetoken3;
- conversion1 = token_value1;
- conversion2 = token_value2;
- conversion3 = token_value3;
- confac1 = uiuc_convert(conversion1);
- confac2 = uiuc_convert(conversion2);
- confac3 = uiuc_convert(conversion3);
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ token6 >> token_value_convert3;
+ convert_z = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ convert_y = uiuc_convert(token_value_convert3);
/* call 2D File Reader with file name (CDfade) and
conversion factors; function returns array of
elevator deflections (deArray) and corresponding
alpha (aArray) and delta CD (CDArray) values and
max number of terms in alpha arrays (nAlphaArray)
and deflection array (nde) */
- CDfadeData = uiuc_2DdataFileReader(CDfade,
- confac2, /* x */
- confac3, /* y */
- confac1, /* z */
- CDfade_aArray,
- CDfade_deArray,
- CDfade_CDArray,
- CDfade_nAlphaArray,
- CDfade_nde);
- aeroParts -> storeCommands (*command_line);
+ uiuc_2DdataFileReader(CDfade,
+ CDfade_aArray,
+ CDfade_deArray,
+ CDfade_CDArray,
+ CDfade_nAlphaArray,
+ CDfade_nde);
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ case CDfdf_flag:
+ {
+ CDfdf = linetoken3;
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ convert_y = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ /* call 1D File Reader with file name (CDfdf) and conversion
+ factors; function returns array of dfs (dfArray) and
+ corresponding CD values (CDArray) and max number of
+ terms in arrays (ndf) */
+ uiuc_1DdataFileReader(CDfdf,
+ CDfdf_dfArray,
+ CDfdf_CDArray,
+ CDfdf_ndf);
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ case CDfadf_flag:
+ {
+ CDfadf = linetoken3;
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ token6 >> token_value_convert3;
+ convert_z = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ convert_y = uiuc_convert(token_value_convert3);
+ /* call 2D File Reader with file name (CDfadf) and
+ conversion factors; function returns array of
+ flap deflections (dfArray) and corresponding
+ alpha (aArray) and delta CD (CDArray) values and
+ max number of terms in alpha arrays (nAlphaArray)
+ and deflection array (ndf) */
+ uiuc_2DdataFileReader(CDfadf,
+ CDfadf_aArray,
+ CDfadf_dfArray,
+ CDfadf_CDArray,
+ CDfadf_nAlphaArray,
+ CDfadf_ndf);
+ aeroDragParts -> storeCommands (*command_line);
break;
}
- default:
+ case CXo_flag:
{
- uiuc_warnings_errors(2, *command_line);
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CXo = token_value;
+ CXo_clean = CXo;
+ aeroDragParts -> storeCommands (*command_line);
break;
}
- };
- break;
- } // end CD map
-
- case CL_flag:
- {
- switch(CL_map[linetoken2])
- {
- case CLo_flag:
+ case CXK_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CXK = token_value;
+ CXK_clean = CXK;
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ case CX_a_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CX_a = token_value;
+ CX_a_clean = CX_a;
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ case CX_a2_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CX_a2 = token_value;
+ CX_a2_clean = CX_a2;
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ case CX_a3_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CX_a3 = token_value;
+ CX_a3_clean = CX_a3;
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ case CX_adot_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CX_adot = token_value;
+ CX_adot_clean = CX_adot;
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ case CX_q_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CX_q = token_value;
+ CX_q_clean = CX_q;
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ case CX_de_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CX_de = token_value;
+ CX_de_clean = CX_de;
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ case CX_dr_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CX_dr = token_value;
+ CX_dr_clean = CX_dr;
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ case CX_df_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CX_df = token_value;
+ CX_df_clean = CX_df;
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ case CX_adf_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CX_adf = token_value;
+ CX_adf_clean = CX_adf;
+ aeroDragParts -> storeCommands (*command_line);
+ break;
+ }
+ default:
+ {
+ uiuc_warnings_errors(2, *command_line);
+ break;
+ }
+ };
+ break;
+ } // end CD map
+
+
+ case CL_flag:
+ {
+ switch(CL_map[linetoken2])
+ {
+ case CLo_flag:
{
if (check_float(linetoken3))
token3 >> token_value;
CLo = token_value;
CLo_clean = CLo;
- aeroParts -> storeCommands (*command_line);
+ aeroLiftParts -> storeCommands (*command_line);
break;
}
case CL_a_flag:
CL_a = token_value;
CL_a_clean = CL_a;
- aeroParts -> storeCommands (*command_line);
+ aeroLiftParts -> storeCommands (*command_line);
break;
}
case CL_adot_flag:
CL_adot = token_value;
CL_adot_clean = CL_adot;
- aeroParts -> storeCommands (*command_line);
+ aeroLiftParts -> storeCommands (*command_line);
break;
}
case CL_q_flag:
CL_q = token_value;
CL_q_clean = CL_q;
- aeroParts -> storeCommands (*command_line);
+ aeroLiftParts -> storeCommands (*command_line);
+ break;
+ }
+ case CL_ih_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CL_ih = token_value;
+ aeroLiftParts -> storeCommands (*command_line);
break;
}
case CL_de_flag:
CL_de = token_value;
CL_de_clean = CL_de;
- aeroParts -> storeCommands (*command_line);
+ aeroLiftParts -> storeCommands (*command_line);
break;
}
case CLfa_flag:
{
CLfa = linetoken3;
- conversion1 = token_value1;
- conversion2 = token_value2;
- confac1 = uiuc_convert(conversion1);
- confac2 = uiuc_convert(conversion2);
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ convert_y = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
/* call 1D File Reader with file name (CLfa) and conversion
factors; function returns array of alphas (aArray) and
corresponding CL values (CLArray) and max number of
terms in arrays (nAlpha) */
- CLfaData = uiuc_1DdataFileReader(CLfa,
- confac2, /* x */
- confac1, /* y */
- CLfa_aArray,
- CLfa_CLArray,
- CLfa_nAlpha);
- aeroParts -> storeCommands (*command_line);
- break;
+ uiuc_1DdataFileReader(CLfa,
+ CLfa_aArray,
+ CLfa_CLArray,
+ CLfa_nAlpha);
+ aeroLiftParts -> storeCommands (*command_line);
+ break;
}
case CLfade_flag:
{
CLfade = linetoken3;
- conversion1 = token_value1;
- conversion2 = token_value2;
- conversion3 = token_value3;
- confac1 = uiuc_convert(conversion1);
- confac2 = uiuc_convert(conversion2);
- confac3 = uiuc_convert(conversion3);
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ token6 >> token_value_convert3;
+ convert_z = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ convert_y = uiuc_convert(token_value_convert3);
/* call 2D File Reader with file name (CLfade) and
conversion factors; function returns array of
elevator deflections (deArray) and corresponding
alpha (aArray) and delta CL (CLArray) values and
max number of terms in alpha arrays (nAlphaArray)
and deflection array (nde) */
- CLfadeData = uiuc_2DdataFileReader(CLfade,
- confac2, /* x */
- confac3, /* y */
- confac1, /* z */
- CLfade_aArray,
- CLfade_deArray,
- CLfade_CLArray,
- CLfade_nAlphaArray,
- CLfade_nde);
- aeroParts -> storeCommands (*command_line);
+ uiuc_2DdataFileReader(CLfade,
+ CLfade_aArray,
+ CLfade_deArray,
+ CLfade_CLArray,
+ CLfade_nAlphaArray,
+ CLfade_nde);
+ aeroLiftParts -> storeCommands (*command_line);
+ break;
+ }
+ case CLfdf_flag:
+ {
+ CLfdf = linetoken3;
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ convert_y = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ /* call 1D File Reader with file name (CLfdf) and conversion
+ factors; function returns array of dfs (dfArray) and
+ corresponding CL values (CLArray) and max number of
+ terms in arrays (ndf) */
+ uiuc_1DdataFileReader(CLfdf,
+ CLfdf_dfArray,
+ CLfdf_CLArray,
+ CLfdf_ndf);
+ aeroLiftParts -> storeCommands (*command_line);
+
+ // additional variables to streamline flap routine in aerodeflections
+ ndf = CLfdf_ndf;
+ int temp_counter = 1;
+ while (temp_counter <= ndf)
+ {
+ dfArray[temp_counter] = CLfdf_dfArray[temp_counter];
+ TimeArray[temp_counter] = dfTimefdf_TimeArray[temp_counter];
+ temp_counter++;
+ }
+ break;
+ }
+ case CLfadf_flag:
+ {
+ CLfadf = linetoken3;
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ token6 >> token_value_convert3;
+ convert_z = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ convert_y = uiuc_convert(token_value_convert3);
+ /* call 2D File Reader with file name (CLfadf) and
+ conversion factors; function returns array of
+ flap deflections (dfArray) and corresponding
+ alpha (aArray) and delta CL (CLArray) values and
+ max number of terms in alpha arrays (nAlphaArray)
+ and deflection array (ndf) */
+ uiuc_2DdataFileReader(CLfadf,
+ CLfadf_aArray,
+ CLfadf_dfArray,
+ CLfadf_CLArray,
+ CLfadf_nAlphaArray,
+ CLfadf_ndf);
+ aeroLiftParts -> storeCommands (*command_line);
+ break;
+ }
+ case CZo_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CZo = token_value;
+ CZo_clean = CZo;
+ aeroLiftParts -> storeCommands (*command_line);
+ break;
+ }
+ case CZ_a_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CZ_a = token_value;
+ CZ_a_clean = CZ_a;
+ aeroLiftParts -> storeCommands (*command_line);
+ break;
+ }
+ case CZ_a2_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CZ_a2 = token_value;
+ CZ_a2_clean = CZ_a2;
+ aeroLiftParts -> storeCommands (*command_line);
+ break;
+ }
+ case CZ_a3_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CZ_a3 = token_value;
+ CZ_a3_clean = CZ_a3;
+ aeroLiftParts -> storeCommands (*command_line);
+ break;
+ }
+ case CZ_adot_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CZ_adot = token_value;
+ CZ_adot_clean = CZ_adot;
+ aeroLiftParts -> storeCommands (*command_line);
+ break;
+ }
+ case CZ_q_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CZ_q = token_value;
+ CZ_q_clean = CZ_q;
+ aeroLiftParts -> storeCommands (*command_line);
+ break;
+ }
+ case CZ_de_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CZ_de = token_value;
+ CZ_de_clean = CZ_de;
+ aeroLiftParts -> storeCommands (*command_line);
+ break;
+ }
+ case CZ_deb2_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CZ_deb2 = token_value;
+ CZ_deb2_clean = CZ_deb2;
+ aeroLiftParts -> storeCommands (*command_line);
+ break;
+ }
+ case CZ_df_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CZ_df = token_value;
+ CZ_df_clean = CZ_df;
+ aeroLiftParts -> storeCommands (*command_line);
+ break;
+ }
+ case CZ_adf_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ CZ_adf = token_value;
+ CZ_adf_clean = CZ_adf;
+ aeroLiftParts -> storeCommands (*command_line);
break;
}
default:
{
uiuc_warnings_errors(2, *command_line);
- break;
+ break;
}
};
break;
} // end CL map
-
+
+
case Cm_flag:
{
switch(Cm_map[linetoken2])
Cmo = token_value;
Cmo_clean = Cmo;
- aeroParts -> storeCommands (*command_line);
+ aeroPitchParts -> storeCommands (*command_line);
break;
}
case Cm_a_flag:
Cm_a = token_value;
Cm_a_clean = Cm_a;
- aeroParts -> storeCommands (*command_line);
+ aeroPitchParts -> storeCommands (*command_line);
+ break;
+ }
+ case Cm_a2_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ Cm_a2 = token_value;
+ Cm_a2_clean = Cm_a2;
+ aeroPitchParts -> storeCommands (*command_line);
break;
}
case Cm_adot_flag:
Cm_adot = token_value;
Cm_adot_clean = Cm_adot;
- aeroParts -> storeCommands (*command_line);
+ aeroPitchParts -> storeCommands (*command_line);
break;
}
case Cm_q_flag:
Cm_q = token_value;
Cm_q_clean = Cm_q;
- aeroParts -> storeCommands (*command_line);
+ aeroPitchParts -> storeCommands (*command_line);
+ break;
+ }
+ case Cm_ih_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ Cm_ih = token_value;
+ aeroPitchParts -> storeCommands (*command_line);
break;
}
case Cm_de_flag:
Cm_de = token_value;
Cm_de_clean = Cm_de;
- aeroParts -> storeCommands (*command_line);
+ aeroPitchParts -> storeCommands (*command_line);
+ break;
+ }
+ case Cm_b2_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ Cm_b2 = token_value;
+ Cm_b2_clean = Cm_b2;
+ aeroPitchParts -> storeCommands (*command_line);
+ break;
+ }
+ case Cm_r_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ Cm_r = token_value;
+ Cm_r_clean = Cm_r;
+ aeroPitchParts -> storeCommands (*command_line);
+ break;
+ }
+ case Cm_df_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ Cm_df = token_value;
+ Cm_df_clean = Cm_df;
+ aeroPitchParts -> storeCommands (*command_line);
+ break;
+ }
+ case Cmfa_flag:
+ {
+ Cmfa = linetoken3;
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ convert_y = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ /* call 1D File Reader with file name (Cmfa) and conversion
+ factors; function returns array of alphas (aArray) and
+ corresponding Cm values (CmArray) and max number of
+ terms in arrays (nAlpha) */
+ uiuc_1DdataFileReader(Cmfa,
+ Cmfa_aArray,
+ Cmfa_CmArray,
+ Cmfa_nAlpha);
+ aeroPitchParts -> storeCommands (*command_line);
break;
}
case Cmfade_flag:
{
Cmfade = linetoken3;
- conversion1 = token_value1;
- conversion2 = token_value2;
- conversion3 = token_value3;
- confac1 = uiuc_convert(conversion1);
- confac2 = uiuc_convert(conversion2);
- confac3 = uiuc_convert(conversion3);
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ token6 >> token_value_convert3;
+ convert_z = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ convert_y = uiuc_convert(token_value_convert3);
/* call 2D File Reader with file name (Cmfade) and
conversion factors; function returns array of
elevator deflections (deArray) and corresponding
alpha (aArray) and delta Cm (CmArray) values and
max number of terms in alpha arrays (nAlphaArray)
and deflection array (nde) */
- CmfadeData = uiuc_2DdataFileReader(Cmfade,
- confac2, /* x */
- confac3, /* y */
- confac1, /* z */
- Cmfade_aArray,
- Cmfade_deArray,
- Cmfade_CmArray,
- Cmfade_nAlphaArray,
- Cmfade_nde);
- aeroParts -> storeCommands (*command_line);
+ uiuc_2DdataFileReader(Cmfade,
+ Cmfade_aArray,
+ Cmfade_deArray,
+ Cmfade_CmArray,
+ Cmfade_nAlphaArray,
+ Cmfade_nde);
+ aeroPitchParts -> storeCommands (*command_line);
+ break;
+ }
+ case Cmfdf_flag:
+ {
+ Cmfdf = linetoken3;
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ convert_y = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ /* call 1D File Reader with file name (Cmfdf) and conversion
+ factors; function returns array of dfs (dfArray) and
+ corresponding Cm values (CmArray) and max number of
+ terms in arrays (ndf) */
+ uiuc_1DdataFileReader(Cmfdf,
+ Cmfdf_dfArray,
+ Cmfdf_CmArray,
+ Cmfdf_ndf);
+ aeroPitchParts -> storeCommands (*command_line);
+ break;
+ }
+ case Cmfadf_flag:
+ {
+ Cmfadf = linetoken3;
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ token6 >> token_value_convert3;
+ convert_z = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ convert_y = uiuc_convert(token_value_convert3);
+ /* call 2D File Reader with file name (Cmfadf) and
+ conversion factors; function returns array of
+ flap deflections (dfArray) and corresponding
+ alpha (aArray) and delta Cm (CmArray) values and
+ max number of terms in alpha arrays (nAlphaArray)
+ and deflection array (ndf) */
+ uiuc_2DdataFileReader(Cmfadf,
+ Cmfadf_aArray,
+ Cmfadf_dfArray,
+ Cmfadf_CmArray,
+ Cmfadf_nAlphaArray,
+ Cmfadf_ndf);
+ aeroPitchParts -> storeCommands (*command_line);
break;
}
default:
break;
} // end Cm map
+
case CY_flag:
{
switch(CY_map[linetoken2])
CYo = token_value;
CYo_clean = CYo;
- aeroParts -> storeCommands (*command_line);
+ aeroSideforceParts -> storeCommands (*command_line);
break;
}
case CY_beta_flag:
CY_beta = token_value;
CY_beta_clean = CY_beta;
- aeroParts -> storeCommands (*command_line);
+ aeroSideforceParts -> storeCommands (*command_line);
break;
}
case CY_p_flag:
CY_p = token_value;
CY_p_clean = CY_p;
- aeroParts -> storeCommands (*command_line);
+ aeroSideforceParts -> storeCommands (*command_line);
break;
}
case CY_r_flag:
CY_r = token_value;
CY_r_clean = CY_r;
- aeroParts -> storeCommands (*command_line);
+ aeroSideforceParts -> storeCommands (*command_line);
break;
}
case CY_da_flag:
CY_da = token_value;
CY_da_clean = CY_da;
- aeroParts -> storeCommands (*command_line);
+ aeroSideforceParts -> storeCommands (*command_line);
break;
}
case CY_dr_flag:
CY_dr = token_value;
CY_dr_clean = CY_dr;
- aeroParts -> storeCommands (*command_line);
+ aeroSideforceParts -> storeCommands (*command_line);
break;
}
- case CYfada_flag:
+ case CY_dra_flag:
{
- CYfada = linetoken3;
- conversion1 = token_value1;
- conversion2 = token_value2;
- conversion3 = token_value3;
- confac1 = uiuc_convert(conversion1);
- confac2 = uiuc_convert(conversion2);
- confac3 = uiuc_convert(conversion3);
- /* call 2D File Reader with file name (CYfada) and
- conversion factors; function returns array of
- aileron deflections (daArray) and corresponding
- alpha (aArray) and delta CY (CYArray) values and
- max number of terms in alpha arrays (nAlphaArray)
- and deflection array (nda) */
- CYfadaData = uiuc_2DdataFileReader(CYfada,
- confac2, /* x */
- confac3, /* y */
- confac1, /* z */
- CYfada_aArray,
- CYfada_daArray,
- CYfada_CYArray,
- CYfada_nAlphaArray,
- CYfada_nda);
- aeroParts -> storeCommands (*command_line);
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(2, *command_line);
+
+ CY_dra = token_value;
+ CY_dra_clean = CY_dra;
+ aeroSideforceParts -> storeCommands (*command_line);
+ break;
+ }
+ case CY_bdot_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(2, *command_line);
+
+ CY_bdot = token_value;
+ CY_bdot_clean = CY_bdot;
+ aeroSideforceParts -> storeCommands (*command_line);
+ break;
+ }
+ case CYfada_flag:
+ {
+ CYfada = linetoken3;
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ token6 >> token_value_convert3;
+ convert_z = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ convert_y = uiuc_convert(token_value_convert3);
+ /* call 2D File Reader with file name (CYfada) and
+ conversion factors; function returns array of
+ aileron deflections (daArray) and corresponding
+ alpha (aArray) and delta CY (CYArray) values and
+ max number of terms in alpha arrays (nAlphaArray)
+ and deflection array (nda) */
+ uiuc_2DdataFileReader(CYfada,
+ CYfada_aArray,
+ CYfada_daArray,
+ CYfada_CYArray,
+ CYfada_nAlphaArray,
+ CYfada_nda);
+ aeroSideforceParts -> storeCommands (*command_line);
break;
}
case CYfbetadr_flag:
{
CYfbetadr = linetoken3;
- conversion1 = token_value1;
- conversion2 = token_value2;
- conversion3 = token_value3;
- confac1 = uiuc_convert(conversion1);
- confac2 = uiuc_convert(conversion2);
- confac3 = uiuc_convert(conversion3);
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ token6 >> token_value_convert3;
+ convert_z = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ convert_y = uiuc_convert(token_value_convert3);
/* call 2D File Reader with file name (CYfbetadr) and
conversion factors; function returns array of
rudder deflections (drArray) and corresponding
beta (betaArray) and delta CY (CYArray) values and
max number of terms in beta arrays (nBetaArray)
and deflection array (ndr) */
- CYfbetadrData = uiuc_2DdataFileReader(CYfbetadr,
- confac2, /* x */
- confac3, /* y */
- confac1, /* z */
- CYfbetadr_betaArray,
- CYfbetadr_drArray,
- CYfbetadr_CYArray,
- CYfbetadr_nBetaArray,
- CYfbetadr_ndr);
- aeroParts -> storeCommands (*command_line);
+ uiuc_2DdataFileReader(CYfbetadr,
+ CYfbetadr_betaArray,
+ CYfbetadr_drArray,
+ CYfbetadr_CYArray,
+ CYfbetadr_nBetaArray,
+ CYfbetadr_ndr);
+ aeroSideforceParts -> storeCommands (*command_line);
break;
}
default:
{
uiuc_warnings_errors(2, *command_line);
- break;
+ break;
}
};
break;
} // end CY map
-
+
+
case Cl_flag:
{
switch(Cl_map[linetoken2])
Clo = token_value;
Clo_clean = Clo;
- aeroParts -> storeCommands (*command_line);
+ aeroRollParts -> storeCommands (*command_line);
break;
}
case Cl_beta_flag:
Cl_beta = token_value;
Cl_beta_clean = Cl_beta;
- aeroParts -> storeCommands (*command_line);
+ aeroRollParts -> storeCommands (*command_line);
break;
}
case Cl_p_flag:
Cl_p = token_value;
Cl_p_clean = Cl_p;
- aeroParts -> storeCommands (*command_line);
+ aeroRollParts -> storeCommands (*command_line);
break;
}
case Cl_r_flag:
Cl_r = token_value;
Cl_r_clean = Cl_r;
- aeroParts -> storeCommands (*command_line);
+ aeroRollParts -> storeCommands (*command_line);
break;
}
case Cl_da_flag:
Cl_da = token_value;
Cl_da_clean = Cl_da;
- aeroParts -> storeCommands (*command_line);
+ aeroRollParts -> storeCommands (*command_line);
break;
}
case Cl_dr_flag:
Cl_dr = token_value;
Cl_dr_clean = Cl_dr;
- aeroParts -> storeCommands (*command_line);
+ aeroRollParts -> storeCommands (*command_line);
+ break;
+ }
+ case Cl_daa_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ Cl_daa = token_value;
+ Cl_daa_clean = Cl_daa;
+ aeroRollParts -> storeCommands (*command_line);
break;
}
case Clfada_flag:
{
Clfada = linetoken3;
- conversion1 = token_value1;
- conversion2 = token_value2;
- conversion3 = token_value3;
- confac1 = uiuc_convert(conversion1);
- confac2 = uiuc_convert(conversion2);
- confac3 = uiuc_convert(conversion3);
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ token6 >> token_value_convert3;
+ convert_z = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ convert_y = uiuc_convert(token_value_convert3);
/* call 2D File Reader with file name (Clfada) and
conversion factors; function returns array of
aileron deflections (daArray) and corresponding
alpha (aArray) and delta Cl (ClArray) values and
max number of terms in alpha arrays (nAlphaArray)
and deflection array (nda) */
- ClfadaData = uiuc_2DdataFileReader(Clfada,
- confac2, /* x */
- confac3, /* y */
- confac1, /* z */
- Clfada_aArray,
- Clfada_daArray,
- Clfada_ClArray,
- Clfada_nAlphaArray,
- Clfada_nda);
- aeroParts -> storeCommands (*command_line);
+ uiuc_2DdataFileReader(Clfada,
+ Clfada_aArray,
+ Clfada_daArray,
+ Clfada_ClArray,
+ Clfada_nAlphaArray,
+ Clfada_nda);
+ aeroRollParts -> storeCommands (*command_line);
break;
}
case Clfbetadr_flag:
{
Clfbetadr = linetoken3;
- conversion1 = token_value1;
- conversion2 = token_value2;
- conversion3 = token_value3;
- confac1 = uiuc_convert(conversion1);
- confac2 = uiuc_convert(conversion2);
- confac3 = uiuc_convert(conversion3);
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ token6 >> token_value_convert3;
+ convert_z = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ convert_y = uiuc_convert(token_value_convert3);
/* call 2D File Reader with file name (Clfbetadr) and
conversion factors; function returns array of
rudder deflections (drArray) and corresponding
beta (betaArray) and delta Cl (ClArray) values and
max number of terms in beta arrays (nBetaArray)
and deflection array (ndr) */
- ClfbetadrData = uiuc_2DdataFileReader(Clfbetadr,
- confac2, /* x */
- confac3, /* y */
- confac1, /* z */
- Clfbetadr_betaArray,
- Clfbetadr_drArray,
- Clfbetadr_ClArray,
- Clfbetadr_nBetaArray,
- Clfbetadr_ndr);
- aeroParts -> storeCommands (*command_line);
+ uiuc_2DdataFileReader(Clfbetadr,
+ Clfbetadr_betaArray,
+ Clfbetadr_drArray,
+ Clfbetadr_ClArray,
+ Clfbetadr_nBetaArray,
+ Clfbetadr_ndr);
+ aeroRollParts -> storeCommands (*command_line);
break;
}
default:
};
break;
} // end Cl map
+
+
case Cn_flag:
{
switch(Cn_map[linetoken2])
Cno = token_value;
Cno_clean = Cno;
- aeroParts -> storeCommands (*command_line);
+ aeroYawParts -> storeCommands (*command_line);
break;
}
case Cn_beta_flag:
Cn_beta = token_value;
Cn_beta_clean = Cn_beta;
- aeroParts -> storeCommands (*command_line);
+ aeroYawParts -> storeCommands (*command_line);
break;
}
case Cn_p_flag:
Cn_p = token_value;
Cn_p_clean = Cn_p;
- aeroParts -> storeCommands (*command_line);
+ aeroYawParts -> storeCommands (*command_line);
break;
}
case Cn_r_flag:
Cn_r = token_value;
Cn_r_clean = Cn_r;
- aeroParts -> storeCommands (*command_line);
+ aeroYawParts -> storeCommands (*command_line);
break;
}
case Cn_da_flag:
Cn_da = token_value;
Cn_da_clean = Cn_da;
- aeroParts -> storeCommands (*command_line);
+ aeroYawParts -> storeCommands (*command_line);
break;
}
case Cn_dr_flag:
Cn_dr = token_value;
Cn_dr_clean = Cn_dr;
- aeroParts -> storeCommands (*command_line);
+ aeroYawParts -> storeCommands (*command_line);
+ break;
+ }
+ case Cn_q_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ Cn_q = token_value;
+ Cn_q_clean = Cn_q;
+ aeroYawParts -> storeCommands (*command_line);
+ break;
+ }
+ case Cn_b3_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ Cn_b3 = token_value;
+ Cn_b3_clean = Cn_b3;
+ aeroYawParts -> storeCommands (*command_line);
break;
}
case Cnfada_flag:
{
Cnfada = linetoken3;
- conversion1 = token_value1;
- conversion2 = token_value2;
- conversion3 = token_value3;
- confac1 = uiuc_convert(conversion1);
- confac2 = uiuc_convert(conversion2);
- confac3 = uiuc_convert(conversion3);
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ token6 >> token_value_convert3;
+ convert_z = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ convert_y = uiuc_convert(token_value_convert3);
/* call 2D File Reader with file name (Cnfada) and
conversion factors; function returns array of
aileron deflections (daArray) and corresponding
alpha (aArray) and delta Cn (CnArray) values and
max number of terms in alpha arrays (nAlphaArray)
and deflection array (nda) */
- CnfadaData = uiuc_2DdataFileReader(Cnfada,
- confac2, /* x */
- confac3, /* y */
- confac1, /* z */
- Cnfada_aArray,
- Cnfada_daArray,
- Cnfada_CnArray,
- Cnfada_nAlphaArray,
- Cnfada_nda);
- aeroParts -> storeCommands (*command_line);
+ uiuc_2DdataFileReader(Cnfada,
+ Cnfada_aArray,
+ Cnfada_daArray,
+ Cnfada_CnArray,
+ Cnfada_nAlphaArray,
+ Cnfada_nda);
+ aeroYawParts -> storeCommands (*command_line);
break;
}
case Cnfbetadr_flag:
{
Cnfbetadr = linetoken3;
- conversion1 = token_value1;
- conversion2 = token_value2;
- conversion3 = token_value3;
- confac1 = uiuc_convert(conversion1);
- confac2 = uiuc_convert(conversion2);
- confac3 = uiuc_convert(conversion3);
+ token4 >> token_value_convert1;
+ token5 >> token_value_convert2;
+ token6 >> token_value_convert3;
+ convert_z = uiuc_convert(token_value_convert1);
+ convert_x = uiuc_convert(token_value_convert2);
+ convert_y = uiuc_convert(token_value_convert3);
/* call 2D File Reader with file name (Cnfbetadr) and
conversion factors; function returns array of
rudder deflections (drArray) and corresponding
beta (betaArray) and delta Cn (CnArray) values and
max number of terms in beta arrays (nBetaArray)
and deflection array (ndr) */
- CnfbetadrData = uiuc_2DdataFileReader(Cnfbetadr,
- confac2, /* x */
- confac3, /* y */
- confac1, /* z */
- Cnfbetadr_betaArray,
- Cnfbetadr_drArray,
- Cnfbetadr_CnArray,
- Cnfbetadr_nBetaArray,
- Cnfbetadr_ndr);
- aeroParts -> storeCommands (*command_line);
+ uiuc_2DdataFileReader(Cnfbetadr,
+ Cnfbetadr_betaArray,
+ Cnfbetadr_drArray,
+ Cnfbetadr_CnArray,
+ Cnfbetadr_nBetaArray,
+ Cnfbetadr_ndr);
+ aeroYawParts -> storeCommands (*command_line);
break;
}
default:
else
uiuc_warnings_errors(1, *command_line);
+ ice_model = true;
iceTime = token_value;
- aeroParts -> storeCommands (*command_line);
break;
}
-
case transientTime_flag:
{
if (check_float(linetoken3))
uiuc_warnings_errors(1, *command_line);
transientTime = token_value;
- aeroParts -> storeCommands (*command_line);
break;
}
+ case eta_ice_final_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
- case eta_final_flag:
+ eta_ice_final = token_value;
+ break;
+ }
+ case beta_probe_wing_flag:
{
if (check_float(linetoken3))
token3 >> token_value;
else
uiuc_warnings_errors(1, *command_line);
- eta_final = token_value;
- aeroParts -> storeCommands (*command_line);
+ beta_model = true;
+ x_probe_wing = token_value;
break;
}
+ case beta_probe_tail_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+ beta_model = true;
+ x_probe_tail = token_value;
+ break;
+ }
case kCDo_flag:
{
if (check_float(linetoken3))
uiuc_warnings_errors(1, *command_line);
kCDo = token_value;
- aeroParts -> storeCommands (*command_line);
break;
}
case kCDK_flag:
uiuc_warnings_errors(1, *command_line);
kCDK = token_value;
- aeroParts -> storeCommands (*command_line);
break;
}
case kCD_a_flag:
uiuc_warnings_errors(1, *command_line);
kCD_a = token_value;
- aeroParts -> storeCommands (*command_line);
+ break;
+ }
+ case kCD_adot_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCD_adot = token_value;
+ break;
+ }
+ case kCD_q_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCD_q = token_value;
break;
}
case kCD_de_flag:
uiuc_warnings_errors(1, *command_line);
kCD_de = token_value;
- aeroParts -> storeCommands (*command_line);
break;
}
-
+ case kCXo_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCXo = token_value;
+ break;
+ }
+ case kCXK_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCXK = token_value;
+ break;
+ }
+ case kCX_a_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCX_a = token_value;
+ break;
+ }
+ case kCX_a2_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCX_a2 = token_value;
+ break;
+ }
+ case kCX_a3_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCX_a3 = token_value;
+ break;
+ }
+ case kCX_adot_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCX_adot = token_value;
+ break;
+ }
+ case kCX_q_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCX_q = token_value;
+ break;
+ }
+ case kCX_de_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCX_de = token_value;
+ break;
+ }
+ case kCX_dr_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCX_dr = token_value;
+ break;
+ }
+ case kCX_df_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCX_df = token_value;
+ break;
+ }
+ case kCX_adf_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCX_adf = token_value;
+ break;
+ }
case kCLo_flag:
{
if (check_float(linetoken3))
uiuc_warnings_errors(1, *command_line);
kCLo = token_value;
- aeroParts -> storeCommands (*command_line);
break;
}
case kCL_a_flag:
uiuc_warnings_errors(1, *command_line);
kCL_a = token_value;
- aeroParts -> storeCommands (*command_line);
break;
}
case kCL_adot_flag:
uiuc_warnings_errors(1, *command_line);
kCL_adot = token_value;
- aeroParts -> storeCommands (*command_line);
break;
}
case kCL_q_flag:
uiuc_warnings_errors(1, *command_line);
kCL_q = token_value;
- aeroParts -> storeCommands (*command_line);
break;
}
case kCL_de_flag:
uiuc_warnings_errors(1, *command_line);
kCL_de = token_value;
- aeroParts -> storeCommands (*command_line);
break;
}
-
- case kCmo_flag:
+ case kCZo_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCZo = token_value;
+ break;
+ }
+ case kCZ_a_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCZ_a = token_value;
+ break;
+ }
+ case kCZ_a2_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCZ_a2 = token_value;
+ break;
+ }
+ case kCZ_a3_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCZ_a3 = token_value;
+ break;
+ }
+ case kCZ_adot_flag:
{
if (check_float(linetoken3))
token3 >> token_value;
else
uiuc_warnings_errors(1, *command_line);
- kCmo = token_value;
- aeroParts -> storeCommands (*command_line);
+ kCZ_adot = token_value;
break;
}
- case kCm_a_flag:
+ case kCZ_q_flag:
{
if (check_float(linetoken3))
token3 >> token_value;
else
uiuc_warnings_errors(1, *command_line);
- kCm_a = token_value;
- aeroParts -> storeCommands (*command_line);
+ kCZ_q = token_value;
break;
}
- case kCm_adot_flag:
+ case kCZ_de_flag:
{
if (check_float(linetoken3))
token3 >> token_value;
else
uiuc_warnings_errors(1, *command_line);
- kCm_adot = token_value;
- aeroParts -> storeCommands (*command_line);
+ kCZ_de = token_value;
break;
}
- case kCm_q_flag:
+ case kCZ_deb2_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCZ_deb2 = token_value;
+ break;
+ }
+ case kCZ_df_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCZ_df = token_value;
+ break;
+ }
+ case kCZ_adf_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCZ_adf = token_value;
+ break;
+ }
+ case kCmo_flag:
{
if (check_float(linetoken3))
token3 >> token_value;
else
uiuc_warnings_errors(1, *command_line);
- kCm_q = token_value;
- aeroParts -> storeCommands (*command_line);
+ kCmo = token_value;
break;
}
- case kCm_de_flag:
+ case kCm_a_flag:
{
if (check_float(linetoken3))
token3 >> token_value;
else
uiuc_warnings_errors(1, *command_line);
- kCm_de = token_value;
- aeroParts -> storeCommands (*command_line);
+ kCm_a = token_value;
break;
}
+ case kCm_a2_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
- case kCYo_flag:
+ kCm_a2 = token_value;
+ break;
+ }
+ case kCm_adot_flag:
{
if (check_float(linetoken3))
token3 >> token_value;
else
uiuc_warnings_errors(1, *command_line);
- kCYo = token_value;
- aeroParts -> storeCommands (*command_line);
+ kCm_adot = token_value;
+ break;
+ }
+ case kCm_q_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCm_q = token_value;
+ break;
+ }
+ case kCm_de_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCm_de = token_value;
+ break;
+ }
+ case kCm_b2_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCm_b2 = token_value;
+ break;
+ }
+ case kCm_r_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCm_r = token_value;
+ break;
+ }
+ case kCm_df_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCm_df = token_value;
+ break;
+ }
+ case kCYo_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCYo = token_value;
+ break;
+ }
+ case kCY_beta_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCY_beta = token_value;
+ break;
+ }
+ case kCY_p_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCY_p = token_value;
+ break;
+ }
+ case kCY_r_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCY_r = token_value;
+ break;
+ }
+ case kCY_da_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCY_da = token_value;
+ break;
+ }
+ case kCY_dr_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCY_dr = token_value;
+ break;
+ }
+ case kCY_dra_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCY_dra = token_value;
+ break;
+ }
+ case kCY_bdot_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCY_bdot = token_value;
+ break;
+ }
+ case kClo_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kClo = token_value;
+ break;
+ }
+ case kCl_beta_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCl_beta = token_value;
+ break;
+ }
+ case kCl_p_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCl_p = token_value;
+ break;
+ }
+ case kCl_r_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCl_r = token_value;
+ break;
+ }
+ case kCl_da_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCl_da = token_value;
+ break;
+ }
+ case kCl_dr_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCl_dr = token_value;
+ break;
+ }
+ case kCl_daa_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCl_daa = token_value;
+ break;
+ }
+ case kCno_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCno = token_value;
+ break;
+ }
+ case kCn_beta_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCn_beta = token_value;
+ break;
+ }
+ case kCn_p_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCn_p = token_value;
+ break;
+ }
+ case kCn_r_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCn_r = token_value;
+ break;
+ }
+ case kCn_da_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCn_da = token_value;
+ break;
+ }
+ case kCn_dr_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCn_dr = token_value;
+ break;
+ }
+ case kCn_q_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCn_q = token_value;
+ break;
+ }
+ case kCn_b3_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ kCn_b3 = token_value;
+ break;
+ }
+ default:
+ {
+ uiuc_warnings_errors(2, *command_line);
+ break;
+ }
+ };
+ break;
+ } // end ice map
+
+
+ case record_flag:
+ {
+ static int fout_flag=0;
+ if (fout_flag==0)
+ {
+ fout_flag=-1;
+ fout.open("uiuc_record.dat");
+ }
+ switch(record_map[linetoken2])
+ {
+ /************************* Time ************************/
+ case Simtime_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case dt_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+
+ /************************* Mass ************************/
+ case Weight_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Mass_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case I_xx_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case I_yy_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case I_zz_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case I_xz_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+
+ /*********************** Geometry **********************/
+ case Dx_pilot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Dy_pilot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Dz_pilot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Dx_cg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Dy_cg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Dz_cg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+
+ /********************** Positions **********************/
+ case Lat_geocentric_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Lon_geocentric_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Radius_to_vehicle_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Latitude_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Longitude_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Altitude_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Phi_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Theta_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Psi_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+
+ /******************** Accelerations ********************/
+ case V_dot_north_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_dot_east_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_dot_down_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case U_dot_body_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_dot_body_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case W_dot_body_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case A_X_pilot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case A_Y_pilot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case A_Z_pilot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case A_X_cg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case A_Y_cg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case A_Z_cg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case N_X_pilot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case N_Y_pilot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case N_Z_pilot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case N_X_cg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case N_Y_cg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case N_Z_cg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case P_dot_body_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Q_dot_body_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case R_dot_body_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+
+ /********************** Velocities *********************/
+ case V_north_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_east_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_down_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_north_rel_ground_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_east_rel_ground_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_down_rel_ground_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_north_airmass_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_east_airmass_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_down_airmass_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_north_rel_airmass_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_east_rel_airmass_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_down_rel_airmass_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case U_gust_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_gust_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case W_gust_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case U_body_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_body_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case W_body_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_rel_wind_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_true_kts_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_rel_ground_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_inertial_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_ground_speed_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_equiv_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_equiv_kts_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_calibrated_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_calibrated_kts_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case P_local_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Q_local_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case R_local_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case P_body_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Q_body_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case R_body_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case P_total_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Q_total_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case R_total_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Phi_dot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Theta_dot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Psi_dot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Latitude_dot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Longitude_dot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Radius_dot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+
+ /************************ Angles ***********************/
+ case Alpha_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Alpha_deg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Alpha_dot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Alpha_dot_deg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Beta_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Beta_deg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Beta_dot_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Beta_dot_deg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Gamma_vert_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Gamma_vert_deg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Gamma_horiz_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Gamma_horiz_deg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+
+ /**************** Atmospheric Properties ***************/
+ case Density_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case V_sound_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Mach_number_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Static_pressure_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Total_pressure_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Impact_pressure_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Dynamic_pressure_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Static_temperature_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Total_temperature_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+
+ /******************** Earth Properties *****************/
+ case Gravity_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Sea_level_radius_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Earth_position_angle_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Runway_altitude_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Runway_latitude_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Runway_longitude_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Runway_heading_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Radius_to_rwy_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case D_pilot_north_of_rwy_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case D_pilot_east_of_rwy_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case D_pilot_above_rwy_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case X_pilot_rwy_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Y_pilot_rwy_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case H_pilot_rwy_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case D_cg_north_of_rwy_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case D_cg_east_of_rwy_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case D_cg_above_rwy_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case X_cg_rwy_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Y_cg_rwy_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case H_cg_rwy_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+
+ /********************* Engine Inputs *******************/
+ case Throttle_pct_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Throttle_3_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+
+ /******************** Control Inputs *******************/
+ case Long_control_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Long_trim_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Long_trim_deg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case elevator_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case elevator_deg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Lat_control_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case aileron_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case aileron_deg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Rudder_pedal_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case rudder_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case rudder_deg_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case Flap_handle_record:
+ {
+ recordParts -> storeCommands (*command_line);
break;
}
- case kCY_beta_flag:
+ case flap_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kCY_beta = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
- case kCY_p_flag:
+ case flap_deg_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kCY_p = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
- case kCY_r_flag:
- {
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
- kCY_r = token_value;
- aeroParts -> storeCommands (*command_line);
+ /****************** Aero Coefficients ******************/
+ case CD_record:
+ {
+ recordParts -> storeCommands (*command_line);
break;
}
- case kCY_da_flag:
+ case CDfaI_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kCY_da = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
- case kCY_dr_flag:
+ case CDfadeI_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kCY_dr = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
-
- case kClo_flag:
+ case CDfdfI_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kClo = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
- case kCl_beta_flag:
+ case CDfadfI_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kCl_beta = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
- case kCl_p_flag:
+ case CX_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kCl_p = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
- case kCl_r_flag:
+ case CL_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kCl_r = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
- case kCl_da_flag:
+ case CLfaI_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kCl_da = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
- case kCl_dr_flag:
+ case CLfadeI_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kCl_dr = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
-
- case kCno_flag:
+ case CLfdfI_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kCno = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
- case kCn_beta_flag:
+ case CLfadfI_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kCn_beta = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
- case kCn_p_flag:
+ case CZ_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kCn_p = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
- case kCn_r_flag:
+ case Cm_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kCn_r = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
- case kCn_da_flag:
+ case CmfaI_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kCn_da = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
- case kCn_dr_flag:
+ case CmfadeI_record:
{
- if (check_float(linetoken3))
- token3 >> token_value;
- else
- uiuc_warnings_errors(1, *command_line);
-
- kCn_dr = token_value;
- aeroParts -> storeCommands (*command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
-
- default:
+ case CmfdfI_record:
{
- uiuc_warnings_errors(2, *command_line);
+ recordParts -> storeCommands (*command_line);
break;
}
- };
- break;
- } // end ice map
-
- case record_flag:
- {
- static int fout_flag=0;
- if (fout_flag==0)
- {
- fout_flag=-1;
- fout.open("uiuc_record.dat");
- }
- switch(record_map[linetoken2])
- {
- case Dx_pilot_record:
+ case CmfadfI_record:
{
recordParts -> storeCommands (*command_line);
break;
}
-
- case Dy_pilot_record:
+ case CY_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Dz_pilot_record:
+ case CYfadaI_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case V_north_record:
+ case CYfbetadrI_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case V_east_record:
+ case Cl_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case V_down_record:
+ case ClfadaI_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case V_rel_wind_record:
+ case ClfbetadrI_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Dynamic_pressure_record:
+ case Cn_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Alpha_record:
+ case CnfadaI_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Alpha_dot_record:
+ case CnfbetadrI_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Beta_record:
+
+ /******************** Ice Detection ********************/
+ case CLclean_wing_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Beta_dot_record:
+ case CLiced_wing_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Gamma_record:
+ case CLclean_tail_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case P_body_record:
+ case CLiced_tail_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Q_body_record:
+ case Lift_clean_wing_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case R_body_record:
+ case Lift_iced_wing_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Phi_record:
+ case Lift_clean_tail_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Theta_record:
+ case Lift_iced_tail_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Psi_record:
+ case Gamma_clean_wing_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Theta_dot_record:
+ case Gamma_iced_wing_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case density_record:
+ case Gamma_clean_tail_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Mass_record:
+ case Gamma_iced_tail_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Simtime_record:
+ case w_clean_wing_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case dt_record:
+ case w_iced_wing_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case elevator_record:
+ case w_clean_tail_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case aileron_record:
+ case w_iced_tail_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case rudder_record:
+ case V_total_clean_wing_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case CD_record:
+ case V_total_iced_wing_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case CDfaI_record:
+ case V_total_clean_tail_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case CDfadeI_record:
+ case V_total_iced_tail_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case CL_record:
+ case beta_flow_clean_wing_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case CLfaI_record:
+ case beta_flow_clean_wing_deg_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case CLfadeI_record:
+ case beta_flow_iced_wing_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Cm_record:
+ case beta_flow_iced_wing_deg_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case CmfadeI_record:
+ case beta_flow_clean_tail_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case CY_record:
+ case beta_flow_clean_tail_deg_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case CYfadaI_record:
+ case beta_flow_iced_tail_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case CYfbetadrI_record:
+ case beta_flow_iced_tail_deg_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Cl_record:
+ case Dbeta_flow_wing_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case ClfadaI_record:
+ case Dbeta_flow_wing_deg_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case ClfbetadrI_record:
+ case Dbeta_flow_tail_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case Cn_record:
+ case Dbeta_flow_tail_deg_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case CnfadaI_record:
+ case pct_beta_flow_wing_record:
{
recordParts -> storeCommands (*command_line);
break;
}
- case CnfbetadrI_record:
+ case pct_beta_flow_tail_record:
{
recordParts -> storeCommands (*command_line);
break;
}
+
+ /************************ Forces ***********************/
case F_X_wind_record:
{
recordParts -> storeCommands (*command_line);
recordParts -> storeCommands (*command_line);
break;
}
+ case F_north_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case F_east_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+ case F_down_record:
+ {
+ recordParts -> storeCommands (*command_line);
+ break;
+ }
+
+ /*********************** Moments ***********************/
case M_l_aero_record:
{
recordParts -> storeCommands (*command_line);
};
break;
} // end record map
-
-
+
+
+ case misc_flag:
+ {
+ switch(misc_map[linetoken2])
+ {
+ case simpleHingeMomentCoef_flag:
+ {
+ if (check_float(linetoken3))
+ token3 >> token_value;
+ else
+ uiuc_warnings_errors(1, *command_line);
+
+ simpleHingeMomentCoef = token_value;
+ break;
+ }
+ case dfTimefdf_flag:
+ {
+ dfTimefdf = linetoken3;
+ /* call 1D File Reader with file name (dfTimefdf);
+ function returns array of dfs (dfArray) and
+ corresponding time values (TimeArray) and max
+ number of terms in arrays (ndf) */
+ uiuc_1DdataFileReader(dfTimefdf,
+ dfTimefdf_dfArray,
+ dfTimefdf_TimeArray,
+ dfTimefdf_ndf);
+ break;
+ }
+ default:
+ {
+ uiuc_warnings_errors(2, *command_line);
+ break;
+ }
+ };
+ break;
+ } // end misc map
+
+
default:
{
if (linetoken1=="*")
#include "uiuc_initializemaps.h"
#include "uiuc_1DdataFileReader.h"
#include "uiuc_2DdataFileReader.h"
-#include "../LaRCsim/ls_generic.h"
+#include "../FDM/LaRCsim/ls_generic.h"
+#include "../FDM/LaRCsim/ls_cockpit.h" /* Long_trim defined */
+#include "../FDM/LaRCsim/ls_constants.h" /* INVG defined */
bool check_float(string &token); // To check whether the token is a float or not
void uiuc_menu (string aircraft);
USA or view http://www.gnu.org/copyleft/gpl.html.
**********************************************************************/
-#include <simgear/compiler.h>
+
#include "uiuc_parsefile.h"
-FG_USING_NAMESPACE(std);
ParseFile :: ParseFile (const string fileName)
{
#ifndef _PARSE_FILE_H_
#define _PARSE_FILE_H_
-#include <simgear/compiler.h>
-
#include <string>
#include <list>
#include <fstream>
-FG_USING_STD(string);
-FG_USING_STD(list);
-#if defined ( MACOS ) || defined ( _MSC_VER )
-FG_USING_STD(ifstream);
-FG_USING_STD(iostream);
-FG_USING_STD(endl);
-#endif
-
#define DELIMITERS " \t"
#define COMMENT "#"
HISTORY: 01/31/2000 initial release
03/02/2000 (JS) added record options for 1D and 2D
interpolated variables
+ 04/01/2000 (JS) added throttle, longitudinal, lateral,
+ and rudder inputs to record map
+ 04/24/2000 (JS) added rest of variables in
+ ls_generic.h
----------------------------------------------------------------------
#include "uiuc_recorder.h"
-void uiuc_recorder(double dt )
+void uiuc_recorder( double dt )
{
-
stack command_list;
string linetoken;
static int init = 0;
+ static int recordStep = 0;
string record_variables = "# ";
- LIST command_line;
- command_list = recordParts->getCommands();
- fout << endl;
+ int modulus = recordStep % recordRate;
- for ( command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
- record_variables += recordParts->getToken(*command_line,2) + " ";
-
- fout << record_variables << endl;
- for ( command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
+ if ((recordStep % recordRate) == 0)
{
-
- linetoken = recordParts->getToken(*command_line, 2);
+ command_list = recordParts->getCommands();
+ fout << endl;
- switch(record_map[linetoken])
- {
- case Dx_pilot_record:
- {
- fout << Dx_pilot << " ";
- break;
- }
- case Dy_pilot_record:
- {
- fout << Dy_pilot << " ";
- break;
- }
- case Dz_pilot_record:
- {
- fout << Dz_pilot << " ";
- break;
- }
- case V_north_record:
- {
- fout << V_north << " ";
- break;
- }
- case V_east_record:
- {
- fout << V_east << " ";
- break;
- }
- case V_down_record:
- {
- fout << V_down << " ";
- break;
- }
- case V_rel_wind_record:
- {
- fout << V_rel_wind << " ";
- break;
- }
- case Dynamic_pressure_record:
- {
- fout << Dynamic_pressure << " ";
- break;
- }
- case Alpha_record:
- {
- fout << Alpha << " ";
- break;
- }
- case Alpha_dot_record:
- {
- fout << Alpha_dot << " ";
- break;
- }
- case Beta_record:
- {
- fout << Beta << " ";
- break;
- }
- case Beta_dot_record:
- {
- fout << Beta_dot << " ";
- break;
- }
- case Gamma_record:
- {
- // fout << Gamma << " ";
- break;
- }
- case P_body_record:
- {
- fout << P_body << " ";
- break;
- }
- case Q_body_record:
- {
- fout << Q_body << " ";
- break;
- }
- case R_body_record:
- {
- fout << R_body << " ";
- break;
- }
- case Phi_record:
- {
- fout << Phi << " ";
- break;
- }
- case Theta_record:
- {
- fout << Theta << " ";
- break;
- }
- case Psi_record:
- {
- fout << Psi << " ";
- break;
- }
- case Theta_dot_record:
- {
- fout << Theta_dot << " ";
- break;
- }
- case density_record:
- {
- fout << Density << " ";
- break;
- }
- case Mass_record:
- {
- fout << Mass << " ";
- break;
- }
- case Simtime_record:
- {
- fout << Simtime << " ";
- break;
- }
- case dt_record:
+ for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
+ record_variables += recordParts->getToken(*command_line,2) + " ";
+
+ fout << record_variables << endl;
+ for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
{
- fout << dt << " ";
- break;
- }
- case elevator_record:
- {
- fout << elevator << " ";
- break;
- }
- case aileron_record:
- {
- fout << aileron << " ";
- break;
- }
- case rudder_record:
- {
- fout << rudder << " ";
- break;
- }
- case CD_record:
- {
- fout << CD << " ";
- break;
- }
- case CDfaI_record:
- {
- fout << CDfaI << " ";
- break;
- }
- case CDfadeI_record:
- {
- fout << CDfadeI << " ";
- break;
- }
- case CL_record:
- {
- fout << CL << " ";
- break;
- }
- case CLfaI_record:
- {
- fout << CLfaI << " ";
- break;
- }
- case CLfadeI_record:
- {
- fout << CLfadeI << " ";
- break;
- }
- case Cm_record:
- {
- fout << Cm << " ";
- break;
- }
- case CmfadeI_record:
- {
- fout << CmfadeI << " ";
- break;
- }
- case CY_record:
- {
- fout << CY << " ";
- break;
- }
- case CYfadaI_record:
- {
- fout << CYfadaI << " ";
- break;
- }
- case CYfbetadrI_record:
- {
- fout << CYfbetadrI << " ";
- break;
- }
- case Cl_record:
- {
- fout << Cl << " ";
- break;
- }
- case ClfadaI_record:
- {
- fout << ClfadaI << " ";
- break;
- }
- case ClfbetadrI_record:
- {
- fout << ClfbetadrI << " ";
- break;
- }
- case Cn_record:
- {
- fout << Cn << " ";
- break;
- }
- case CnfadaI_record:
- {
- fout << CnfadaI << " ";
- break;
- }
- case CnfbetadrI_record:
- {
- fout << CnfbetadrI << " ";
- break;
- }
- case F_X_wind_record:
- {
- fout << F_X_wind << " ";
- break;
- }
- case F_Y_wind_record:
- {
- fout << F_Y_wind << " ";
- break;
- }
- case F_Z_wind_record:
- {
- fout << F_Z_wind << " ";
- break;
- }
- case F_X_aero_record:
- {
- fout << F_X_aero << " ";
- break;
- }
- case F_Y_aero_record:
- {
- fout << F_Y_aero << " ";
- break;
- }
- case F_Z_aero_record:
- {
- fout << F_Z_aero << " ";
- break;
- }
- case F_X_engine_record:
- {
- fout << F_X_engine << " ";
- break;
- }
- case F_Y_engine_record:
- {
- fout << F_Y_engine << " ";
- break;
- }
- case F_Z_engine_record:
- {
- fout << F_Z_engine << " ";
- break;
- }
- case F_X_gear_record:
- {
- fout << F_X_gear << " ";
- break;
- }
- case F_Y_gear_record:
- {
- fout << F_Y_gear << " ";
- break;
- }
- case F_Z_gear_record:
- {
- fout << F_Z_gear << " ";
- break;
- }
- case F_X_record:
- {
- fout << F_X << " ";
- break;
- }
- case F_Y_record:
- {
- fout << F_Y << " ";
- break;
- }
- case F_Z_record:
- {
- fout << F_Z << " ";
- break;
- }
- case M_l_aero_record:
- {
- fout << M_l_aero << " ";
- break;
- }
- case M_m_aero_record:
- {
- fout << M_m_aero << " ";
- break;
- }
- case M_n_aero_record:
- {
- fout << M_n_aero << " ";
- break;
- }
- case M_l_engine_record:
- {
- fout << M_l_engine << " ";
- break;
- }
- case M_m_engine_record:
- {
- fout << M_m_engine << " ";
- break;
- }
- case M_n_engine_record:
- {
- fout << M_n_engine << " ";
- break;
- }
- case M_l_gear_record:
- {
- fout << M_l_gear << " ";
- break;
- }
- case M_m_gear_record:
- {
- fout << M_m_gear << " ";
- break;
- }
- case M_n_gear_record:
- {
- fout << M_n_gear << " ";
- break;
- }
- case M_l_rp_record:
- {
- fout << M_l_rp << " ";
- break;
- }
- case M_m_rp_record:
- {
- fout << M_m_rp << " ";
- break;
- }
- case M_n_rp_record:
- {
- fout << M_n_rp << " ";
- break;
- }
- };
- } // end record map
+ linetoken = recordParts->getToken(*command_line, 2);
+
+ switch(record_map[linetoken])
+ {
+ /************************* Time ************************/
+ case Simtime_record:
+ {
+ fout << Simtime << " ";
+ break;
+ }
+ case dt_record:
+ {
+ fout << dt << " ";
+ break;
+ }
+
+ /************************* Mass ************************/
+ case Weight_record:
+ {
+ fout << Weight << " ";
+ break;
+ }
+ case Mass_record:
+ {
+ fout << Mass << " ";
+ break;
+ }
+ case I_xx_record:
+ {
+ fout << I_xx << " ";
+ break;
+ }
+ case I_yy_record:
+ {
+ fout << I_yy << " ";
+ break;
+ }
+ case I_zz_record:
+ {
+ fout << I_zz << " ";
+ break;
+ }
+ case I_xz_record:
+ {
+ fout << I_xz << " ";
+ break;
+ }
+
+ /*********************** Geometry **********************/
+ case Dx_pilot_record:
+ {
+ fout << Dx_pilot << " ";
+ break;
+ }
+ case Dy_pilot_record:
+ {
+ fout << Dy_pilot << " ";
+ break;
+ }
+ case Dz_pilot_record:
+ {
+ fout << Dz_pilot << " ";
+ break;
+ }
+ case Dx_cg_record:
+ {
+ fout << Dx_cg << " ";
+ break;
+ }
+ case Dy_cg_record:
+ {
+ fout << Dy_cg << " ";
+ break;
+ }
+ case Dz_cg_record:
+ {
+ fout << Dz_cg << " ";
+ break;
+ }
+
+ /********************** Positions **********************/
+ case Lat_geocentric_record:
+ {
+ fout << Lat_geocentric << " ";
+ break;
+ }
+ case Lon_geocentric_record:
+ {
+ fout << Lon_geocentric << " ";
+ break;
+ }
+ case Radius_to_vehicle_record:
+ {
+ fout << Radius_to_vehicle << " ";
+ break;
+ }
+ case Latitude_record:
+ {
+ fout << Latitude << " ";
+ break;
+ }
+ case Longitude_record:
+ {
+ fout << Longitude << " ";
+ break;
+ }
+ case Altitude_record:
+ {
+ fout << Altitude << " ";
+ break;
+ }
+ case Phi_record:
+ {
+ fout << Phi << " ";
+ break;
+ }
+ case Theta_record:
+ {
+ fout << Theta << " ";
+ break;
+ }
+ case Psi_record:
+ {
+ fout << Psi << " ";
+ break;
+ }
+
+ /******************** Accelerations ********************/
+ case V_dot_north_record:
+ {
+ fout << V_dot_north << " ";
+ break;
+ }
+ case V_dot_east_record:
+ {
+ fout << V_dot_east << " ";
+ break;
+ }
+ case V_dot_down_record:
+ {
+ fout << V_dot_down << " ";
+ break;
+ }
+ case U_dot_body_record:
+ {
+ fout << U_dot_body << " ";
+ break;
+ }
+ case V_dot_body_record:
+ {
+ fout << V_dot_body << " ";
+ break;
+ }
+ case W_dot_body_record:
+ {
+ fout << W_dot_body << " ";
+ break;
+ }
+ case A_X_pilot_record:
+ {
+ fout << A_X_pilot << " ";
+ break;
+ }
+ case A_Y_pilot_record:
+ {
+ fout << A_Y_pilot << " ";
+ break;
+ }
+ case A_Z_pilot_record:
+ {
+ fout << A_Z_pilot << " ";
+ break;
+ }
+ case A_X_cg_record:
+ {
+ fout << A_X_cg << " ";
+ break;
+ }
+ case A_Y_cg_record:
+ {
+ fout << A_Y_cg << " ";
+ break;
+ }
+ case A_Z_cg_record:
+ {
+ fout << A_Z_cg << " ";
+ break;
+ }
+ case N_X_pilot_record:
+ {
+ fout << N_X_pilot << " ";
+ break;
+ }
+ case N_Y_pilot_record:
+ {
+ fout << N_Y_pilot << " ";
+ break;
+ }
+ case N_Z_pilot_record:
+ {
+ fout << N_Z_pilot << " ";
+ break;
+ }
+ case N_X_cg_record:
+ {
+ fout << N_X_cg << " ";
+ break;
+ }
+ case N_Y_cg_record:
+ {
+ fout << N_Y_cg << " ";
+ break;
+ }
+ case N_Z_cg_record:
+ {
+ fout << N_Z_cg << " ";
+ break;
+ }
+ case P_dot_body_record:
+ {
+ fout << P_dot_body << " ";
+ break;
+ }
+ case Q_dot_body_record:
+ {
+ fout << Q_dot_body << " ";
+ break;
+ }
+ case R_dot_body_record:
+ {
+ fout << R_dot_body << " ";
+ break;
+ }
+
+ /********************** Velocities *********************/
+ case V_north_record:
+ {
+ fout << V_north << " ";
+ break;
+ }
+ case V_east_record:
+ {
+ fout << V_east << " ";
+ break;
+ }
+ case V_down_record:
+ {
+ fout << V_down << " ";
+ break;
+ }
+ case V_north_rel_ground_record:
+ {
+ fout << V_north_rel_ground << " ";
+ break;
+ }
+ case V_east_rel_ground_record:
+ {
+ fout << V_east_rel_ground << " ";
+ break;
+ }
+ case V_down_rel_ground_record:
+ {
+ fout << V_down_rel_ground << " ";
+ break;
+ }
+ case V_north_airmass_record:
+ {
+ fout << V_north_airmass << " ";
+ break;
+ }
+ case V_east_airmass_record:
+ {
+ fout << V_east_airmass << " ";
+ break;
+ }
+ case V_down_airmass_record:
+ {
+ fout << V_down_airmass << " ";
+ break;
+ }
+ case V_north_rel_airmass_record:
+ {
+ fout << V_north_rel_airmass << " ";
+ break;
+ }
+ case V_east_rel_airmass_record:
+ {
+ fout << V_east_rel_airmass << " ";
+ break;
+ }
+ case V_down_rel_airmass_record:
+ {
+ fout << V_down_rel_airmass << " ";
+ break;
+ }
+ case U_gust_record:
+ {
+ fout << U_gust << " ";
+ break;
+ }
+ case V_gust_record:
+ {
+ fout << V_gust << " ";
+ break;
+ }
+ case W_gust_record:
+ {
+ fout << W_gust << " ";
+ break;
+ }
+ case U_body_record:
+ {
+ fout << U_body << " ";
+ break;
+ }
+ case V_body_record:
+ {
+ fout << V_body << " ";
+ break;
+ }
+ case W_body_record:
+ {
+ fout << W_body << " ";
+ break;
+ }
+ case V_rel_wind_record:
+ {
+ fout << V_rel_wind << " ";
+ break;
+ }
+ case V_true_kts_record:
+ {
+ fout << V_true_kts << " ";
+ break;
+ }
+ case V_rel_ground_record:
+ {
+ fout << V_rel_ground << " ";
+ break;
+ }
+ case V_inertial_record:
+ {
+ fout << V_inertial << " ";
+ break;
+ }
+ case V_ground_speed_record:
+ {
+ fout << V_ground_speed << " ";
+ break;
+ }
+ case V_equiv_record:
+ {
+ fout << V_equiv << " ";
+ break;
+ }
+ case V_equiv_kts_record:
+ {
+ fout << V_equiv_kts << " ";
+ break;
+ }
+ case V_calibrated_record:
+ {
+ fout << V_calibrated << " ";
+ break;
+ }
+ case V_calibrated_kts_record:
+ {
+ fout << V_calibrated_kts << " ";
+ break;
+ }
+ case P_local_record:
+ {
+ fout << P_local << " ";
+ break;
+ }
+ case Q_local_record:
+ {
+ fout << Q_local << " ";
+ break;
+ }
+ case R_local_record:
+ {
+ fout << R_local << " ";
+ break;
+ }
+ case P_body_record:
+ {
+ fout << P_body << " ";
+ break;
+ }
+ case Q_body_record:
+ {
+ fout << Q_body << " ";
+ break;
+ }
+ case R_body_record:
+ {
+ fout << R_body << " ";
+ break;
+ }
+ case P_total_record:
+ {
+ fout << P_total << " ";
+ break;
+ }
+ case Q_total_record:
+ {
+ fout << Q_total << " ";
+ break;
+ }
+ case R_total_record:
+ {
+ fout << R_total << " ";
+ break;
+ }
+ case Phi_dot_record:
+ {
+ fout << Phi_dot << " ";
+ break;
+ }
+ case Theta_dot_record:
+ {
+ fout << Theta_dot << " ";
+ break;
+ }
+ case Psi_dot_record:
+ {
+ fout << Psi_dot << " ";
+ break;
+ }
+ case Latitude_dot_record:
+ {
+ fout << Latitude_dot << " ";
+ break;
+ }
+ case Longitude_dot_record:
+ {
+ fout << Longitude_dot << " ";
+ break;
+ }
+ case Radius_dot_record:
+ {
+ fout << Radius_dot << " ";
+ break;
+ }
+
+ /************************ Angles ***********************/
+ case Alpha_record:
+ {
+ fout << Alpha << " ";
+ break;
+ }
+ case Alpha_deg_record:
+ {
+ fout << Alpha * RAD_TO_DEG << " ";
+ break;
+ }
+ case Alpha_dot_record:
+ {
+ fout << Alpha_dot << " ";
+ break;
+ }
+ case Alpha_dot_deg_record:
+ {
+ fout << Alpha_dot * RAD_TO_DEG << " ";
+ break;
+ }
+ case Beta_record:
+ {
+ fout << Beta << " ";
+ break;
+ }
+ case Beta_deg_record:
+ {
+ fout << Beta * RAD_TO_DEG << " ";
+ break;
+ }
+ case Beta_dot_record:
+ {
+ fout << Beta_dot << " ";
+ break;
+ }
+ case Beta_dot_deg_record:
+ {
+ fout << Beta_dot * RAD_TO_DEG << " ";
+ break;
+ }
+ case Gamma_vert_record:
+ {
+ fout << Gamma_vert_rad << " ";
+ break;
+ }
+ case Gamma_vert_deg_record:
+ {
+ fout << Gamma_vert_rad * RAD_TO_DEG << " ";
+ break;
+ }
+ case Gamma_horiz_record:
+ {
+ fout << Gamma_horiz_rad << " ";
+ break;
+ }
+ case Gamma_horiz_deg_record:
+ {
+ fout << Gamma_horiz_rad * RAD_TO_DEG << " ";
+ break;
+ }
+
+ /**************** Atmospheric Properties ***************/
+ case Density_record:
+ {
+ fout << Density << " ";
+ break;
+ }
+ case V_sound_record:
+ {
+ fout << V_sound << " ";
+ break;
+ }
+ case Mach_number_record:
+ {
+ fout << Mach_number << " ";
+ break;
+ }
+ case Static_pressure_record:
+ {
+ fout << Static_pressure << " ";
+ break;
+ }
+ case Total_pressure_record:
+ {
+ fout << Total_pressure << " ";
+ break;
+ }
+ case Impact_pressure_record:
+ {
+ fout << Impact_pressure << " ";
+ break;
+ }
+ case Dynamic_pressure_record:
+ {
+ fout << Dynamic_pressure << " ";
+ break;
+ }
+ case Static_temperature_record:
+ {
+ fout << Static_temperature << " ";
+ break;
+ }
+ case Total_temperature_record:
+ {
+ fout << Total_temperature << " ";
+ break;
+ }
+
+ /******************** Earth Properties *****************/
+ case Gravity_record:
+ {
+ fout << Gravity << " ";
+ break;
+ }
+ case Sea_level_radius_record:
+ {
+ fout << Sea_level_radius << " ";
+ break;
+ }
+ case Earth_position_angle_record:
+ {
+ fout << Earth_position_angle << " ";
+ break;
+ }
+ case Runway_altitude_record:
+ {
+ fout << Runway_altitude << " ";
+ break;
+ }
+ case Runway_latitude_record:
+ {
+ fout << Runway_latitude << " ";
+ break;
+ }
+ case Runway_longitude_record:
+ {
+ fout << Runway_longitude << " ";
+ break;
+ }
+ case Runway_heading_record:
+ {
+ fout << Runway_heading << " ";
+ break;
+ }
+ case Radius_to_rwy_record:
+ {
+ fout << Radius_to_rwy << " ";
+ break;
+ }
+ case D_pilot_north_of_rwy_record:
+ {
+ fout << D_pilot_north_of_rwy << " ";
+ break;
+ }
+ case D_pilot_east_of_rwy_record:
+ {
+ fout << D_pilot_east_of_rwy << " ";
+ break;
+ }
+ case D_pilot_above_rwy_record:
+ {
+ fout << D_pilot_above_rwy << " ";
+ break;
+ }
+ case X_pilot_rwy_record:
+ {
+ fout << X_pilot_rwy << " ";
+ break;
+ }
+ case Y_pilot_rwy_record:
+ {
+ fout << Y_pilot_rwy << " ";
+ break;
+ }
+ case H_pilot_rwy_record:
+ {
+ fout << H_pilot_rwy << " ";
+ break;
+ }
+ case D_cg_north_of_rwy_record:
+ {
+ fout << D_cg_north_of_rwy << " ";
+ break;
+ }
+ case D_cg_east_of_rwy_record:
+ {
+ fout << D_cg_east_of_rwy << " ";
+ break;
+ }
+ case D_cg_above_rwy_record:
+ {
+ fout << D_cg_above_rwy << " ";
+ break;
+ }
+ case X_cg_rwy_record:
+ {
+ fout << X_cg_rwy << " ";
+ break;
+ }
+ case Y_cg_rwy_record:
+ {
+ fout << Y_cg_rwy << " ";
+ break;
+ }
+ case H_cg_rwy_record:
+ {
+ fout << H_cg_rwy << " ";
+ break;
+ }
+
+ /********************* Engine Inputs *******************/
+ case Throttle_3_record:
+ {
+ fout << Throttle[3] << " ";
+ break;
+ }
+ case Throttle_pct_record:
+ {
+ fout << Throttle_pct << " ";
+ break;
+ }
+
+ /******************** Control Inputs *******************/
+ case Long_control_record:
+ {
+ fout << Long_control << " ";
+ break;
+ }
+ case Long_trim_record:
+ {
+ fout << Long_trim << " ";
+ break;
+ }
+ case Long_trim_deg_record:
+ {
+ fout << Long_trim * RAD_TO_DEG << " ";
+ break;
+ }
+ case elevator_record:
+ {
+ fout << elevator << " ";
+ break;
+ }
+ case elevator_deg_record:
+ {
+ fout << elevator * RAD_TO_DEG << " ";
+ break;
+ }
+ case Lat_control_record:
+ {
+ fout << Long_control << " ";
+ break;
+ }
+ case aileron_record:
+ {
+ fout << aileron << " ";
+ break;
+ }
+ case aileron_deg_record:
+ {
+ fout << aileron * RAD_TO_DEG << " ";
+ break;
+ }
+ case Rudder_pedal_record:
+ {
+ fout << Long_control << " ";
+ break;
+ }
+ case rudder_record:
+ {
+ fout << rudder << " ";
+ break;
+ }
+ case rudder_deg_record:
+ {
+ fout << rudder * RAD_TO_DEG << " ";
+ break;
+ }
+ case Flap_handle_record:
+ {
+ fout << flap << " ";
+ break;
+ }
+ case flap_record:
+ {
+ fout << flap << " ";
+ break;
+ }
+ case flap_deg_record:
+ {
+ fout << flap * RAD_TO_DEG << " ";
+ break;
+ }
+
+ /****************** Aero Coefficients ******************/
+ case CD_record:
+ {
+ fout << CD << " ";
+ break;
+ }
+ case CDfaI_record:
+ {
+ fout << CDfaI << " ";
+ break;
+ }
+ case CDfCLI_record:
+ {
+ fout << CDfCLI << " ";
+ break;
+ }
+ case CDfadeI_record:
+ {
+ fout << CDfadeI << " ";
+ break;
+ }
+ case CDfdfI_record:
+ {
+ fout << CDfdfI << " ";
+ break;
+ }
+ case CDfadfI_record:
+ {
+ fout << CDfadfI << " ";
+ break;
+ }
+ case CX_record:
+ {
+ fout << CX << " ";
+ break;
+ }
+ case CL_record:
+ {
+ fout << CL << " ";
+ break;
+ }
+ case CLfaI_record:
+ {
+ fout << CLfaI << " ";
+ break;
+ }
+ case CLfadeI_record:
+ {
+ fout << CLfadeI << " ";
+ break;
+ }
+ case CLfdfI_record:
+ {
+ fout << CLfdfI << " ";
+ break;
+ }
+ case CLfadfI_record:
+ {
+ fout << CLfadfI << " ";
+ break;
+ }
+ case CZ_record:
+ {
+ fout << CZ << " ";
+ break;
+ }
+ case Cm_record:
+ {
+ fout << Cm << " ";
+ break;
+ }
+ case CmfaI_record:
+ {
+ fout << CmfaI << " ";
+ break;
+ }
+ case CmfadeI_record:
+ {
+ fout << CmfadeI << " ";
+ break;
+ }
+ case CmfdfI_record:
+ {
+ fout << CmfdfI << " ";
+ break;
+ }
+ case CmfadfI_record:
+ {
+ fout << CmfadfI << " ";
+ break;
+ }
+ case CY_record:
+ {
+ fout << CY << " ";
+ break;
+ }
+ case CYfadaI_record:
+ {
+ fout << CYfadaI << " ";
+ break;
+ }
+ case CYfbetadrI_record:
+ {
+ fout << CYfbetadrI << " ";
+ break;
+ }
+ case Cl_record:
+ {
+ fout << Cl << " ";
+ break;
+ }
+ case ClfadaI_record:
+ {
+ fout << ClfadaI << " ";
+ break;
+ }
+ case ClfbetadrI_record:
+ {
+ fout << ClfbetadrI << " ";
+ break;
+ }
+ case Cn_record:
+ {
+ fout << Cn << " ";
+ break;
+ }
+ case CnfadaI_record:
+ {
+ fout << CnfadaI << " ";
+ break;
+ }
+ case CnfbetadrI_record:
+ {
+ fout << CnfbetadrI << " ";
+ break;
+ }
+
+ /******************** Ice Detection ********************/
+ case CLclean_wing_record:
+ {
+ fout << CLclean_wing << " ";
+ break;
+ }
+ case CLiced_wing_record:
+ {
+ fout << CLiced_wing << " ";
+ break;
+ }
+ case CLclean_tail_record:
+ {
+ fout << CLclean_tail << " ";
+ break;
+ }
+ case CLiced_tail_record:
+ {
+ fout << CLiced_tail << " ";
+ break;
+ }
+ case Lift_clean_wing_record:
+ {
+ fout << Lift_clean_wing << " ";
+ break;
+ }
+ case Lift_iced_wing_record:
+ {
+ fout << Lift_iced_wing << " ";
+ break;
+ }
+ case Lift_clean_tail_record:
+ {
+ fout << Lift_clean_tail << " ";
+ break;
+ }
+ case Lift_iced_tail_record:
+ {
+ fout << Lift_iced_tail << " ";
+ break;
+ }
+ case Gamma_clean_wing_record:
+ {
+ fout << Gamma_clean_wing << " ";
+ break;
+ }
+ case Gamma_iced_wing_record:
+ {
+ fout << Gamma_iced_wing << " ";
+ break;
+ }
+ case Gamma_clean_tail_record:
+ {
+ fout << Gamma_clean_tail << " ";
+ break;
+ }
+ case Gamma_iced_tail_record:
+ {
+ fout << Gamma_iced_tail << " ";
+ break;
+ }
+ case w_clean_wing_record:
+ {
+ fout << w_clean_wing << " ";
+ break;
+ }
+ case w_iced_wing_record:
+ {
+ fout << w_iced_wing << " ";
+ break;
+ }
+ case w_clean_tail_record:
+ {
+ fout << w_clean_tail << " ";
+ break;
+ }
+ case w_iced_tail_record:
+ {
+ fout << w_iced_tail << " ";
+ break;
+ }
+ case V_total_clean_wing_record:
+ {
+ fout << V_total_clean_wing << " ";
+ break;
+ }
+ case V_total_iced_wing_record:
+ {
+ fout << V_total_iced_wing << " ";
+ break;
+ }
+ case V_total_clean_tail_record:
+ {
+ fout << V_total_clean_tail << " ";
+ break;
+ }
+ case V_total_iced_tail_record:
+ {
+ fout << V_total_iced_tail << " ";
+ break;
+ }
+ case beta_flow_clean_wing_record:
+ {
+ fout << beta_flow_clean_wing << " ";
+ break;
+ }
+ case beta_flow_clean_wing_deg_record:
+ {
+ fout << beta_flow_clean_wing * RAD_TO_DEG << " ";
+ break;
+ }
+ case beta_flow_iced_wing_record:
+ {
+ fout << beta_flow_iced_wing << " ";
+ break;
+ }
+ case beta_flow_iced_wing_deg_record:
+ {
+ fout << beta_flow_iced_wing * RAD_TO_DEG << " ";
+ break;
+ }
+ case beta_flow_clean_tail_record:
+ {
+ fout << beta_flow_clean_tail << " ";
+ break;
+ }
+ case beta_flow_clean_tail_deg_record:
+ {
+ fout << beta_flow_clean_tail * RAD_TO_DEG << " ";
+ break;
+ }
+ case beta_flow_iced_tail_record:
+ {
+ fout << beta_flow_iced_tail << " ";
+ break;
+ }
+ case beta_flow_iced_tail_deg_record:
+ {
+ fout << beta_flow_iced_tail * RAD_TO_DEG << " ";
+ break;
+ }
+ case Dbeta_flow_wing_record:
+ {
+ fout << Dbeta_flow_wing << " ";
+ break;
+ }
+ case Dbeta_flow_wing_deg_record:
+ {
+ fout << Dbeta_flow_wing * RAD_TO_DEG << " ";
+ break;
+ }
+ case Dbeta_flow_tail_record:
+ {
+ fout << Dbeta_flow_tail << " ";
+ break;
+ }
+ case Dbeta_flow_tail_deg_record:
+ {
+ fout << Dbeta_flow_tail * RAD_TO_DEG << " ";
+ break;
+ }
+ case pct_beta_flow_wing_record:
+ {
+ fout << pct_beta_flow_wing << " ";
+ break;
+ }
+ case pct_beta_flow_tail_record:
+ {
+ fout << pct_beta_flow_tail << " ";
+ break;
+ }
+
+ /************************ Forces ***********************/
+ case F_X_wind_record:
+ {
+ fout << F_X_wind << " ";
+ break;
+ }
+ case F_Y_wind_record:
+ {
+ fout << F_Y_wind << " ";
+ break;
+ }
+ case F_Z_wind_record:
+ {
+ fout << F_Z_wind << " ";
+ break;
+ }
+ case F_X_aero_record:
+ {
+ fout << F_X_aero << " ";
+ break;
+ }
+ case F_Y_aero_record:
+ {
+ fout << F_Y_aero << " ";
+ break;
+ }
+ case F_Z_aero_record:
+ {
+ fout << F_Z_aero << " ";
+ break;
+ }
+ case F_X_engine_record:
+ {
+ fout << F_X_engine << " ";
+ break;
+ }
+ case F_Y_engine_record:
+ {
+ fout << F_Y_engine << " ";
+ break;
+ }
+ case F_Z_engine_record:
+ {
+ fout << F_Z_engine << " ";
+ break;
+ }
+ case F_X_gear_record:
+ {
+ fout << F_X_gear << " ";
+ break;
+ }
+ case F_Y_gear_record:
+ {
+ fout << F_Y_gear << " ";
+ break;
+ }
+ case F_Z_gear_record:
+ {
+ fout << F_Z_gear << " ";
+ break;
+ }
+ case F_X_record:
+ {
+ fout << F_X << " ";
+ break;
+ }
+ case F_Y_record:
+ {
+ fout << F_Y << " ";
+ break;
+ }
+ case F_Z_record:
+ {
+ fout << F_Z << " ";
+ break;
+ }
+ case F_north_record:
+ {
+ fout << F_north << " ";
+ break;
+ }
+ case F_east_record:
+ {
+ fout << F_east << " ";
+ break;
+ }
+ case F_down_record:
+ {
+ fout << F_down << " ";
+ break;
+ }
+
+ /*********************** Moments ***********************/
+ case M_l_aero_record:
+ {
+ fout << M_l_aero << " ";
+ break;
+ }
+ case M_m_aero_record:
+ {
+ fout << M_m_aero << " ";
+ break;
+ }
+ case M_n_aero_record:
+ {
+ fout << M_n_aero << " ";
+ break;
+ }
+ case M_l_engine_record:
+ {
+ fout << M_l_engine << " ";
+ break;
+ }
+ case M_m_engine_record:
+ {
+ fout << M_m_engine << " ";
+ break;
+ }
+ case M_n_engine_record:
+ {
+ fout << M_n_engine << " ";
+ break;
+ }
+ case M_l_gear_record:
+ {
+ fout << M_l_gear << " ";
+ break;
+ }
+ case M_m_gear_record:
+ {
+ fout << M_m_gear << " ";
+ break;
+ }
+ case M_n_gear_record:
+ {
+ fout << M_n_gear << " ";
+ break;
+ }
+ case M_l_rp_record:
+ {
+ fout << M_l_rp << " ";
+ break;
+ }
+ case M_m_rp_record:
+ {
+ fout << M_m_rp << " ";
+ break;
+ }
+ case M_n_rp_record:
+ {
+ fout << M_n_rp << " ";
+ break;
+ }
+ };
+ } // end record map
+ }
+ recordStep++;
}
// end uiuc_recorder.cpp
#include "uiuc_parsefile.h"
#include "uiuc_aircraft.h"
#include "../FDM/LaRCsim/ls_generic.h"
+#include "../FDM/LaRCsim/ls_cockpit.h"
+#include "../FDM/LaRCsim/ls_constants.h"
extern double Simtime;
USA or view http://www.gnu.org/copyleft/gpl.html.
**********************************************************************/
-#include <simgear/compiler.h>
-
#include "uiuc_warnings_errors.h"
-FG_USING_NAMESPACE(std);
-
void uiuc_warnings_errors(int errorCode, string line)
{
switch (errorCode)
#ifndef _WARNINGS_ERRORS_H_
#define _WARNINGS_ERRORS_H_
-#include <simgear/compiler.h> /* for FG_USING_STD */
-
#include <string>
#include <iostream>
-#include <stdlib.h> /* for exit */
-
-FG_USING_STD(string);
-FG_USING_STD(iostream);
void uiuc_warnings_errors(int errorCode, string line);
/**********************************************************************
- *
- * FILENAME: uiuc_wrapper.cpp
- *
- * ----------------------------------------------------------------------
- *
- * DESCRIPTION: A wrapper(interface) between the UIUC Aeromodel (C++ files)
- * and the LaRCsim FDM (C files)
- *
- * ----------------------------------------------------------------------
- *
- * STATUS: alpha version
- *
- * ----------------------------------------------------------------------
- *
- * REFERENCES:
- *
- * ----------------------------------------------------------------------
- *
- * HISTORY: 01/26/2000 initial release
- *
- * ----------------------------------------------------------------------
- *
- * AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
- *
- * ----------------------------------------------------------------------
- *
- * VARIABLES:
- *
- * ----------------------------------------------------------------------
- *
- * INPUTS: *
- *
- * ----------------------------------------------------------------------
- *
- * OUTPUTS: *
- *
- * ----------------------------------------------------------------------
- *
- * CALLED BY: *
- *
- * ----------------------------------------------------------------------
- *
- * CALLS TO: *
- *
- * ----------------------------------------------------------------------
- *
- * COPYRIGHT: (C) 2000 by Michael Selig
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
- * USA or view http://www.gnu.org/copyleft/gpl.html.
- *
- ***********************************************************************/
+
+ FILENAME: uiuc_wrapper.cpp
+----------------------------------------------------------------------
+
+ DESCRIPTION: A wrapper(interface) between the UIUC Aeromodel (C++ files)
+ and the LaRCsim FDM (C files)
+
+----------------------------------------------------------------------
+
+ STATUS: alpha version
+
+----------------------------------------------------------------------
+
+ REFERENCES:
+
+----------------------------------------------------------------------
+
+ HISTORY: 01/26/2000 initial release
+
+----------------------------------------------------------------------
+
+ AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
+
+----------------------------------------------------------------------
+
+ VARIABLES:
+
+----------------------------------------------------------------------
+
+ INPUTS: *
+
+----------------------------------------------------------------------
+
+ OUTPUTS: *
+
+----------------------------------------------------------------------
+
+ CALLED BY: *
+
+----------------------------------------------------------------------
+
+ CALLS TO: *
+
+----------------------------------------------------------------------
+
+ COPYRIGHT: (C) 2000 by Michael Selig
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA or view http://www.gnu.org/copyleft/gpl.html.
+
+**********************************************************************/
#include "uiuc_aircraft.h"
#include "uiuc_aircraftdir.h"
#include "uiuc_aerodeflections.h"
#include "uiuc_recorder.h"
#include "uiuc_menu.h"
-#include "../LaRCsim/ls_generic.h"
-
+#include "uiuc_betaprobe.h"
+#include "../FDM/LaRCsim/ls_generic.h"
extern "C" void uiuc_init_aeromodel ();
extern "C" void uiuc_force_moment(double dt);
double qScbar = qS * cbar;
double qSb = qS * bw;
- uiuc_aerodeflections();
+ uiuc_aerodeflections(dt);
uiuc_coefficients();
-
+
/* Calculate the wind axis forces */
+ if (CX && CZ)
+ {
+ CD = -CX * cos(Alpha) - CZ * sin(Alpha);
+ CL = CX * sin(Alpha) - CZ * cos(Alpha);
+ }
F_X_wind = -1 * CD * qS;
F_Y_wind = CY * qS;
F_Z_wind = -1 * CL * qS;
-
+
/* wind-axis to body-axis transformation */
F_X_aero = F_X_wind * Cos_alpha * Cos_beta - F_Y_wind * Cos_alpha * Sin_beta - F_Z_wind * Sin_alpha;
F_Y_aero = F_X_wind * Sin_beta + F_Y_wind * Cos_beta;
F_Z_aero = F_X_wind * Sin_alpha * Cos_beta - F_Y_wind * Sin_alpha * Sin_beta + F_Z_wind * Cos_alpha;
-
- /* Moment calculations */
+
+ /* Moment calculations */
M_l_aero = Cl * qSb;
M_m_aero = Cm * qScbar;
- M_n_aero = Cn * qSb;
+ M_n_aero = Cn * qSb;
- uiuc_recorder(dt);
+ /* Call fligt data recorder */
+ if (Simtime >= recordStartTime)
+ uiuc_recorder(dt);
}
void uiuc_engine_routine()
projects / flightgear.git / commitdiff