From: curt <curt>
Date: Wed, 6 Sep 2000 19:52:37 +0000 (+0000)
Subject: Sep 1 2000 updates from the UIUC team.
X-Git-Url: https://git.mxchange.org/?a=commitdiff_plain;h=517d111c5cb8da39af6a183ae90ce06cca9cc832;p=flightgear.git

Sep 1 2000 updates from the UIUC team.
---

diff --git a/src/FDM/UIUCModel/Documentation/README-uiucDoc.txt b/src/FDM/UIUCModel/Documentation/README-uiucDoc.txt
new file mode 100644
index 000000000..9c532bd11
--- /dev/null
+++ b/src/FDM/UIUCModel/Documentation/README-uiucDoc.txt
@@ -0,0 +1,1087 @@
+************************************************
+*                                              * 
+*  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)
+
+**********************************************************************
diff --git a/src/FDM/UIUCModel/Makefile.am b/src/FDM/UIUCModel/Makefile.am
index 071d6ba30..2158a57ce 100644
--- a/src/FDM/UIUCModel/Makefile.am
+++ b/src/FDM/UIUCModel/Makefile.am
@@ -1,42 +1,48 @@
 
+
 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) 
diff --git a/src/FDM/UIUCModel/uiuc_1DdataFileReader.cpp b/src/FDM/UIUCModel/uiuc_1DdataFileReader.cpp
index 2f49199c1..9e67fb952 100644
--- a/src/FDM/UIUCModel/uiuc_1DdataFileReader.cpp
+++ b/src/FDM/UIUCModel/uiuc_1DdataFileReader.cpp
@@ -70,8 +70,8 @@
 #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;
diff --git a/src/FDM/UIUCModel/uiuc_1DdataFileReader.h b/src/FDM/UIUCModel/uiuc_1DdataFileReader.h
index 878d5232c..1a2018c1a 100644
--- a/src/FDM/UIUCModel/uiuc_1DdataFileReader.h
+++ b/src/FDM/UIUCModel/uiuc_1DdataFileReader.h
@@ -1,19 +1,14 @@
 #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_
diff --git a/src/FDM/UIUCModel/uiuc_1Dinterpolation.cpp b/src/FDM/UIUCModel/uiuc_1Dinterpolation.cpp
index b5613a075..e89d988b6 100644
--- a/src/FDM/UIUCModel/uiuc_1Dinterpolation.cpp
+++ b/src/FDM/UIUCModel/uiuc_1Dinterpolation.cpp
@@ -6,7 +6,7 @@
 
  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)
 
 ----------------------------------------------------------------------
 
@@ -16,9 +16,9 @@
 
  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.
 
 ----------------------------------------------------------------------
 
@@ -93,13 +93,13 @@ double uiuc_1Dinterpolation( double xData[100], double yData[100], int xmax, dou
   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
diff --git a/src/FDM/UIUCModel/uiuc_1Dinterpolation.h b/src/FDM/UIUCModel/uiuc_1Dinterpolation.h
index a89136384..903242700 100644
--- a/src/FDM/UIUCModel/uiuc_1Dinterpolation.h
+++ b/src/FDM/UIUCModel/uiuc_1Dinterpolation.h
@@ -1,6 +1,9 @@
 #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_
diff --git a/src/FDM/UIUCModel/uiuc_2DdataFileReader.cpp b/src/FDM/UIUCModel/uiuc_2DdataFileReader.cpp
index 890d20dd4..9c45fe7ce 100644
--- a/src/FDM/UIUCModel/uiuc_2DdataFileReader.cpp
+++ b/src/FDM/UIUCModel/uiuc_2DdataFileReader.cpp
@@ -73,20 +73,17 @@
 #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;
 
@@ -128,8 +125,7 @@ int uiuc_2DdataFileReader( string file_name,
           counter_x++;
         }
     }
-  data = 1;
-  return data;
+  return;
 }
 
 // end uiuc_2DdataFileReader.cpp
diff --git a/src/FDM/UIUCModel/uiuc_2DdataFileReader.h b/src/FDM/UIUCModel/uiuc_2DdataFileReader.h
index d32985a6e..c6bec85df 100644
--- a/src/FDM/UIUCModel/uiuc_2DdataFileReader.h
+++ b/src/FDM/UIUCModel/uiuc_2DdataFileReader.h
@@ -1,17 +1,15 @@
 #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_
diff --git a/src/FDM/UIUCModel/uiuc_2Dinterpolation.h b/src/FDM/UIUCModel/uiuc_2Dinterpolation.h
index 7a9d9f4a1..8bbbd4f38 100644
--- a/src/FDM/UIUCModel/uiuc_2Dinterpolation.h
+++ b/src/FDM/UIUCModel/uiuc_2Dinterpolation.h
@@ -1,8 +1,12 @@
 #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_
diff --git a/src/FDM/UIUCModel/uiuc_aerodeflections.cpp b/src/FDM/UIUCModel/uiuc_aerodeflections.cpp
index e2692d99e..1050f9538 100644
--- a/src/FDM/UIUCModel/uiuc_aerodeflections.cpp
+++ b/src/FDM/UIUCModel/uiuc_aerodeflections.cpp
@@ -21,6 +21,7 @@
 ----------------------------------------------------------------------
 
  HISTORY:      01/30/2000   initial release
+               04/05/2000   (JS) added zero_Long_trim command
 
 ----------------------------------------------------------------------
 
@@ -69,20 +70,85 @@
 
 #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;
 }
diff --git a/src/FDM/UIUCModel/uiuc_aerodeflections.h b/src/FDM/UIUCModel/uiuc_aerodeflections.h
index 6638e5f81..ec93ff89f 100644
--- a/src/FDM/UIUCModel/uiuc_aerodeflections.h
+++ b/src/FDM/UIUCModel/uiuc_aerodeflections.h
@@ -1,11 +1,11 @@
-
 #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_
diff --git a/src/FDM/UIUCModel/uiuc_aircraft.h b/src/FDM/UIUCModel/uiuc_aircraft.h
index ae9f63bd4..7fb4cc2c0 100644
--- a/src/FDM/UIUCModel/uiuc_aircraft.h
+++ b/src/FDM/UIUCModel/uiuc_aircraft.h
@@ -32,6 +32,10 @@
                             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
 
 ----------------------------------------------------------------------
 
@@ -90,7 +94,6 @@
 #define _AIRCRAFT_H_
 
 #include <simgear/compiler.h>
-
 #include <map>
 #include <iostream>
 #include "uiuc_parsefile.h"
@@ -101,154 +104,284 @@ FG_USING_STD(iostream);
 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 ===*/
@@ -256,25 +389,63 @@ typedef struct
   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) ===========================================*/
@@ -291,9 +462,12 @@ typedef struct
   /* 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 ==============================*/
   
@@ -303,34 +477,42 @@ typedef struct
   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];
@@ -338,44 +520,75 @@ typedef struct
   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];
@@ -383,13 +596,49 @@ typedef struct
   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) */
@@ -397,18 +646,29 @@ typedef struct
   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];
@@ -416,34 +676,54 @@ typedef struct
   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];
@@ -451,7 +731,6 @@ typedef struct
   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
@@ -459,7 +738,6 @@ typedef struct
 #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];
@@ -467,7 +745,6 @@ typedef struct
   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
@@ -475,30 +752,22 @@ typedef struct
 #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];
@@ -506,7 +775,6 @@ typedef struct
   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
@@ -514,7 +782,6 @@ typedef struct
 #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];
@@ -522,7 +789,6 @@ typedef struct
   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
@@ -530,26 +796,23 @@ typedef struct
 #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];
@@ -557,7 +820,6 @@ typedef struct
   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
@@ -565,7 +827,6 @@ typedef struct
 #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];
@@ -573,7 +834,6 @@ typedef struct
   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
@@ -581,6 +841,7 @@ typedef struct
 #define Cnfbetadr_ndr         aircraft_->Cnfbetadr_ndr
 #define CnfbetadrI            aircraft_->CnfbetadrI
   
+
   /* Variables (token2) ===========================================*/
   /* gear ========== Landing gear model quantities ================*/
   
@@ -588,46 +849,71 @@ typedef struct
   
 #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
@@ -638,98 +924,106 @@ typedef struct
 #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 =============*/
@@ -737,26 +1031,114 @@ typedef struct
   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;
@@ -766,7 +1148,6 @@ typedef struct
   
 } 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
diff --git a/src/FDM/UIUCModel/uiuc_aircraftdir.h b/src/FDM/UIUCModel/uiuc_aircraftdir.h
index ad55d3f3c..9432838da 100644
--- a/src/FDM/UIUCModel/uiuc_aircraftdir.h
+++ b/src/FDM/UIUCModel/uiuc_aircraftdir.h
@@ -70,12 +70,11 @@
 
 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
diff --git a/src/FDM/UIUCModel/uiuc_betaprobe.cpp b/src/FDM/UIUCModel/uiuc_betaprobe.cpp
new file mode 100644
index 000000000..5e2afb075
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_betaprobe.cpp
@@ -0,0 +1,132 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_betaprobe.h b/src/FDM/UIUCModel/uiuc_betaprobe.h
new file mode 100644
index 000000000..fddc8d66f
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_betaprobe.h
@@ -0,0 +1,11 @@
+#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_
diff --git a/src/FDM/UIUCModel/uiuc_coef_drag.cpp b/src/FDM/UIUCModel/uiuc_coef_drag.cpp
new file mode 100644
index 000000000..e35cbdce5
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_coef_drag.cpp
@@ -0,0 +1,393 @@
+/**********************************************************************
+
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_coef_drag.h b/src/FDM/UIUCModel/uiuc_coef_drag.h
new file mode 100644
index 000000000..c87f30b58
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_coef_drag.h
@@ -0,0 +1,14 @@
+#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_
diff --git a/src/FDM/UIUCModel/uiuc_coef_lift.cpp b/src/FDM/UIUCModel/uiuc_coef_lift.cpp
new file mode 100644
index 000000000..036e54f30
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_coef_lift.cpp
@@ -0,0 +1,396 @@
+/**********************************************************************
+
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_coef_lift.h b/src/FDM/UIUCModel/uiuc_coef_lift.h
new file mode 100644
index 000000000..8790bdd6b
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_coef_lift.h
@@ -0,0 +1,14 @@
+#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_
diff --git a/src/FDM/UIUCModel/uiuc_coef_pitch.cpp b/src/FDM/UIUCModel/uiuc_coef_pitch.cpp
new file mode 100644
index 000000000..7c35bd978
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_coef_pitch.cpp
@@ -0,0 +1,230 @@
+/**********************************************************************
+
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_coef_pitch.h b/src/FDM/UIUCModel/uiuc_coef_pitch.h
new file mode 100644
index 000000000..91475ad07
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_coef_pitch.h
@@ -0,0 +1,14 @@
+#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_
diff --git a/src/FDM/UIUCModel/uiuc_coef_roll.cpp b/src/FDM/UIUCModel/uiuc_coef_roll.cpp
new file mode 100644
index 000000000..840ad9079
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_coef_roll.cpp
@@ -0,0 +1,190 @@
+/**********************************************************************
+
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_coef_roll.h b/src/FDM/UIUCModel/uiuc_coef_roll.h
new file mode 100644
index 000000000..42f7f2ae0
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_coef_roll.h
@@ -0,0 +1,14 @@
+#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_
diff --git a/src/FDM/UIUCModel/uiuc_coef_sideforce.cpp b/src/FDM/UIUCModel/uiuc_coef_sideforce.cpp
new file mode 100644
index 000000000..e0e39637b
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_coef_sideforce.cpp
@@ -0,0 +1,199 @@
+/**********************************************************************
+
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_coef_sideforce.h b/src/FDM/UIUCModel/uiuc_coef_sideforce.h
new file mode 100644
index 000000000..2cef57f02
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_coef_sideforce.h
@@ -0,0 +1,14 @@
+#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_
diff --git a/src/FDM/UIUCModel/uiuc_coef_yaw.cpp b/src/FDM/UIUCModel/uiuc_coef_yaw.cpp
new file mode 100644
index 000000000..5bef09adb
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_coef_yaw.cpp
@@ -0,0 +1,199 @@
+/**********************************************************************
+
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_coef_yaw.h b/src/FDM/UIUCModel/uiuc_coef_yaw.h
new file mode 100644
index 000000000..7f02e9c43
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_coef_yaw.h
@@ -0,0 +1,14 @@
+#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_
diff --git a/src/FDM/UIUCModel/uiuc_coefficients.cpp b/src/FDM/UIUCModel/uiuc_coefficients.cpp
index 38ff7b243..260f7c471 100644
--- a/src/FDM/UIUCModel/uiuc_coefficients.cpp
+++ b/src/FDM/UIUCModel/uiuc_coefficients.cpp
@@ -12,9 +12,7 @@
 
 ----------------------------------------------------------------------
 
- REFERENCES:   Roskam, Jan.  Airplane Flight Dynamics and Automatic
-               Flight Controls, Part I.  Lawrence, KS: DARcorporation,
-               1995.
+ REFERENCES:   
 
 ----------------------------------------------------------------------
 
@@ -28,6 +26,8 @@
                             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
 
 ----------------------------------------------------------------------
 
@@ -40,11 +40,10 @@
 
 ----------------------------------------------------------------------
 
- INPUTS:       -Alpha
-               -aileron
-               -elevator
-               -rudder
-               -coefficient components
+ INPUTS:       -V_rel_wind (or U_body)
+               -dyn_on_speed
+               -ice on/off
+	       -phugoid on/off
 
 ----------------------------------------------------------------------
 
@@ -57,13 +56,17 @@
 
 ----------------------------------------------------------------------
 
- 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
 
 ----------------------------------------------------------------------
 
@@ -88,542 +91,64 @@
 #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;
 }
diff --git a/src/FDM/UIUCModel/uiuc_coefficients.h b/src/FDM/UIUCModel/uiuc_coefficients.h
index 19af07379..06c6f5022 100644
--- a/src/FDM/UIUCModel/uiuc_coefficients.h
+++ b/src/FDM/UIUCModel/uiuc_coefficients.h
@@ -1,11 +1,17 @@
+#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_
diff --git a/src/FDM/UIUCModel/uiuc_controlInput.cpp b/src/FDM/UIUCModel/uiuc_controlInput.cpp
new file mode 100644
index 000000000..f4b22682b
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_controlInput.cpp
@@ -0,0 +1,125 @@
+/**********************************************************************
+
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_controlInput.h b/src/FDM/UIUCModel/uiuc_controlInput.h
new file mode 100644
index 000000000..53eadc70f
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_controlInput.h
@@ -0,0 +1,12 @@
+#ifndef _CONTROLINPUT_H_
+#define _CONTROLINPUT_H_
+
+#include "uiuc_aircraft.h"
+#include "uiuc_1Dinterpolation.h"
+
+extern double Simtime;
+
+
+void uiuc_controlInput();
+
+#endif // _CONTROLINPUT_H_
diff --git a/src/FDM/UIUCModel/uiuc_convert.cpp b/src/FDM/UIUCModel/uiuc_convert.cpp
index bc3a0d59e..a74a09da4 100644
--- a/src/FDM/UIUCModel/uiuc_convert.cpp
+++ b/src/FDM/UIUCModel/uiuc_convert.cpp
@@ -28,7 +28,7 @@
 
 ----------------------------------------------------------------------
 
- INPUTS:       -coversion type
+ INPUTS:       -conversion type
 
 ----------------------------------------------------------------------
 
@@ -73,11 +73,13 @@ double uiuc_convert( int conversionType )
     {
     case 0:
       {
+	/* no conversion, multiply by 1 */
 	factor = 1;
 	break;
       }
     case 1:
       {
+	/* convert from degrees to radians */
 	factor = DEG_TO_RAD;
 	break;
       }
diff --git a/src/FDM/UIUCModel/uiuc_engine.cpp b/src/FDM/UIUCModel/uiuc_engine.cpp
index c41d5af70..49e23ab39 100644
--- a/src/FDM/UIUCModel/uiuc_engine.cpp
+++ b/src/FDM/UIUCModel/uiuc_engine.cpp
@@ -12,7 +12,9 @@
 
 ----------------------------------------------------------------------
 
- 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
 
 ----------------------------------------------------------------------
 
@@ -77,48 +79,84 @@ void uiuc_engine()
   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
diff --git a/src/FDM/UIUCModel/uiuc_engine.h b/src/FDM/UIUCModel/uiuc_engine.h
index 60ebf5266..b408a0e0f 100644
--- a/src/FDM/UIUCModel/uiuc_engine.h
+++ b/src/FDM/UIUCModel/uiuc_engine.h
@@ -2,10 +2,8 @@
 #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_
diff --git a/src/FDM/UIUCModel/uiuc_ice.cpp b/src/FDM/UIUCModel/uiuc_ice.cpp
index ec3cfeec5..d777d5a14 100644
--- a/src/FDM/UIUCModel/uiuc_ice.cpp
+++ b/src/FDM/UIUCModel/uiuc_ice.cpp
@@ -18,6 +18,8 @@
 ----------------------------------------------------------------------
 
  HISTORY:      02/22/2000   initial release
+               04/25/2000   (JS) added uiuc_ice_eta function
+                            (removed from uiuc_coefficients)
 
 ----------------------------------------------------------------------
 
@@ -27,19 +29,35 @@
 
  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
 
 ----------------------------------------------------------------------
 
@@ -68,13 +86,37 @@
 #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;
 }
diff --git a/src/FDM/UIUCModel/uiuc_ice.h b/src/FDM/UIUCModel/uiuc_ice.h
index b63eab35d..18bf1fa8c 100644
--- a/src/FDM/UIUCModel/uiuc_ice.h
+++ b/src/FDM/UIUCModel/uiuc_ice.h
@@ -1,6 +1,13 @@
 #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_
diff --git a/src/FDM/UIUCModel/uiuc_initializemaps.cpp b/src/FDM/UIUCModel/uiuc_initializemaps.cpp
index 5d9b49957..775d8c658 100644
--- a/src/FDM/UIUCModel/uiuc_initializemaps.cpp
+++ b/src/FDM/UIUCModel/uiuc_initializemaps.cpp
@@ -1,76 +1,94 @@
 /********************************************************************** 
- * 
- * 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
diff --git a/src/FDM/UIUCModel/uiuc_initializemaps.h b/src/FDM/UIUCModel/uiuc_initializemaps.h
index 1e7a847f6..f6943c2e3 100644
--- a/src/FDM/UIUCModel/uiuc_initializemaps.h
+++ b/src/FDM/UIUCModel/uiuc_initializemaps.h
@@ -2,14 +2,26 @@
 #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_
diff --git a/src/FDM/UIUCModel/uiuc_map_CD.cpp b/src/FDM/UIUCModel/uiuc_map_CD.cpp
new file mode 100644
index 000000000..e7d427c6a
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_CD.cpp
@@ -0,0 +1,96 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_CD.h b/src/FDM/UIUCModel/uiuc_map_CD.h
new file mode 100644
index 000000000..80191157f
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_CD.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_CD_H_
+#define _MAP_CD_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_CD();
+
+#endif  // _MAP_CD_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_CL.cpp b/src/FDM/UIUCModel/uiuc_map_CL.cpp
new file mode 100644
index 000000000..18057b4ae
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_CL.cpp
@@ -0,0 +1,93 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_CL.h b/src/FDM/UIUCModel/uiuc_map_CL.h
new file mode 100644
index 000000000..e019ddef2
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_CL.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_CL_H_
+#define _MAP_CL_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_CL();
+
+#endif  // _MAP_CL_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_CY.cpp b/src/FDM/UIUCModel/uiuc_map_CY.cpp
new file mode 100644
index 000000000..6664e2fd6
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_CY.cpp
@@ -0,0 +1,83 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_CY.h b/src/FDM/UIUCModel/uiuc_map_CY.h
new file mode 100644
index 000000000..6f82af148
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_CY.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_CY_H_
+#define _MAP_CY_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_CY();
+
+#endif  // _MAP_CY_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_Cm.cpp b/src/FDM/UIUCModel/uiuc_map_Cm.cpp
new file mode 100644
index 000000000..4cb997a71
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_Cm.cpp
@@ -0,0 +1,87 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_Cm.h b/src/FDM/UIUCModel/uiuc_map_Cm.h
new file mode 100644
index 000000000..7f5e2ed38
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_Cm.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_CM_H_
+#define _MAP_CM_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_Cm();
+
+#endif  // _MAP_CM_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_Cn.cpp b/src/FDM/UIUCModel/uiuc_map_Cn.cpp
new file mode 100644
index 000000000..a18bd2a91
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_Cn.cpp
@@ -0,0 +1,83 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_Cn.h b/src/FDM/UIUCModel/uiuc_map_Cn.h
new file mode 100644
index 000000000..f0d3f7c0f
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_Cn.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_CN_H_
+#define _MAP_CN_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_Cn();
+
+#endif  // _MAP_CN_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_Croll.cpp b/src/FDM/UIUCModel/uiuc_map_Croll.cpp
new file mode 100644
index 000000000..561039719
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_Croll.cpp
@@ -0,0 +1,82 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_Croll.h b/src/FDM/UIUCModel/uiuc_map_Croll.h
new file mode 100644
index 000000000..3bfa4a8f1
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_Croll.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_CROLL_H_
+#define _MAP_CROLL_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_Croll();
+
+#endif  // _MAP_CROLL_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_controlSurface.cpp b/src/FDM/UIUCModel/uiuc_map_controlSurface.cpp
new file mode 100644
index 000000000..ff5b4ea14
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_controlSurface.cpp
@@ -0,0 +1,83 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_controlSurface.h b/src/FDM/UIUCModel/uiuc_map_controlSurface.h
new file mode 100644
index 000000000..fcb69aa07
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_controlSurface.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_CONTROLSURFACE_H_
+#define _MAP_CONTROLSURFACE_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_controlSurface();
+
+#endif  // _MAP_CONTROLSURFACE_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_engine.cpp b/src/FDM/UIUCModel/uiuc_map_engine.cpp
new file mode 100644
index 000000000..79465d1df
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_engine.cpp
@@ -0,0 +1,76 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_engine.h b/src/FDM/UIUCModel/uiuc_map_engine.h
new file mode 100644
index 000000000..129460c13
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_engine.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_ENGINE_H_
+#define _MAP_ENGINE_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_engine();
+
+#endif  // _MAP_ENGINE_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_geometry.cpp b/src/FDM/UIUCModel/uiuc_map_geometry.cpp
new file mode 100644
index 000000000..eb78ead58
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_geometry.cpp
@@ -0,0 +1,80 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_geometry.h b/src/FDM/UIUCModel/uiuc_map_geometry.h
new file mode 100644
index 000000000..5ea511948
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_geometry.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_GEOMETRY_H_
+#define _MAP_GEOMETRY_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_geometry();
+
+#endif  // _MAP_GEOMETRY_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_ice.cpp b/src/FDM/UIUCModel/uiuc_map_ice.cpp
new file mode 100644
index 000000000..7045d3f24
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_ice.cpp
@@ -0,0 +1,142 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_ice.h b/src/FDM/UIUCModel/uiuc_map_ice.h
new file mode 100644
index 000000000..902406617
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_ice.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_ICE_H_
+#define _MAP_ICE_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_ice();
+
+#endif  // _MAP_ICE_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_init.cpp b/src/FDM/UIUCModel/uiuc_map_init.cpp
new file mode 100644
index 000000000..df32532e0
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_init.cpp
@@ -0,0 +1,94 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_init.h b/src/FDM/UIUCModel/uiuc_map_init.h
new file mode 100644
index 000000000..c107a9b86
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_init.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_INIT_H_
+#define _MAP_INIT_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_init();
+
+#endif  // _MAP_INIT_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_keyword.cpp b/src/FDM/UIUCModel/uiuc_map_keyword.cpp
new file mode 100644
index 000000000..aaf98b02f
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_keyword.cpp
@@ -0,0 +1,88 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_keyword.h b/src/FDM/UIUCModel/uiuc_map_keyword.h
new file mode 100644
index 000000000..f8109f16b
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_keyword.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_KEYWORD_H_
+#define _MAP_KEYWORD_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_keyword();
+
+#endif  // _MAP_KEYWORD_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_mass.cpp b/src/FDM/UIUCModel/uiuc_map_mass.cpp
new file mode 100644
index 000000000..5aa25c578
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_mass.cpp
@@ -0,0 +1,79 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_mass.h b/src/FDM/UIUCModel/uiuc_map_mass.h
new file mode 100644
index 000000000..3bab6fde4
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_mass.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_MASS_H_
+#define _MAP_MASS_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_mass();
+
+#endif  // _MAP_MASS_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_misc.cpp b/src/FDM/UIUCModel/uiuc_map_misc.cpp
new file mode 100644
index 000000000..bab8b8b4a
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_misc.cpp
@@ -0,0 +1,75 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_misc.h b/src/FDM/UIUCModel/uiuc_map_misc.h
new file mode 100644
index 000000000..5c966f65a
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_misc.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_MISC_H_
+#define _MAP_MISC_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_misc();
+
+#endif  // _MAP_MISC_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_record1.cpp b/src/FDM/UIUCModel/uiuc_map_record1.cpp
new file mode 100644
index 000000000..9d02585b6
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_record1.cpp
@@ -0,0 +1,152 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_record1.h b/src/FDM/UIUCModel/uiuc_map_record1.h
new file mode 100644
index 000000000..67cbf6f7a
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_record1.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_RECORD1_H_
+#define _MAP_RECORD1_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_record1();
+
+#endif  // _MAP_RECORD1_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_record2.cpp b/src/FDM/UIUCModel/uiuc_map_record2.cpp
new file mode 100644
index 000000000..d54465d6d
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_record2.cpp
@@ -0,0 +1,154 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_record2.h b/src/FDM/UIUCModel/uiuc_map_record2.h
new file mode 100644
index 000000000..f8a352958
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_record2.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_RECORD2_H_
+#define _MAP_RECORD2_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_record2();
+
+#endif  // _MAP_RECORD2_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_record3.cpp b/src/FDM/UIUCModel/uiuc_map_record3.cpp
new file mode 100644
index 000000000..e705f6989
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_record3.cpp
@@ -0,0 +1,143 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_record3.h b/src/FDM/UIUCModel/uiuc_map_record3.h
new file mode 100644
index 000000000..16e6521be
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_record3.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_RECORD3_H_
+#define _MAP_RECORD3_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_record3();
+
+#endif  // _MAP_RECORD3_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_record4.cpp b/src/FDM/UIUCModel/uiuc_map_record4.cpp
new file mode 100644
index 000000000..41ee20502
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_record4.cpp
@@ -0,0 +1,139 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_record4.h b/src/FDM/UIUCModel/uiuc_map_record4.h
new file mode 100644
index 000000000..80c01f321
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_record4.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_RECORD4_H_
+#define _MAP_RECORD4_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_record4();
+
+#endif  // _MAP_RECORD4_H_
diff --git a/src/FDM/UIUCModel/uiuc_map_record5.cpp b/src/FDM/UIUCModel/uiuc_map_record5.cpp
new file mode 100644
index 000000000..d062c0f27
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_record5.cpp
@@ -0,0 +1,125 @@
+/********************************************************************** 
+ 
+ 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
diff --git a/src/FDM/UIUCModel/uiuc_map_record5.h b/src/FDM/UIUCModel/uiuc_map_record5.h
new file mode 100644
index 000000000..dc5de1a1b
--- /dev/null
+++ b/src/FDM/UIUCModel/uiuc_map_record5.h
@@ -0,0 +1,8 @@
+#ifndef _MAP_RECORD5_H_
+#define _MAP_RECORD5_H_
+
+#include "uiuc_aircraft.h"
+
+void uiuc_map_record5();
+
+#endif  // _MAP_RECORD5_H_
diff --git a/src/FDM/UIUCModel/uiuc_menu.cpp b/src/FDM/UIUCModel/uiuc_menu.cpp
index 8e0e919c9..04af84ad6 100644
--- a/src/FDM/UIUCModel/uiuc_menu.cpp
+++ b/src/FDM/UIUCModel/uiuc_menu.cpp
@@ -29,6 +29,18 @@
                             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
 
 ----------------------------------------------------------------------
 
@@ -50,7 +62,7 @@
 
 ----------------------------------------------------------------------
 
- CALLED BY:   uiuc_wrapper.cpp 
+ CALLED BY:    uiuc_wrapper.cpp 
 
 ----------------------------------------------------------------------
 
@@ -78,20 +90,22 @@
 **********************************************************************/
 
 #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;
@@ -99,18 +113,35 @@ void uiuc_menu (string aircraft_name)
   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())
   {
@@ -118,11 +149,10 @@ void uiuc_menu (string aircraft_name)
     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); 
@@ -135,10 +165,6 @@ void uiuc_menu (string aircraft_name)
       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:
@@ -178,6 +204,50 @@ void uiuc_menu (string aircraft_name)
                   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)) 
@@ -277,6 +347,49 @@ void uiuc_menu (string aircraft_name)
                   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);
@@ -324,6 +437,50 @@ void uiuc_menu (string aircraft_name)
                   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);
@@ -332,8 +489,8 @@ void uiuc_menu (string aircraft_name)
               };
             break;
           } // end geometry map
-          
-          
+
+
         case controlSurface_flag:
           {
             switch(controlSurface_map[linetoken2])
@@ -389,6 +546,131 @@ void uiuc_menu (string aircraft_name)
                   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);
@@ -397,12 +679,24 @@ void uiuc_menu (string aircraft_name)
               };
             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))
@@ -483,13 +777,16 @@ void uiuc_menu (string aircraft_name)
                   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);
@@ -513,7 +810,7 @@ void uiuc_menu (string aircraft_name)
                   
                   CDo = token_value;
                   CDo_clean = CDo;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroDragParts -> storeCommands (*command_line);
                   break;
                 }
               case CDK_flag:
@@ -525,7 +822,7 @@ void uiuc_menu (string aircraft_name)
                   
                   CDK = token_value;
                   CDK_clean = CDK;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroDragParts -> storeCommands (*command_line);
                   break;
                 }
               case CD_a_flag:
@@ -537,7 +834,42 @@ void uiuc_menu (string aircraft_name)
                   
                   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:
@@ -549,70 +881,258 @@ void uiuc_menu (string aircraft_name)
                   
                   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;
@@ -621,7 +1141,7 @@ void uiuc_menu (string aircraft_name)
                   
                   CLo = token_value;
                   CLo_clean = CLo;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroLiftParts -> storeCommands (*command_line);
                   break;
                 }
               case CL_a_flag:
@@ -633,7 +1153,7 @@ void uiuc_menu (string aircraft_name)
                   
                   CL_a = token_value;
                   CL_a_clean = CL_a;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroLiftParts -> storeCommands (*command_line);
                   break;
                 }
               case CL_adot_flag:
@@ -645,7 +1165,7 @@ void uiuc_menu (string aircraft_name)
 
                   CL_adot = token_value;
                   CL_adot_clean = CL_adot;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroLiftParts -> storeCommands (*command_line);
                   break;
                 }
               case CL_q_flag:
@@ -657,7 +1177,18 @@ void uiuc_menu (string aircraft_name)
 
                   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:
@@ -669,65 +1200,233 @@ void uiuc_menu (string aircraft_name)
 
                   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])
@@ -741,7 +1440,7 @@ void uiuc_menu (string aircraft_name)
 
                   Cmo = token_value;
                   Cmo_clean = Cmo;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroPitchParts -> storeCommands (*command_line);
                   break;
                 }
               case Cm_a_flag:
@@ -753,7 +1452,19 @@ void uiuc_menu (string aircraft_name)
 
                   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:
@@ -765,7 +1476,7 @@ void uiuc_menu (string aircraft_name)
 
                   Cm_adot = token_value;
                   Cm_adot_clean = Cm_adot;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroPitchParts -> storeCommands (*command_line);
                   break;
                 }
               case Cm_q_flag:
@@ -777,7 +1488,18 @@ void uiuc_menu (string aircraft_name)
 
                   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:
@@ -789,34 +1511,127 @@ void uiuc_menu (string aircraft_name)
 
                   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:
@@ -828,6 +1643,7 @@ void uiuc_menu (string aircraft_name)
             break;
           } // end Cm map
 
+
         case CY_flag:
           {
             switch(CY_map[linetoken2])
@@ -841,7 +1657,7 @@ void uiuc_menu (string aircraft_name)
 
                   CYo = token_value;
                   CYo_clean = CYo;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroSideforceParts -> storeCommands (*command_line);
                   break;
                 }
               case CY_beta_flag:
@@ -853,7 +1669,7 @@ void uiuc_menu (string aircraft_name)
 
                   CY_beta = token_value;
                   CY_beta_clean = CY_beta;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroSideforceParts -> storeCommands (*command_line);
                   break;
                 }
               case CY_p_flag:
@@ -865,7 +1681,7 @@ void uiuc_menu (string aircraft_name)
 
                   CY_p = token_value;
                   CY_p_clean = CY_p;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroSideforceParts -> storeCommands (*command_line);
                   break;
                 }
               case CY_r_flag:
@@ -877,7 +1693,7 @@ void uiuc_menu (string aircraft_name)
 
                   CY_r = token_value;
                   CY_r_clean = CY_r;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroSideforceParts -> storeCommands (*command_line);
                   break;
                 }
               case CY_da_flag:
@@ -889,7 +1705,7 @@ void uiuc_menu (string aircraft_name)
 
                   CY_da = token_value;
                   CY_da_clean = CY_da;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroSideforceParts -> storeCommands (*command_line);
                   break;
                 }
               case CY_dr_flag:
@@ -901,72 +1717,91 @@ void uiuc_menu (string aircraft_name)
 
                   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])
@@ -980,7 +1815,7 @@ void uiuc_menu (string aircraft_name)
 
                   Clo = token_value;
                   Clo_clean = Clo;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroRollParts -> storeCommands (*command_line);
                   break;
                 }
               case Cl_beta_flag:
@@ -992,7 +1827,7 @@ void uiuc_menu (string aircraft_name)
 
                   Cl_beta = token_value;
                   Cl_beta_clean = Cl_beta;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroRollParts -> storeCommands (*command_line);
                   break;
                 }
               case Cl_p_flag:
@@ -1004,7 +1839,7 @@ void uiuc_menu (string aircraft_name)
 
                   Cl_p = token_value;
                   Cl_p_clean = Cl_p;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroRollParts -> storeCommands (*command_line);
                   break;
                 }
               case Cl_r_flag:
@@ -1016,7 +1851,7 @@ void uiuc_menu (string aircraft_name)
 
                   Cl_r = token_value;
                   Cl_r_clean = Cl_r;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroRollParts -> storeCommands (*command_line);
                   break;
                 }
               case Cl_da_flag:
@@ -1028,7 +1863,7 @@ void uiuc_menu (string aircraft_name)
 
                   Cl_da = token_value;
                   Cl_da_clean = Cl_da;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroRollParts -> storeCommands (*command_line);
                   break;
                 }
               case Cl_dr_flag:
@@ -1040,61 +1875,67 @@ void uiuc_menu (string aircraft_name)
 
                   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:
@@ -1105,6 +1946,8 @@ void uiuc_menu (string aircraft_name)
               };
             break;
           } // end Cl map
+
+
         case Cn_flag:
           {
             switch(Cn_map[linetoken2])
@@ -1118,7 +1961,7 @@ void uiuc_menu (string aircraft_name)
 
                   Cno = token_value;
                   Cno_clean = Cno;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroYawParts -> storeCommands (*command_line);
                   break;
                 }
               case Cn_beta_flag:
@@ -1130,7 +1973,7 @@ void uiuc_menu (string aircraft_name)
 
                   Cn_beta = token_value;
                   Cn_beta_clean = Cn_beta;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroYawParts -> storeCommands (*command_line);
                   break;
                 }
               case Cn_p_flag:
@@ -1142,7 +1985,7 @@ void uiuc_menu (string aircraft_name)
 
                   Cn_p = token_value;
                   Cn_p_clean = Cn_p;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroYawParts -> storeCommands (*command_line);
                   break;
                 }
               case Cn_r_flag:
@@ -1154,7 +1997,7 @@ void uiuc_menu (string aircraft_name)
 
                   Cn_r = token_value;
                   Cn_r_clean = Cn_r;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroYawParts -> storeCommands (*command_line);
                   break;
                 }
               case Cn_da_flag:
@@ -1166,7 +2009,7 @@ void uiuc_menu (string aircraft_name)
 
                   Cn_da = token_value;
                   Cn_da_clean = Cn_da;
-                  aeroParts -> storeCommands (*command_line);
+                  aeroYawParts -> storeCommands (*command_line);
                   break;
                 }
               case Cn_dr_flag:
@@ -1178,61 +2021,79 @@ void uiuc_menu (string aircraft_name)
 
                   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:
@@ -1279,11 +2140,10 @@ void uiuc_menu (string aircraft_name)
                   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))
@@ -1292,22 +2152,40 @@ void uiuc_menu (string aircraft_name)
                     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))
@@ -1316,7 +2194,6 @@ void uiuc_menu (string aircraft_name)
                     uiuc_warnings_errors(1, *command_line);
                   
                   kCDo = token_value;
-                  aeroParts -> storeCommands (*command_line);
                   break;
                 }
               case kCDK_flag:
@@ -1327,7 +2204,6 @@ void uiuc_menu (string aircraft_name)
                     uiuc_warnings_errors(1, *command_line);
                   
                   kCDK = token_value;
-                  aeroParts -> storeCommands (*command_line);
                   break;
                 }
               case kCD_a_flag:
@@ -1338,7 +2214,26 @@ void uiuc_menu (string aircraft_name)
                     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:
@@ -1349,10 +2244,118 @@ void uiuc_menu (string aircraft_name)
                     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))
@@ -1361,7 +2364,6 @@ void uiuc_menu (string aircraft_name)
                     uiuc_warnings_errors(1, *command_line);
                   
                   kCLo = token_value;
-                  aeroParts -> storeCommands (*command_line);
                   break;
                 }
               case kCL_a_flag:
@@ -1372,7 +2374,6 @@ void uiuc_menu (string aircraft_name)
                     uiuc_warnings_errors(1, *command_line);
                   
                   kCL_a = token_value;
-                  aeroParts -> storeCommands (*command_line);
                   break;
                 }
               case kCL_adot_flag:
@@ -1383,7 +2384,6 @@ void uiuc_menu (string aircraft_name)
                     uiuc_warnings_errors(1, *command_line);
 
                   kCL_adot = token_value;
-                  aeroParts -> storeCommands (*command_line);
                   break;
                 }
               case kCL_q_flag:
@@ -1394,7 +2394,6 @@ void uiuc_menu (string aircraft_name)
                     uiuc_warnings_errors(1, *command_line);
 
                   kCL_q = token_value;
-                  aeroParts -> storeCommands (*command_line);
                   break;
                 }
               case kCL_de_flag:
@@ -1405,507 +2404,1490 @@ void uiuc_menu (string aircraft_name)
                     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);
@@ -1981,6 +3963,23 @@ void uiuc_menu (string aircraft_name)
                   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);
@@ -2049,8 +4048,45 @@ void uiuc_menu (string aircraft_name)
               };
             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=="*")
diff --git a/src/FDM/UIUCModel/uiuc_menu.h b/src/FDM/UIUCModel/uiuc_menu.h
index 37ff640f3..ea22d31a3 100644
--- a/src/FDM/UIUCModel/uiuc_menu.h
+++ b/src/FDM/UIUCModel/uiuc_menu.h
@@ -9,7 +9,9 @@
 #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);
diff --git a/src/FDM/UIUCModel/uiuc_parsefile.cpp b/src/FDM/UIUCModel/uiuc_parsefile.cpp
index b88a7ae40..a9ab68c93 100644
--- a/src/FDM/UIUCModel/uiuc_parsefile.cpp
+++ b/src/FDM/UIUCModel/uiuc_parsefile.cpp
@@ -62,11 +62,10 @@
  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)
 {
diff --git a/src/FDM/UIUCModel/uiuc_parsefile.h b/src/FDM/UIUCModel/uiuc_parsefile.h
index 9862852bb..09752146c 100644
--- a/src/FDM/UIUCModel/uiuc_parsefile.h
+++ b/src/FDM/UIUCModel/uiuc_parsefile.h
@@ -1,20 +1,10 @@
 #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 "#"
 
diff --git a/src/FDM/UIUCModel/uiuc_recorder.cpp b/src/FDM/UIUCModel/uiuc_recorder.cpp
index 0feb385be..4c1e316d0 100644
--- a/src/FDM/UIUCModel/uiuc_recorder.cpp
+++ b/src/FDM/UIUCModel/uiuc_recorder.cpp
@@ -21,6 +21,10 @@
  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
 
 ----------------------------------------------------------------------
 
@@ -68,386 +72,1234 @@
 
 #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
diff --git a/src/FDM/UIUCModel/uiuc_recorder.h b/src/FDM/UIUCModel/uiuc_recorder.h
index 4ae5be90a..f3dfd3c6e 100644
--- a/src/FDM/UIUCModel/uiuc_recorder.h
+++ b/src/FDM/UIUCModel/uiuc_recorder.h
@@ -5,6 +5,8 @@
 #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;
 
diff --git a/src/FDM/UIUCModel/uiuc_warnings_errors.cpp b/src/FDM/UIUCModel/uiuc_warnings_errors.cpp
index 22810fff0..e6b015ebf 100644
--- a/src/FDM/UIUCModel/uiuc_warnings_errors.cpp
+++ b/src/FDM/UIUCModel/uiuc_warnings_errors.cpp
@@ -74,12 +74,8 @@ for information.
  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)
diff --git a/src/FDM/UIUCModel/uiuc_warnings_errors.h b/src/FDM/UIUCModel/uiuc_warnings_errors.h
index a2f18422c..80cb9eaad 100644
--- a/src/FDM/UIUCModel/uiuc_warnings_errors.h
+++ b/src/FDM/UIUCModel/uiuc_warnings_errors.h
@@ -1,14 +1,8 @@
 #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);
 
diff --git a/src/FDM/UIUCModel/uiuc_wrapper.cpp b/src/FDM/UIUCModel/uiuc_wrapper.cpp
index 90bbdf5ff..b4f025913 100644
--- a/src/FDM/UIUCModel/uiuc_wrapper.cpp
+++ b/src/FDM/UIUCModel/uiuc_wrapper.cpp
@@ -1,68 +1,67 @@
 /********************************************************************** 
- * 
- * 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"
@@ -71,8 +70,8 @@
 #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);
@@ -100,25 +99,32 @@ 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()