src/FDM/UIUCModel/uiuc_menu.cpp

   1 /**********************************************************************
   2
   3  FILENAME:     uiuc_menu.cpp
   4
   5 ----------------------------------------------------------------------
   6
   7  DESCRIPTION:  reads input file for specified aircraft and creates
   8                approporiate data storage space
   9
  10 ----------------------------------------------------------------------
  11
  12  STATUS:       alpha version
  13
  14 ----------------------------------------------------------------------
  15
  16  REFERENCES:   based on "menu reader" format of Michael Selig
  17
  18 ----------------------------------------------------------------------
  19
  20  HISTORY:      01/29/2000   initial release
  21                02/18/2000   (JS) added 1D data file capability for
  22                             CL(a) and CD(a) -- calls
  23                             uiuc_1DdataFileReader
  24                02/22/2000   (JS) added ice map functions
  25                02/29/2000   (JS) added 2D data file capability for
  26                             CL(a,de), CD(a,de), Cm(a,de), CY(a,da),
  27                             CY(beta,dr), Cl(a,da), Cl(beta,dr),
  28                             Cn(a,da), Cn(beta,dr) -- calls
  29                             uiuc_2DdataFileReader
  30                02/02/2000   (JS) added record options for 1D and
  31                             2D interpolated variables
  32                03/28/2000   (JS) streamlined conversion factors for
  33                             file readers -- since they are global
  34                             variables, it is not necessary to put
  35                             them in the function calls
  36                03/29/2000   (JS) added Cmfa and Weight flags;
  37                             added misc map; added Dx_cg (etc) to init
  38                             map
  39                04/01/2000   (JS) added throttle, longitudinal, lateral,
  40                             and rudder inputs to record map
  41                04/05/2000   (JS) added Altitude to init and record
  42                             maps; added zero_Long_trim to
  43                             controlSurface map
  44                03/09/2001   (DPM) added support for gear.
  45                06/18/2001   (RD) Added Alpha, Beta, U_body,
  46                             V_body, and W_body to init map.  Added
  47                             aileron_input, rudder_input, pilot_elev_no,
  48                             pilot_ail_no, and pilot_rud_no to
  49                             controlSurface map.  Added Throttle_pct_input
  50                             to engine map.  Added CZfa to CL map.
  51                07/05/2001   (RD) Changed pilot_elev_no = true to pilot_
  52                             elev_no_check=false.  This is to allow pilot
  53                             to fly aircraft after input files have been
  54                             used.
  55                08/27/2001   (RD) Added xxx_init_true and xxx_init for
  56                             P_body, Q_body, R_body, Phi, Theta, Psi,
  57                             U_body, V_body, and W_body to help in
  58                             starting the A/C at an initial condition.
  59                10/25/2001   (RD) Added new variables needed for the non-
  60                             linear Twin Otter model at zero flaps
  61                             (Cxfxxf0)
  62                11/12/2001   (RD) Added new variables needed for the non-
  63                             linear Twin Otter model with flaps
  64                             (Cxfxxf).  Removed zero flap variables.
  65                             Added minmaxfind() which is needed for non-
  66                             linear variables
  67                01/11/2002   (AP) Added keywords for bootTime
  68                02/13/2002   (RD) Added variables so linear aero model
  69                             values can be recorded
  70                02/18/2002   (RD) Added variables necessary to use the
  71                             uiuc_3Dinterp_quick() function.  Takes
  72                             advantage of data in a "nice" form (data
  73                             that are in a rectangular matrix).
  74                03/13/2002   (RD) Added aircraft_directory so full path
  75                             is no longer needed in the aircraft.dat file
  76                04/02/2002   (RD) Removed minmaxfind() since it was no
  77                             longer needed.  Added d_2_to_3(),
  78                             d_1_to_2(), and i_1_to_2() so uiuc_menu()
  79                             will compile with certain compilers.
  80                08/29/2002   (RD) Separated each primary keyword into its
  81                             own function to speed up compile time
  82                08/29/2002   (RD w/ help from CO) Made changes to shorten
  83                             compile time.  [] RD to add more comments here.
  84                08/29/2003   (MSS) Adding new keywords for new engine model
  85                             and slipstream effects on tail.
  86
  87 ----------------------------------------------------------------------
  88
  89  AUTHOR(S):    Bipin Sehgal       <bsehgal@uiuc.edu>
  90                Jeff Scott         <jscott@mail.com>
  91                Robert Deters      <rdeters@uiuc.edu>
  92                Michael Selig      <m-selig@uiuc.edu>
  93                David Megginson    <david@megginson.com>
  94                Ann Peedikayil     <peedikay@uiuc.edu>
  95 ----------------------------------------------------------------------
  96
  97  VARIABLES:
  98
  99 ----------------------------------------------------------------------
 100
 101  INPUTS:       n/a
 102
 103 ----------------------------------------------------------------------
 104
 105  OUTPUTS:      n/a
 106
 107 ----------------------------------------------------------------------
 108
 109  CALLED BY:    uiuc_wrapper.cpp
 110
 111 ----------------------------------------------------------------------
 112
 113  CALLS TO:     aircraft.dat
 114                tabulated data files (if needed)
 115
 116 ----------------------------------------------------------------------
 117
 118  COPYRIGHT:    (C) 2000 by Michael Selig
 119
 120  This program is free software; you can redistribute it and/or
 121  modify it under the terms of the GNU General Public License
 122  as published by the Free Software Foundation.
 123
 124  This program is distributed in the hope that it will be useful,
 125  but WITHOUT ANY WARRANTY; without even the implied warranty of
 126  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 127  GNU General Public License for more details.
 128
 129  You should have received a copy of the GNU General Public License
 130  along with this program; if not, write to the Free Software
 131  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 132  USA or view http://www.gnu.org/copyleft/gpl.html.
 133
 134 **********************************************************************/
 135
 136 #include <simgear/compiler.h>
 137
 138 #if defined( __MWERKS__ )
 139 // -dw- optimizer chokes (big-time) trying to optimize humongous
 140 // loop/switch statements
 141 #pragma optimization_level 0
 142 #endif
 143
 144 #include <stdlib.h>
 145 #include <string.h>
 146 #include STL_IOSTREAM
 147
 148 #include "uiuc_menu.h"
 149
 150 #if !defined (SG_HAVE_NATIVE_SGI_COMPILERS)
 151 SG_USING_STD(cerr);
 152 SG_USING_STD(cout);
 153 SG_USING_STD(endl);
 154
 155 #  ifndef _MSC_VER
 156 SG_USING_STD(exit);
 157 #  endif
 158 #endif
 159
 160 bool check_float( const string &token)
 161 {
 162   float value;
 163   istrstream stream(token.c_str());
 164   return (stream >> value);
 165 }
 166
 167 void d_2_to_3( double array2D[100][100], double array3D[][100][100], int index3D)
 168 {
 169   for (register int i=0; i<=99; i++)
 170     {
 171       for (register int j=1; j<=99; j++)
 172         {
 173           array3D[index3D][i][j]=array2D[i][j];
 174         }
 175     }
 176 }
 177
 178 void d_1_to_2( double array1D[100], double array2D[][100], int index2D)
 179 {
 180   for (register int i=0; i<=99; i++)
 181     {
 182       array2D[index2D][i]=array1D[i];
 183     }
 184 }
 185
 186 void d_1_to_1( double array1[100], double array2[100] )
 187 {
 188   for (register int i=0; i<=99; i++)
 189     {
 190       array2[i]=array1[i];
 191     }
 192 }
 193
 194 void i_1_to_2( int array1D[100], int array2D[][100], int index2D)
 195 {
 196   for (register int i=0; i<=99; i++)
 197     {
 198       array2D[index2D][i]=array1D[i];
 199     }
 200 }
 201
 202 void parse_init( const string& linetoken2, const string& linetoken3,
 203                  const string& linetoken4, LIST command_line ) {
 204     double token_value;
 205     istrstream token3(linetoken3.c_str());
 206     istrstream token4(linetoken4.c_str());
 207     int token_value_recordRate;
 208
 209     switch(init_map[linetoken2])
 210       {
 211       case Dx_pilot_flag:
 212         {
 213           if (check_float(linetoken3))
 214             token3 >> token_value;
 215           else
 216             uiuc_warnings_errors(1, *command_line);
 217
 218           Dx_pilot = token_value;
 219           initParts -> storeCommands (*command_line);
 220           break;
 221         }
 222       case Dy_pilot_flag:
 223         {
 224           if (check_float(linetoken3))
 225             token3 >> token_value;
 226           else
 227             uiuc_warnings_errors(1, *command_line);
 228
 229           Dy_pilot = token_value;
 230           initParts -> storeCommands (*command_line);
 231           break;
 232         }
 233       case Dz_pilot_flag:
 234         {
 235           if (check_float(linetoken3))
 236             token3 >> token_value;
 237           else
 238             uiuc_warnings_errors(1, *command_line);
 239
 240           Dz_pilot = token_value;
 241           initParts -> storeCommands (*command_line);
 242           break;
 243         }
 244       case Dx_cg_flag:
 245         {
 246           if (check_float(linetoken3))
 247             token3 >> token_value;
 248           else
 249             uiuc_warnings_errors(1, *command_line);
 250
 251           Dx_cg = token_value;
 252           initParts -> storeCommands (*command_line);
 253           break;
 254         }
 255       case Dy_cg_flag:
 256         {
 257           if (check_float(linetoken3))
 258             token3 >> token_value;
 259           else
 260             uiuc_warnings_errors(1, *command_line);
 261
 262           Dy_cg = token_value;
 263           initParts -> storeCommands (*command_line);
 264           break;
 265         }
 266       case Dz_cg_flag:
 267         {
 268           if (check_float(linetoken3))
 269             token3 >> token_value;
 270           else
 271             uiuc_warnings_errors(1, *command_line);
 272
 273           Dz_cg = token_value;
 274           initParts -> storeCommands (*command_line);
 275           break;
 276         }
 277       case Altitude_flag:
 278         {
 279           if (check_float(linetoken3))
 280             token3 >> token_value;
 281           else
 282             uiuc_warnings_errors(1, *command_line);
 283
 284           Altitude = token_value;
 285           initParts -> storeCommands (*command_line);
 286           break;
 287         }
 288       case V_north_flag:
 289         {
 290           if (check_float(linetoken3))
 291             token3 >> token_value;
 292           else
 293             uiuc_warnings_errors(1, *command_line);
 294
 295           V_north = token_value;
 296           initParts -> storeCommands (*command_line);
 297           break;
 298         }
 299       case V_east_flag:
 300         {
 301           initParts -> storeCommands (*command_line);
 302           if (check_float(linetoken3))
 303             token3 >> token_value;
 304           else
 305             uiuc_warnings_errors(1, *command_line);
 306
 307           V_east = token_value;
 308           break;
 309         }
 310       case V_down_flag:
 311         {
 312           if (check_float(linetoken3))
 313             token3 >> token_value;
 314           else
 315             uiuc_warnings_errors(1, *command_line);
 316
 317           V_down = token_value;
 318           initParts -> storeCommands (*command_line);
 319           break;
 320         }
 321       case P_body_flag:
 322         {
 323           if (check_float(linetoken3))
 324             token3 >> token_value;
 325           else
 326             uiuc_warnings_errors(1, *command_line);
 327
 328           P_body_init_true = true;
 329           P_body_init = token_value;
 330           initParts -> storeCommands (*command_line);
 331           break;
 332         }
 333       case Q_body_flag:
 334         {
 335           if (check_float(linetoken3))
 336             token3 >> token_value;
 337           else
 338             uiuc_warnings_errors(1, *command_line);
 339
 340           Q_body_init_true = true;
 341           Q_body_init = token_value;
 342           initParts -> storeCommands (*command_line);
 343           break;
 344         }
 345       case R_body_flag:
 346         {
 347           if (check_float(linetoken3))
 348             token3 >> token_value;
 349           else
 350             uiuc_warnings_errors(1, *command_line);
 351
 352           R_body_init_true = true;
 353           R_body_init = token_value;
 354           initParts -> storeCommands (*command_line);
 355           break;
 356         }
 357       case Phi_flag:
 358         {
 359           if (check_float(linetoken3))
 360             token3 >> token_value;
 361           else
 362             uiuc_warnings_errors(1, *command_line);
 363
 364           Phi_init_true = true;
 365           Phi_init = token_value;
 366           initParts -> storeCommands (*command_line);
 367           break;
 368         }
 369       case Theta_flag:
 370         {
 371           if (check_float(linetoken3))
 372             token3 >> token_value;
 373           else
 374             uiuc_warnings_errors(1, *command_line);
 375
 376           Theta_init_true = true;
 377           Theta_init = token_value;
 378           initParts -> storeCommands (*command_line);
 379           break;
 380         }
 381       case Psi_flag:
 382         {
 383           if (check_float(linetoken3))
 384             token3 >> token_value;
 385           else
 386             uiuc_warnings_errors(1, *command_line);
 387
 388           Psi_init_true = true;
 389           Psi_init = token_value;
 390           initParts -> storeCommands (*command_line);
 391           break;
 392         }
 393       case Long_trim_flag:
 394         {
 395           if (check_float(linetoken3))
 396             token3 >> token_value;
 397           else
 398             uiuc_warnings_errors(1, *command_line);
 399
 400           Long_trim = token_value;
 401           initParts -> storeCommands (*command_line);
 402           break;
 403         }
 404       case recordRate_flag:
 405         {
 406           //can't use check_float since variable is integer
 407           token3 >> token_value_recordRate;
 408           recordRate = 120 / token_value_recordRate;
 409           break;
 410         }
 411       case recordStartTime_flag:
 412         {
 413           if (check_float(linetoken3))
 414             token3 >> token_value;
 415           else
 416             uiuc_warnings_errors(1, *command_line);
 417
 418           recordStartTime = token_value;
 419           break;
 420         }
 421       case use_V_rel_wind_2U_flag:
 422         {
 423           use_V_rel_wind_2U = true;
 424           break;
 425         }
 426       case nondim_rate_V_rel_wind_flag:
 427         {
 428           nondim_rate_V_rel_wind = true;
 429           break;
 430         }
 431       case use_abs_U_body_2U_flag:
 432         {
 433           use_abs_U_body_2U = true;
 434           break;
 435         }
 436       case dyn_on_speed_flag:
 437         {
 438           if (check_float(linetoken3))
 439             token3 >> token_value;
 440           else
 441             uiuc_warnings_errors(1, *command_line);
 442
 443           dyn_on_speed = token_value;
 444           break;
 445         }
 446       case dyn_on_speed_zero_flag:
 447         {
 448           if (check_float(linetoken3))
 449             token3 >> token_value;
 450           else
 451             uiuc_warnings_errors(1, *command_line);
 452
 453           dyn_on_speed_zero = token_value;
 454           break;
 455         }
 456       case use_dyn_on_speed_curve1_flag:
 457         {
 458           use_dyn_on_speed_curve1 = true;
 459           break;
 460         }
 461       case use_Alpha_dot_on_speed_flag:
 462         {
 463           use_Alpha_dot_on_speed = true;
 464           if (check_float(linetoken3))
 465             token3 >> token_value;
 466           else
 467             uiuc_warnings_errors(1, *command_line);
 468           Alpha_dot_on_speed = token_value;
 469           break;
 470         }
 471       case downwashMode_flag:
 472         {
 473           b_downwashMode = true;
 474           token3 >> downwashMode;
 475           if (downwashMode==100)
 476             ;
 477           // compute downwash using downwashCoef, do nothing here
 478           else
 479             uiuc_warnings_errors(4, *command_line);
 480           break;
 481         }
 482       case downwashCoef_flag:
 483         {
 484           if (check_float(linetoken3))
 485             token3 >> token_value;
 486           else
 487             uiuc_warnings_errors(1, *command_line);
 488           downwashCoef = token_value;
 489           break;
 490         }
 491       case Alpha_flag:
 492         {
 493           if (check_float(linetoken3))
 494             token3 >> token_value;
 495           else
 496             uiuc_warnings_errors(1, *command_line);
 497
 498           Alpha_init_true = true;
 499           Alpha_init = token_value * DEG_TO_RAD;
 500           break;
 501         }
 502       case Beta_flag:
 503         {
 504           if (check_float(linetoken3))
 505             token3 >> token_value;
 506           else
 507             uiuc_warnings_errors(1, *command_line);
 508
 509           Beta_init_true = true;
 510           Beta_init = token_value * DEG_TO_RAD;
 511           break;
 512         }
 513       case U_body_flag:
 514         {
 515           if (check_float(linetoken3))
 516             token3 >> token_value;
 517           else
 518             uiuc_warnings_errors(1, *command_line);
 519
 520           U_body_init_true = true;
 521           U_body_init = token_value;
 522           break;
 523         }
 524       case V_body_flag:
 525         {
 526           if (check_float(linetoken3))
 527             token3 >> token_value;
 528           else
 529             uiuc_warnings_errors(1, *command_line);
 530
 531           V_body_init_true = true;
 532           V_body_init = token_value;
 533           break;
 534         }
 535       case W_body_flag:
 536         {
 537           if (check_float(linetoken3))
 538             token3 >> token_value;
 539           else
 540             uiuc_warnings_errors(1, *command_line);
 541
 542           W_body_init_true = true;
 543           W_body_init = token_value;
 544           break;
 545         }
 546       case ignore_unknown_flag:
 547         {
 548           dont_ignore=false;
 549           break;
 550         }
 551       case trim_case_2_flag:
 552         {
 553           trim_case_2 = true;
 554           break;
 555         }
 556       case use_uiuc_network_flag:
 557         {
 558           use_uiuc_network = true;
 559           server_IP = linetoken3;
 560           token4 >> port_num;
 561           break;
 562         }
 563       case old_flap_routine_flag:
 564         {
 565           old_flap_routine = true;
 566           break;
 567         }
 568       case icing_demo_flag:
 569         {
 570           icing_demo = true;
 571           break;
 572         }
 573       case outside_control_flag:
 574         {
 575           outside_control = true;
 576           break;
 577         }
 578       default:
 579         {
 580           if (dont_ignore)
 581             uiuc_warnings_errors(2, *command_line);
 582           break;
 583         }
 584       };
 585 }
 586
 587 void parse_geometry( const string& linetoken2, const string& linetoken3,
 588                  LIST command_line ) {
 589     double token_value;
 590     istrstream token3(linetoken3.c_str());
 591
 592     switch(geometry_map[linetoken2])
 593       {
 594       case bw_flag:
 595         {
 596           if (check_float(linetoken3))
 597             token3 >> token_value;
 598           else
 599             uiuc_warnings_errors(1, *command_line);
 600
 601           bw = token_value;
 602           geometryParts -> storeCommands (*command_line);
 603           break;
 604         }
 605       case cbar_flag:
 606         {
 607           if (check_float(linetoken3))
 608             token3 >> token_value;
 609           else
 610             uiuc_warnings_errors(1, *command_line);
 611
 612           cbar = token_value;
 613           geometryParts -> storeCommands (*command_line);
 614           break;
 615         }
 616       case Sw_flag:
 617         {
 618           if (check_float(linetoken3))
 619             token3 >> token_value;
 620           else
 621             uiuc_warnings_errors(1, *command_line);
 622
 623           Sw = token_value;
 624           geometryParts -> storeCommands (*command_line);
 625           break;
 626         }
 627       case ih_flag:
 628         {
 629           if (check_float(linetoken3))
 630             token3 >> token_value;
 631           else
 632             uiuc_warnings_errors(1, *command_line);
 633
 634           ih = token_value;
 635           geometryParts -> storeCommands (*command_line);
 636           break;
 637         }
 638       case bh_flag:
 639         {
 640           if (check_float(linetoken3))
 641             token3 >> token_value;
 642           else
 643             uiuc_warnings_errors(1, *command_line);
 644
 645           bh = token_value;
 646           geometryParts -> storeCommands (*command_line);
 647           break;
 648         }
 649       case ch_flag:
 650         {
 651           if (check_float(linetoken3))
 652             token3 >> token_value;
 653           else
 654             uiuc_warnings_errors(1, *command_line);
 655
 656           ch = token_value;
 657           geometryParts -> storeCommands (*command_line);
 658           break;
 659         }
 660       case Sh_flag:
 661         {
 662           if (check_float(linetoken3))
 663             token3 >> token_value;
 664           else
 665             uiuc_warnings_errors(1, *command_line);
 666
 667           Sh = token_value;
 668           geometryParts -> storeCommands (*command_line);
 669           break;
 670         }
 671       default:
 672         {
 673           if (dont_ignore)
 674             uiuc_warnings_errors(2, *command_line);
 675           break;
 676         }
 677       };
 678 }
 679
 680 void parse_controlSurface( const string& linetoken2, const string& linetoken3,
 681                            const string& linetoken4, const string& linetoken5,
 682                            const string& linetoken6,
 683                            const string& aircraft_directory,
 684                            LIST command_line ) {
 685     double token_value;
 686     int token_value_convert1, token_value_convert2;
 687     istrstream token3(linetoken3.c_str());
 688     istrstream token4(linetoken4.c_str());
 689     istrstream token5(linetoken5.c_str());
 690     istrstream token6(linetoken6.c_str());
 691
 692     switch(controlSurface_map[linetoken2])
 693       {
 694       case de_flag:
 695         {
 696           if (check_float(linetoken3))
 697             token3 >> token_value;
 698           else
 699             uiuc_warnings_errors(1, *command_line);
 700
 701           demax = token_value;
 702
 703           if (check_float(linetoken4))
 704             token4 >> token_value;
 705           else
 706             uiuc_warnings_errors(1, *command_line);
 707
 708           demin = token_value;
 709           break;
 710         }
 711       case da_flag:
 712         {
 713           if (check_float(linetoken3))
 714             token3 >> token_value;
 715           else
 716             uiuc_warnings_errors(1, *command_line);
 717
 718           damax = token_value;
 719
 720           if (check_float(linetoken4))
 721             token4 >> token_value;
 722           else
 723             uiuc_warnings_errors(1, *command_line);
 724
 725           damin = token_value;
 726           break;
 727         }
 728       case dr_flag:
 729         {
 730           if (check_float(linetoken3))
 731             token3 >> token_value;
 732           else
 733             uiuc_warnings_errors(1, *command_line);
 734
 735           drmax = token_value;
 736
 737           if (check_float(linetoken4))
 738             token4 >> token_value;
 739           else
 740             uiuc_warnings_errors(1, *command_line);
 741
 742           drmin = token_value;
 743           break;
 744         }
 745       case set_Long_trim_flag:
 746         {
 747           if (check_float(linetoken3))
 748             token3 >> token_value;
 749           else
 750             uiuc_warnings_errors(1, *command_line);
 751
 752           set_Long_trim = true;
 753           elevator_tab = token_value;
 754           break;
 755         }
 756       case set_Long_trim_deg_flag:
 757         {
 758           if (check_float(linetoken3))
 759             token3 >> token_value;
 760           else
 761             uiuc_warnings_errors(1, *command_line);
 762
 763           set_Long_trim = true;
 764           elevator_tab = token_value * DEG_TO_RAD;
 765           break;
 766         }
 767       case zero_Long_trim_flag:
 768         {
 769           zero_Long_trim = true;
 770           break;
 771         }
 772       case elevator_step_flag:
 773         {
 774           // set step input flag
 775           elevator_step = true;
 776
 777           // read in step angle in degrees and convert
 778           if (check_float(linetoken3))
 779             token3 >> token_value;
 780           else
 781             uiuc_warnings_errors(1, *command_line);
 782
 783           elevator_step_angle = token_value * DEG_TO_RAD;
 784
 785           // read in step start time
 786           if (check_float(linetoken4))
 787             token4 >> token_value;
 788           else
 789             uiuc_warnings_errors(1, *command_line);
 790
 791           elevator_step_startTime = token_value;
 792           break;
 793         }
 794       case elevator_singlet_flag:
 795         {
 796           // set singlet input flag
 797           elevator_singlet = true;
 798
 799           // read in singlet angle in degrees and convert
 800           if (check_float(linetoken3))
 801             token3 >> token_value;
 802           else
 803             uiuc_warnings_errors(1, *command_line);
 804
 805           elevator_singlet_angle = token_value * DEG_TO_RAD;
 806
 807           // read in singlet start time
 808           if (check_float(linetoken4))
 809             token4 >> token_value;
 810           else
 811             uiuc_warnings_errors(1, *command_line);
 812
 813           elevator_singlet_startTime = token_value;
 814
 815           // read in singlet duration
 816           if (check_float(linetoken5))
 817             token5 >> token_value;
 818           else
 819             uiuc_warnings_errors(1, *command_line);
 820
 821           elevator_singlet_duration = token_value;
 822           break;
 823         }
 824       case elevator_doublet_flag:
 825         {
 826           // set doublet input flag
 827           elevator_doublet = true;
 828
 829           // read in doublet angle in degrees and convert
 830           if (check_float(linetoken3))
 831             token3 >> token_value;
 832           else
 833             uiuc_warnings_errors(1, *command_line);
 834
 835           elevator_doublet_angle = token_value * DEG_TO_RAD;
 836
 837           // read in doublet start time
 838           if (check_float(linetoken4))
 839             token4 >> token_value;
 840           else
 841             uiuc_warnings_errors(1, *command_line);
 842
 843           elevator_doublet_startTime = token_value;
 844
 845           // read in doublet duration
 846           if (check_float(linetoken5))
 847             token5 >> token_value;
 848           else
 849             uiuc_warnings_errors(1, *command_line);
 850
 851           elevator_doublet_duration = token_value;
 852           break;
 853         }
 854       case elevator_input_flag:
 855         {
 856           elevator_input = true;
 857           elevator_input_file = aircraft_directory + linetoken3;
 858           token4 >> token_value_convert1;
 859           token5 >> token_value_convert2;
 860           convert_y = uiuc_convert(token_value_convert1);
 861           convert_x = uiuc_convert(token_value_convert2);
 862           uiuc_1DdataFileReader(elevator_input_file,
 863                                 elevator_input_timeArray,
 864                                 elevator_input_deArray,
 865                                 elevator_input_ntime);
 866           token6 >> token_value;
 867           elevator_input_startTime = token_value;
 868           break;
 869         }
 870       case aileron_input_flag:
 871         {
 872           aileron_input = true;
 873           aileron_input_file = aircraft_directory + linetoken3;
 874           token4 >> token_value_convert1;
 875           token5 >> token_value_convert2;
 876           convert_y = uiuc_convert(token_value_convert1);
 877           convert_x = uiuc_convert(token_value_convert2);
 878           uiuc_1DdataFileReader(aileron_input_file,
 879                                 aileron_input_timeArray,
 880                                 aileron_input_daArray,
 881                                 aileron_input_ntime);
 882           token6 >> token_value;
 883           aileron_input_startTime = token_value;
 884           break;
 885         }
 886       case rudder_input_flag:
 887         {
 888           rudder_input = true;
 889           rudder_input_file = aircraft_directory + linetoken3;
 890           token4 >> token_value_convert1;
 891           token5 >> token_value_convert2;
 892           convert_y = uiuc_convert(token_value_convert1);
 893           convert_x = uiuc_convert(token_value_convert2);
 894           uiuc_1DdataFileReader(rudder_input_file,
 895                                 rudder_input_timeArray,
 896                                 rudder_input_drArray,
 897                                 rudder_input_ntime);
 898           token6 >> token_value;
 899           rudder_input_startTime = token_value;
 900           break;
 901         }
 902       case flap_pos_input_flag:
 903         {
 904           flap_pos_input = true;
 905           flap_pos_input_file = aircraft_directory + linetoken3;
 906           token4 >> token_value_convert1;
 907           token5 >> token_value_convert2;
 908           convert_y = uiuc_convert(token_value_convert1);
 909           convert_x = uiuc_convert(token_value_convert2);
 910           uiuc_1DdataFileReader(flap_pos_input_file,
 911                                 flap_pos_input_timeArray,
 912                                 flap_pos_input_dfArray,
 913                                 flap_pos_input_ntime);
 914           token6 >> token_value;
 915           flap_pos_input_startTime = token_value;
 916           break;
 917         }
 918       case pilot_elev_no_flag:
 919         {
 920           pilot_elev_no_check = true;
 921           break;
 922         }
 923       case pilot_ail_no_flag:
 924         {
 925           pilot_ail_no_check = true;
 926           break;
 927         }
 928       case pilot_rud_no_flag:
 929         {
 930           pilot_rud_no_check = true;
 931           break;
 932         }
 933       case flap_max_flag:
 934         {
 935           if (check_float(linetoken3))
 936             token3 >> token_value;
 937           else
 938             uiuc_warnings_errors(1, *command_line);
 939
 940           flap_max = token_value;
 941           break;
 942         }
 943       case flap_rate_flag:
 944         {
 945           if (check_float(linetoken3))
 946             token3 >> token_value;
 947           else
 948             uiuc_warnings_errors(1, *command_line);
 949
 950           flap_rate = token_value;
 951           break;
 952         }
 953       default:
 954         {
 955           if (dont_ignore)
 956             uiuc_warnings_errors(2, *command_line);
 957           break;
 958         }
 959       };
 960 }
 961
 962 void parse_mass( const string& linetoken2, const string& linetoken3,
 963                  LIST command_line ) {
 964     double token_value;
 965     istrstream token3(linetoken3.c_str());
 966
 967     switch(mass_map[linetoken2])
 968       {
 969       case Weight_flag:
 970         {
 971           if (check_float(linetoken3))
 972             token3 >> token_value;
 973           else
 974             uiuc_warnings_errors(1, *command_line);
 975
 976           Weight = token_value;
 977           Mass = Weight * INVG;
 978           massParts -> storeCommands (*command_line);
 979           break;
 980         }
 981       case Mass_flag:
 982         {
 983           if (check_float(linetoken3))
 984             token3 >> token_value;
 985           else
 986             uiuc_warnings_errors(1, *command_line);
 987
 988           Mass = token_value;
 989           massParts -> storeCommands (*command_line);
 990           break;
 991         }
 992       case I_xx_flag:
 993         {
 994           if (check_float(linetoken3))
 995             token3 >> token_value;
 996           else
 997             uiuc_warnings_errors(1, *command_line);
 998
 999           I_xx = token_value;
1000           massParts -> storeCommands (*command_line);
1001           break;
1002         }
1003       case I_yy_flag:
1004         {
1005           if (check_float(linetoken3))
1006             token3 >> token_value;
1007           else
1008             uiuc_warnings_errors(1, *command_line);
1009
1010           I_yy = token_value;
1011           massParts -> storeCommands (*command_line);
1012           break;
1013         }
1014       case I_zz_flag:
1015         {
1016           if (check_float(linetoken3))
1017             token3 >> token_value;
1018           else
1019             uiuc_warnings_errors(1, *command_line);
1020
1021           I_zz = token_value;
1022           massParts -> storeCommands (*command_line);
1023           break;
1024         }
1025       case I_xz_flag:
1026         {
1027           if (check_float(linetoken3))
1028             token3 >> token_value;
1029           else
1030             uiuc_warnings_errors(1, *command_line);
1031
1032           I_xz = token_value;
1033           massParts -> storeCommands (*command_line);
1034           break;
1035         }
1036       case Mass_appMass_ratio_flag:
1037         {
1038           if (check_float(linetoken3))
1039             token3 >> token_value;
1040           else
1041             uiuc_warnings_errors(1, *command_line);
1042
1043           Mass_appMass_ratio = token_value;
1044           massParts -> storeCommands (*command_line);
1045           break;
1046         }
1047       case I_xx_appMass_ratio_flag:
1048         {
1049           if (check_float(linetoken3))
1050             token3 >> token_value;
1051           else
1052             uiuc_warnings_errors(1, *command_line);
1053
1054           I_xx_appMass_ratio = token_value;
1055           massParts -> storeCommands (*command_line);
1056           break;
1057         }
1058       case I_yy_appMass_ratio_flag:
1059         {
1060           if (check_float(linetoken3))
1061             token3 >> token_value;
1062           else
1063             uiuc_warnings_errors(1, *command_line);
1064
1065           I_yy_appMass_ratio = token_value;
1066           massParts -> storeCommands (*command_line);
1067           break;
1068         }
1069       case I_zz_appMass_ratio_flag:
1070         {
1071           if (check_float(linetoken3))
1072             token3 >> token_value;
1073           else
1074             uiuc_warnings_errors(1, *command_line);
1075
1076           I_zz_appMass_ratio = token_value;
1077           massParts -> storeCommands (*command_line);
1078           break;
1079         }
1080       case Mass_appMass_flag:
1081         {
1082           if (check_float(linetoken3))
1083             token3 >> token_value;
1084           else
1085             uiuc_warnings_errors(1, *command_line);
1086
1087           Mass_appMass = token_value;
1088           massParts -> storeCommands (*command_line);
1089           break;
1090         }
1091       case I_xx_appMass_flag:
1092         {
1093           if (check_float(linetoken3))
1094             token3 >> token_value;
1095           else
1096             uiuc_warnings_errors(1, *command_line);
1097
1098           I_xx_appMass = token_value;
1099           massParts -> storeCommands (*command_line);
1100           break;
1101         }
1102       case I_yy_appMass_flag:
1103         {
1104           if (check_float(linetoken3))
1105             token3 >> token_value;
1106           else
1107             uiuc_warnings_errors(1, *command_line);
1108
1109           I_yy_appMass = token_value;
1110           massParts -> storeCommands (*command_line);
1111           break;
1112         }
1113       case I_zz_appMass_flag:
1114         {
1115           if (check_float(linetoken3))
1116             token3 >> token_value;
1117           else
1118             uiuc_warnings_errors(1, *command_line);
1119
1120           I_zz_appMass = token_value;
1121           massParts -> storeCommands (*command_line);
1122           break;
1123         }
1124       default:
1125         {
1126           if (dont_ignore)
1127             uiuc_warnings_errors(2, *command_line);
1128           break;
1129         }
1130       };
1131 }
1132
1133 void parse_engine( const string& linetoken2, const string& linetoken3,
1134                    const string& linetoken4, const string& linetoken5,
1135                    const string& linetoken6, const string& aircraft_directory,
1136                    LIST command_line ) {
1137     double token_value;
1138     int token_value_convert1, token_value_convert2;
1139     istrstream token3(linetoken3.c_str());
1140     istrstream token4(linetoken4.c_str());
1141     istrstream token5(linetoken5.c_str());
1142     istrstream token6(linetoken6.c_str());
1143
1144     switch(engine_map[linetoken2])
1145       {
1146       case simpleSingle_flag:
1147         {
1148           if (check_float(linetoken3))
1149             token3 >> token_value;
1150           else
1151             uiuc_warnings_errors(1, *command_line);
1152
1153           simpleSingleMaxThrust = token_value;
1154           engineParts -> storeCommands (*command_line);
1155           break;
1156         }
1157       case simpleSingleModel_flag:
1158         {
1159           simpleSingleModel = true;
1160           /* input the thrust at zero speed */
1161           if (check_float(linetoken3))
1162             token3 >> token_value;
1163           else
1164             uiuc_warnings_errors(1, *command_line);
1165           t_v0 = token_value;
1166           /* input slope of thrust at speed for which thrust is zero */
1167           if (check_float(linetoken4))
1168             token4 >> token_value;
1169           else
1170             uiuc_warnings_errors(1, *command_line);
1171           dtdv_t0 = token_value;
1172           /* input speed at which thrust is zero */
1173           if (check_float(linetoken5))
1174             token5 >> token_value;
1175           else
1176             uiuc_warnings_errors(1, *command_line);
1177           v_t0 = token_value;
1178           dtdvvt = -dtdv_t0 * v_t0 / t_v0;
1179           engineParts -> storeCommands (*command_line);
1180           break;
1181         }
1182       case c172_flag:
1183         {
1184           engineParts -> storeCommands (*command_line);
1185           break;
1186         }
1187       case cherokee_flag:
1188         {
1189           engineParts -> storeCommands (*command_line);
1190           break;
1191         }
1192       case Throttle_pct_input_flag:
1193         {
1194           Throttle_pct_input = true;
1195           Throttle_pct_input_file = aircraft_directory + linetoken3;
1196           token4 >> token_value_convert1;
1197           token5 >> token_value_convert2;
1198           convert_y = uiuc_convert(token_value_convert1);
1199           convert_x = uiuc_convert(token_value_convert2);
1200           uiuc_1DdataFileReader(Throttle_pct_input_file,
1201                                 Throttle_pct_input_timeArray,
1202                                 Throttle_pct_input_dTArray,
1203                                 Throttle_pct_input_ntime);
1204           token6 >> token_value;
1205           Throttle_pct_input_startTime = token_value;
1206           break;
1207         }
1208       case gyroForce_Q_body_flag:
1209         {
1210           /* include gyroscopic forces due to pitch */
1211           gyroForce_Q_body = true;
1212           break;
1213         }
1214       case gyroForce_R_body_flag:
1215         {
1216           /* include gyroscopic forces due to yaw */
1217           gyroForce_R_body = true;
1218           break;
1219         }
1220
1221       case slipstream_effects_flag:
1222         {
1223         // include slipstream effects
1224           b_slipstreamEffects = true;
1225           if (!simpleSingleModel)
1226             uiuc_warnings_errors(3, *command_line);
1227           break;
1228         }
1229       case propDia_flag:
1230         {
1231           if (check_float(linetoken3))
1232             token3 >> token_value;
1233           else
1234             uiuc_warnings_errors(1, *command_line);
1235           propDia = token_value;
1236           break;
1237         }
1238       case eta_q_Cm_q_flag:
1239         {
1240         // include slipstream effects due to Cm_q
1241           if (check_float(linetoken3))
1242             token3 >> token_value;
1243           else
1244             uiuc_warnings_errors(1, *command_line);
1245           eta_q_Cm_q_fac = token_value;
1246           if (eta_q_Cm_q_fac == 0.0) {eta_q_Cm_q_fac = 1.0;}
1247           break;
1248         }
1249       case eta_q_Cm_adot_flag:
1250         {
1251         // include slipstream effects due to Cm_adot
1252           if (check_float(linetoken3))
1253             token3 >> token_value;
1254           else
1255             uiuc_warnings_errors(1, *command_line);
1256           eta_q_Cm_adot_fac = token_value;
1257           if (eta_q_Cm_adot_fac == 0.0) {eta_q_Cm_adot_fac = 1.0;}
1258           break;
1259         }
1260       case eta_q_Cmfade_flag:
1261         {
1262         // include slipstream effects due to Cmfade
1263           if (check_float(linetoken3))
1264             token3 >> token_value;
1265           else
1266             uiuc_warnings_errors(1, *command_line);
1267           eta_q_Cmfade_fac = token_value;
1268           if (eta_q_Cmfade_fac == 0.0) {eta_q_Cmfade_fac = 1.0;}
1269           break;
1270         }
1271       case eta_q_Cl_beta_flag:
1272         {
1273         // include slipstream effects due to Cl_beta
1274           if (check_float(linetoken3))
1275             token3 >> token_value;
1276           else
1277             uiuc_warnings_errors(1, *command_line);
1278           eta_q_Cl_beta_fac = token_value;
1279           if (eta_q_Cl_beta_fac == 0.0) {eta_q_Cl_beta_fac = 1.0;}
1280           break;
1281         }
1282       case eta_q_Cl_p_flag:
1283         {
1284         // include slipstream effects due to Cl_p
1285           if (check_float(linetoken3))
1286             token3 >> token_value;
1287           else
1288             uiuc_warnings_errors(1, *command_line);
1289           eta_q_Cl_p_fac = token_value;
1290           if (eta_q_Cl_p_fac == 0.0) {eta_q_Cl_p_fac = 1.0;}
1291           break;
1292         }
1293       case eta_q_Cl_r_flag:
1294         {
1295         // include slipstream effects due to Cl_r
1296           if (check_float(linetoken3))
1297             token3 >> token_value;
1298           else
1299             uiuc_warnings_errors(1, *command_line);
1300           eta_q_Cl_r_fac = token_value;
1301           if (eta_q_Cl_r_fac == 0.0) {eta_q_Cl_r_fac = 1.0;}
1302           break;
1303         }
1304       case eta_q_Cl_dr_flag:
1305         {
1306         // include slipstream effects due to Cl_dr
1307           if (check_float(linetoken3))
1308             token3 >> token_value;
1309           else
1310             uiuc_warnings_errors(1, *command_line);
1311           eta_q_Cl_dr_fac = token_value;
1312           if (eta_q_Cl_dr_fac == 0.0) {eta_q_Cl_dr_fac = 1.0;}
1313           break;
1314         }
1315       case eta_q_CY_beta_flag:
1316         {
1317         // include slipstream effects due to CY_beta
1318           if (check_float(linetoken3))
1319             token3 >> token_value;
1320           else
1321             uiuc_warnings_errors(1, *command_line);
1322           eta_q_CY_beta_fac = token_value;
1323           if (eta_q_CY_beta_fac == 0.0) {eta_q_CY_beta_fac = 1.0;}
1324           break;
1325         }
1326       case eta_q_CY_p_flag:
1327         {
1328         // include slipstream effects due to CY_p
1329           if (check_float(linetoken3))
1330             token3 >> token_value;
1331           else
1332             uiuc_warnings_errors(1, *command_line);
1333           eta_q_CY_p_fac = token_value;
1334           if (eta_q_CY_p_fac == 0.0) {eta_q_CY_p_fac = 1.0;}
1335           break;
1336         }
1337       case eta_q_CY_r_flag:
1338         {
1339         // include slipstream effects due to CY_r
1340           if (check_float(linetoken3))
1341             token3 >> token_value;
1342           else
1343             uiuc_warnings_errors(1, *command_line);
1344           eta_q_CY_r_fac = token_value;
1345           if (eta_q_CY_r_fac == 0.0) {eta_q_CY_r_fac = 1.0;}
1346           break;
1347         }
1348       case eta_q_CY_dr_flag:
1349         {
1350         // include slipstream effects due to CY_dr
1351           if (check_float(linetoken3))
1352             token3 >> token_value;
1353           else
1354             uiuc_warnings_errors(1, *command_line);
1355           eta_q_CY_dr_fac = token_value;
1356           if (eta_q_CY_dr_fac == 0.0) {eta_q_CY_dr_fac = 1.0;}
1357           break;
1358         }
1359       case eta_q_Cn_beta_flag:
1360         {
1361         // include slipstream effects due to Cn_beta
1362           if (check_float(linetoken3))
1363             token3 >> token_value;
1364           else
1365             uiuc_warnings_errors(1, *command_line);
1366           eta_q_Cn_beta_fac = token_value;
1367           if (eta_q_Cn_beta_fac == 0.0) {eta_q_Cn_beta_fac = 1.0;}
1368           break;
1369         }
1370       case eta_q_Cn_p_flag:
1371         {
1372         // include slipstream effects due to Cn_p
1373           if (check_float(linetoken3))
1374             token3 >> token_value;
1375           else
1376             uiuc_warnings_errors(1, *command_line);
1377           eta_q_Cn_p_fac = token_value;
1378           if (eta_q_Cn_p_fac == 0.0) {eta_q_Cn_p_fac = 1.0;}
1379           break;
1380         }
1381       case eta_q_Cn_r_flag:
1382         {
1383         // include slipstream effects due to Cn_r
1384           if (check_float(linetoken3))
1385             token3 >> token_value;
1386           else
1387             uiuc_warnings_errors(1, *command_line);
1388           eta_q_Cn_r_fac = token_value;
1389           if (eta_q_Cn_r_fac == 0.0) {eta_q_Cn_r_fac = 1.0;}
1390           break;
1391         }
1392       case eta_q_Cn_dr_flag:
1393         {
1394         // include slipstream effects due to Cn_dr
1395           if (check_float(linetoken3))
1396             token3 >> token_value;
1397           else
1398             uiuc_warnings_errors(1, *command_line);
1399           eta_q_Cn_dr_fac = token_value;
1400           if (eta_q_Cn_dr_fac == 0.0) {eta_q_Cn_dr_fac = 1.0;}
1401           break;
1402         }
1403
1404       case omega_flag:
1405         {
1406           if (check_float(linetoken3))
1407             token3 >> token_value;
1408           else
1409             uiuc_warnings_errors(1, *command_line);
1410           minOmega = token_value;
1411           if (check_float(linetoken4))
1412             token4 >> token_value;
1413           else
1414             uiuc_warnings_errors(1, *command_line);
1415           maxOmega = token_value;
1416           break;
1417         }
1418       case omegaRPM_flag:
1419         {
1420           if (check_float(linetoken3))
1421             token3 >> token_value;
1422           else
1423             uiuc_warnings_errors(1, *command_line);
1424           minOmegaRPM = token_value;
1425           minOmega    = minOmegaRPM * 2.0 * LS_PI / 60;
1426           if (check_float(linetoken4))
1427             token4 >> token_value;
1428           else
1429             uiuc_warnings_errors(1, *command_line);
1430           maxOmegaRPM = token_value;
1431           maxOmega    = maxOmegaRPM * 2.0 * LS_PI / 60;
1432           break;
1433         }
1434       case polarInertia_flag:
1435         {
1436           if (check_float(linetoken3))
1437             token3 >> token_value;
1438           else
1439             uiuc_warnings_errors(1, *command_line);
1440           polarInertia = token_value;
1441           break;
1442         }
1443       case forcemom_flag:
1444         {
1445           engineParts -> storeCommands (*command_line);
1446           break;
1447         }
1448       case Xp_input_flag:
1449         {
1450           Xp_input = true;
1451           Xp_input_file = aircraft_directory + linetoken3;
1452           token4 >> token_value_convert1;
1453           token5 >> token_value_convert2;
1454           convert_y = uiuc_convert(token_value_convert1);
1455           convert_x = uiuc_convert(token_value_convert2);
1456           uiuc_1DdataFileReader(Xp_input_file,
1457                                 Xp_input_timeArray,
1458                                 Xp_input_XpArray,
1459                                 Xp_input_ntime);
1460           token6 >> token_value;
1461           Xp_input_startTime = token_value;
1462           break;
1463         }
1464       case Zp_input_flag:
1465         {
1466           Zp_input = true;
1467           Zp_input_file = aircraft_directory + linetoken3;
1468           token4 >> token_value_convert1;
1469           token5 >> token_value_convert2;
1470           convert_y = uiuc_convert(token_value_convert1);
1471           convert_x = uiuc_convert(token_value_convert2);
1472           uiuc_1DdataFileReader(Zp_input_file,
1473                                 Zp_input_timeArray,
1474                                 Zp_input_ZpArray,
1475                                 Zp_input_ntime);
1476           token6 >> token_value;
1477           Zp_input_startTime = token_value;
1478           break;
1479         }
1480       case Mp_input_flag:
1481         {
1482           Mp_input = true;
1483           Mp_input_file = aircraft_directory + linetoken3;
1484           token4 >> token_value_convert1;
1485           token5 >> token_value_convert2;
1486           convert_y = uiuc_convert(token_value_convert1);
1487           convert_x = uiuc_convert(token_value_convert2);
1488           uiuc_1DdataFileReader(Mp_input_file,
1489                                 Mp_input_timeArray,
1490                                 Mp_input_MpArray,
1491                                 Mp_input_ntime);
1492           token6 >> token_value;
1493           Mp_input_startTime = token_value;
1494           break;
1495         }
1496       default:
1497         {
1498           if (dont_ignore)
1499             uiuc_warnings_errors(2, *command_line);
1500           break;
1501         }
1502       };
1503 }
1504
1505 void parse_CD( const string& linetoken2, const string& linetoken3,
1506                const string& linetoken4, const string& linetoken5,
1507                const string& linetoken6, const string& linetoken7,
1508                const string& linetoken8, const string& linetoken9,
1509                const string& aircraft_directory,
1510                bool &CXfabetaf_first, bool &CXfadef_first,
1511                bool &CXfaqf_first, LIST command_line ) {
1512     double token_value;
1513     int token_value_convert1, token_value_convert2, token_value_convert3;
1514     double datafile_xArray[100][100], datafile_yArray[100];
1515     double datafile_zArray[100][100];
1516     int datafile_nxArray[100], datafile_ny;
1517     istrstream token3(linetoken3.c_str());
1518     istrstream token4(linetoken4.c_str());
1519     istrstream token5(linetoken5.c_str());
1520     istrstream token6(linetoken6.c_str());
1521     istrstream token7(linetoken7.c_str());
1522     istrstream token8(linetoken8.c_str());
1523     istrstream token9(linetoken9.c_str());
1524
1525     switch(CD_map[linetoken2])
1526       {
1527       case CDo_flag:
1528         {
1529           if (check_float(linetoken3))
1530             token3 >> token_value;
1531           else
1532             uiuc_warnings_errors(1, *command_line);
1533
1534           CDo = token_value;
1535           CDo_clean = CDo;
1536           aeroDragParts -> storeCommands (*command_line);
1537           break;
1538         }
1539       case CDK_flag:
1540         {
1541           if (check_float(linetoken3))
1542             token3 >> token_value;
1543           else
1544             uiuc_warnings_errors(1, *command_line);
1545
1546           CDK = token_value;
1547           CDK_clean = CDK;
1548           aeroDragParts -> storeCommands (*command_line);
1549           break;
1550         }
1551       case CD_a_flag:
1552         {
1553           if (check_float(linetoken3))
1554             token3 >> token_value;
1555           else
1556             uiuc_warnings_errors(1, *command_line);
1557
1558           CD_a = token_value;
1559           CD_a_clean = CD_a;
1560           aeroDragParts -> storeCommands (*command_line);
1561           break;
1562         }
1563       case CD_adot_flag:
1564         {
1565           if (check_float(linetoken3))
1566             token3 >> token_value;
1567           else
1568             uiuc_warnings_errors(1, *command_line);
1569
1570           CD_adot = token_value;
1571           CD_adot_clean = CD_adot;
1572           aeroDragParts -> storeCommands (*command_line);
1573           break;
1574         }
1575       case CD_q_flag:
1576         {
1577           if (check_float(linetoken3))
1578             token3 >> token_value;
1579           else
1580             uiuc_warnings_errors(1, *command_line);
1581
1582           CD_q = token_value;
1583           CD_q_clean = CD_q;
1584           aeroDragParts -> storeCommands (*command_line);
1585           break;
1586         }
1587       case CD_ih_flag:
1588         {
1589           if (check_float(linetoken3))
1590             token3 >> token_value;
1591           else
1592             uiuc_warnings_errors(1, *command_line);
1593
1594           CD_ih = token_value;
1595           aeroDragParts -> storeCommands (*command_line);
1596           break;
1597         }
1598       case CD_de_flag:
1599         {
1600           if (check_float(linetoken3))
1601             token3 >> token_value;
1602           else
1603             uiuc_warnings_errors(1, *command_line);
1604
1605           CD_de = token_value;
1606           CD_de_clean = CD_de;
1607           aeroDragParts -> storeCommands (*command_line);
1608           break;
1609         }
1610       case CDfa_flag:
1611         {
1612           CDfa = aircraft_directory + linetoken3;
1613           token4 >> token_value_convert1;
1614           token5 >> token_value_convert2;
1615           convert_y = uiuc_convert(token_value_convert1);
1616           convert_x = uiuc_convert(token_value_convert2);
1617           /* call 1D File Reader with file name (CDfa) and conversion
1618              factors; function returns array of alphas (aArray) and
1619              corresponding CD values (CDArray) and max number of
1620              terms in arrays (nAlpha) */
1621           uiuc_1DdataFileReader(CDfa,
1622                                 CDfa_aArray,
1623                                 CDfa_CDArray,
1624                                 CDfa_nAlpha);
1625           aeroDragParts -> storeCommands (*command_line);
1626           break;
1627         }
1628       case CDfCL_flag:
1629         {
1630           CDfCL = aircraft_directory + linetoken3;
1631           token4 >> token_value_convert1;
1632           token5 >> token_value_convert2;
1633           convert_y = uiuc_convert(token_value_convert1);
1634           convert_x = uiuc_convert(token_value_convert2);
1635           /* call 1D File Reader with file name (CDfCL) and conversion
1636              factors; function returns array of CLs (CLArray) and
1637              corresponding CD values (CDArray) and max number of
1638              terms in arrays (nCL) */
1639           uiuc_1DdataFileReader(CDfCL,
1640                                 CDfCL_CLArray,
1641                                 CDfCL_CDArray,
1642                                 CDfCL_nCL);
1643           aeroDragParts -> storeCommands (*command_line);
1644           break;
1645         }
1646       case CDfade_flag:
1647         {
1648           CDfade = aircraft_directory + linetoken3;
1649           token4 >> token_value_convert1;
1650           token5 >> token_value_convert2;
1651           token6 >> token_value_convert3;
1652           convert_z = uiuc_convert(token_value_convert1);
1653           convert_x = uiuc_convert(token_value_convert2);
1654           convert_y = uiuc_convert(token_value_convert3);
1655           /* call 2D File Reader with file name (CDfade) and
1656              conversion factors; function returns array of
1657              elevator deflections (deArray) and corresponding
1658              alpha (aArray) and delta CD (CDArray) values and
1659              max number of terms in alpha arrays (nAlphaArray)
1660              and deflection array (nde) */
1661           uiuc_2DdataFileReader(CDfade,
1662                                 CDfade_aArray,
1663                                 CDfade_deArray,
1664                                 CDfade_CDArray,
1665                                 CDfade_nAlphaArray,
1666                                 CDfade_nde);
1667           aeroDragParts -> storeCommands (*command_line);
1668           break;
1669         }
1670       case CDfdf_flag:
1671         {
1672           CDfdf = aircraft_directory + linetoken3;
1673           token4 >> token_value_convert1;
1674           token5 >> token_value_convert2;
1675           convert_y = uiuc_convert(token_value_convert1);
1676           convert_x = uiuc_convert(token_value_convert2);
1677           /* call 1D File Reader with file name (CDfdf) and conversion
1678              factors; function returns array of dfs (dfArray) and
1679              corresponding CD values (CDArray) and max number of
1680              terms in arrays (ndf) */
1681           uiuc_1DdataFileReader(CDfdf,
1682                                 CDfdf_dfArray,
1683                                 CDfdf_CDArray,
1684                                 CDfdf_ndf);
1685           aeroDragParts -> storeCommands (*command_line);
1686           break;
1687         }
1688       case CDfadf_flag:
1689         {
1690           CDfadf = aircraft_directory + linetoken3;
1691           token4 >> token_value_convert1;
1692           token5 >> token_value_convert2;
1693           token6 >> token_value_convert3;
1694           convert_z = uiuc_convert(token_value_convert1);
1695           convert_x = uiuc_convert(token_value_convert2);
1696           convert_y = uiuc_convert(token_value_convert3);
1697           /* call 2D File Reader with file name (CDfadf) and
1698              conversion factors; function returns array of
1699              flap deflections (dfArray) and corresponding
1700              alpha (aArray) and delta CD (CDArray) values and
1701              max number of terms in alpha arrays (nAlphaArray)
1702              and deflection array (ndf) */
1703           uiuc_2DdataFileReader(CDfadf,
1704                                 CDfadf_aArray,
1705                                 CDfadf_dfArray,
1706                                 CDfadf_CDArray,
1707                                 CDfadf_nAlphaArray,
1708                                 CDfadf_ndf);
1709           aeroDragParts -> storeCommands (*command_line);
1710           break;
1711         }
1712       case CXo_flag:
1713         {
1714           if (check_float(linetoken3))
1715             token3 >> token_value;
1716           else
1717             uiuc_warnings_errors(1, *command_line);
1718
1719           CXo = token_value;
1720           CXo_clean = CXo;
1721           aeroDragParts -> storeCommands (*command_line);
1722           break;
1723         }
1724       case CXK_flag:
1725         {
1726           if (check_float(linetoken3))
1727             token3 >> token_value;
1728           else
1729             uiuc_warnings_errors(1, *command_line);
1730
1731           CXK = token_value;
1732           CXK_clean = CXK;
1733           aeroDragParts -> storeCommands (*command_line);
1734           break;
1735         }
1736       case CX_a_flag:
1737         {
1738           if (check_float(linetoken3))
1739             token3 >> token_value;
1740           else
1741             uiuc_warnings_errors(1, *command_line);
1742
1743           CX_a = token_value;
1744           CX_a_clean = CX_a;
1745           aeroDragParts -> storeCommands (*command_line);
1746           break;
1747         }
1748       case CX_a2_flag:
1749         {
1750           if (check_float(linetoken3))
1751             token3 >> token_value;
1752           else
1753             uiuc_warnings_errors(1, *command_line);
1754
1755           CX_a2 = token_value;
1756           CX_a2_clean = CX_a2;
1757           aeroDragParts -> storeCommands (*command_line);
1758           break;
1759         }
1760       case CX_a3_flag:
1761         {
1762           if (check_float(linetoken3))
1763             token3 >> token_value;
1764           else
1765             uiuc_warnings_errors(1, *command_line);
1766
1767           CX_a3 = token_value;
1768           CX_a3_clean = CX_a3;
1769           aeroDragParts -> storeCommands (*command_line);
1770           break;
1771         }
1772       case CX_adot_flag:
1773         {
1774           if (check_float(linetoken3))
1775             token3 >> token_value;
1776           else
1777             uiuc_warnings_errors(1, *command_line);
1778
1779           CX_adot = token_value;
1780           CX_adot_clean = CX_adot;
1781           aeroDragParts -> storeCommands (*command_line);
1782           break;
1783         }
1784       case CX_q_flag:
1785         {
1786           if (check_float(linetoken3))
1787             token3 >> token_value;
1788           else
1789             uiuc_warnings_errors(1, *command_line);
1790
1791           CX_q = token_value;
1792           CX_q_clean = CX_q;
1793           aeroDragParts -> storeCommands (*command_line);
1794           break;
1795         }
1796       case CX_de_flag:
1797         {
1798           if (check_float(linetoken3))
1799             token3 >> token_value;
1800           else
1801             uiuc_warnings_errors(1, *command_line);
1802
1803           CX_de = token_value;
1804           CX_de_clean = CX_de;
1805           aeroDragParts -> storeCommands (*command_line);
1806           break;
1807         }
1808       case CX_dr_flag:
1809         {
1810           if (check_float(linetoken3))
1811             token3 >> token_value;
1812           else
1813             uiuc_warnings_errors(1, *command_line);
1814
1815           CX_dr = token_value;
1816           CX_dr_clean = CX_dr;
1817           aeroDragParts -> storeCommands (*command_line);
1818           break;
1819         }
1820       case CX_df_flag:
1821         {
1822           if (check_float(linetoken3))
1823             token3 >> token_value;
1824           else
1825             uiuc_warnings_errors(1, *command_line);
1826
1827           CX_df = token_value;
1828           CX_df_clean = CX_df;
1829           aeroDragParts -> storeCommands (*command_line);
1830           break;
1831         }
1832       case CX_adf_flag:
1833         {
1834           if (check_float(linetoken3))
1835             token3 >> token_value;
1836           else
1837             uiuc_warnings_errors(1, *command_line);
1838
1839           CX_adf = token_value;
1840           CX_adf_clean = CX_adf;
1841           aeroDragParts -> storeCommands (*command_line);
1842           break;
1843         }
1844       case CXfabetaf_flag:
1845         {
1846           int CXfabetaf_index, i;
1847           string CXfabetaf_file;
1848           double flap_value;
1849           CXfabetaf_file = aircraft_directory + linetoken3;
1850           token4 >> CXfabetaf_index;
1851           if (CXfabetaf_index < 1 || CXfabetaf_index >= 30)
1852             uiuc_warnings_errors(1, *command_line);
1853           if (CXfabetaf_index > CXfabetaf_nf)
1854             CXfabetaf_nf = CXfabetaf_index;
1855           token5 >> flap_value;
1856           CXfabetaf_fArray[CXfabetaf_index] = flap_value;
1857           token6 >> token_value_convert1;
1858           token7 >> token_value_convert2;
1859           token8 >> token_value_convert3;
1860           token9 >> CXfabetaf_nice;
1861           convert_z = uiuc_convert(token_value_convert1);
1862           convert_x = uiuc_convert(token_value_convert2);
1863           convert_y = uiuc_convert(token_value_convert3);
1864           /* call 2D File Reader with file name (CXfabetaf_file) and
1865              conversion factors; function returns array of
1866              elevator deflections (deArray) and corresponding
1867              alpha (aArray) and delta CZ (CZArray) values and
1868              max number of terms in alpha arrays (nAlphaArray)
1869              and delfection array (nde) */
1870           uiuc_2DdataFileReader(CXfabetaf_file,
1871                                 datafile_xArray,
1872                                 datafile_yArray,
1873                                 datafile_zArray,
1874                                 datafile_nxArray,
1875                                 datafile_ny);
1876           d_2_to_3(datafile_xArray, CXfabetaf_aArray, CXfabetaf_index);
1877           d_1_to_2(datafile_yArray, CXfabetaf_betaArray, CXfabetaf_index);
1878           d_2_to_3(datafile_zArray, CXfabetaf_CXArray, CXfabetaf_index);
1879           i_1_to_2(datafile_nxArray, CXfabetaf_nAlphaArray, CXfabetaf_index);
1880           CXfabetaf_nbeta[CXfabetaf_index] = datafile_ny;
1881           if (CXfabetaf_first==true)
1882             {
1883               if (CXfabetaf_nice == 1)
1884                 {
1885                   CXfabetaf_na_nice = datafile_nxArray[1];
1886                   CXfabetaf_nb_nice = datafile_ny;
1887                   d_1_to_1(datafile_yArray, CXfabetaf_bArray_nice);
1888                   for (i=1; i<=CXfabetaf_na_nice; i++)
1889                     CXfabetaf_aArray_nice[i] = datafile_xArray[1][i];
1890                 }
1891               aeroDragParts -> storeCommands (*command_line);
1892               CXfabetaf_first=false;
1893             }
1894           break;
1895         }
1896       case CXfadef_flag:
1897         {
1898           int CXfadef_index, i;
1899           string CXfadef_file;
1900           double flap_value;
1901           CXfadef_file = aircraft_directory + linetoken3;
1902           token4 >> CXfadef_index;
1903           if (CXfadef_index < 0 || CXfadef_index >= 30)
1904             uiuc_warnings_errors(1, *command_line);
1905           if (CXfadef_index > CXfadef_nf)
1906             CXfadef_nf = CXfadef_index;
1907           token5 >> flap_value;
1908           CXfadef_fArray[CXfadef_index] = flap_value;
1909           token6 >> token_value_convert1;
1910           token7 >> token_value_convert2;
1911           token8 >> token_value_convert3;
1912           token9 >> CXfadef_nice;
1913           convert_z = uiuc_convert(token_value_convert1);
1914           convert_x = uiuc_convert(token_value_convert2);
1915           convert_y = uiuc_convert(token_value_convert3);
1916           /* call 2D File Reader with file name (CXfadef_file) and
1917              conversion factors; function returns array of
1918              elevator deflections (deArray) and corresponding
1919              alpha (aArray) and delta CZ (CZArray) values and
1920              max number of terms in alpha arrays (nAlphaArray)
1921              and delfection array (nde) */
1922           uiuc_2DdataFileReader(CXfadef_file,
1923                                 datafile_xArray,
1924                                 datafile_yArray,
1925                                 datafile_zArray,
1926                                 datafile_nxArray,
1927                                 datafile_ny);
1928           d_2_to_3(datafile_xArray, CXfadef_aArray, CXfadef_index);
1929           d_1_to_2(datafile_yArray, CXfadef_deArray, CXfadef_index);
1930           d_2_to_3(datafile_zArray, CXfadef_CXArray, CXfadef_index);
1931           i_1_to_2(datafile_nxArray, CXfadef_nAlphaArray, CXfadef_index);
1932           CXfadef_nde[CXfadef_index] = datafile_ny;
1933           if (CXfadef_first==true)
1934             {
1935               if (CXfadef_nice == 1)
1936                 {
1937                   CXfadef_na_nice = datafile_nxArray[1];
1938                   CXfadef_nde_nice = datafile_ny;
1939                   d_1_to_1(datafile_yArray, CXfadef_deArray_nice);
1940                   for (i=1; i<=CXfadef_na_nice; i++)
1941                     CXfadef_aArray_nice[i] = datafile_xArray[1][i];
1942                 }
1943               aeroDragParts -> storeCommands (*command_line);
1944               CXfadef_first=false;
1945             }
1946           break;
1947         }
1948       case CXfaqf_flag:
1949         {
1950           int CXfaqf_index, i;
1951           string CXfaqf_file;
1952           double flap_value;
1953           CXfaqf_file = aircraft_directory + linetoken3;
1954           token4 >> CXfaqf_index;
1955           if (CXfaqf_index < 0 || CXfaqf_index >= 30)
1956             uiuc_warnings_errors(1, *command_line);
1957           if (CXfaqf_index > CXfaqf_nf)
1958             CXfaqf_nf = CXfaqf_index;
1959           token5 >> flap_value;
1960           CXfaqf_fArray[CXfaqf_index] = flap_value;
1961           token6 >> token_value_convert1;
1962           token7 >> token_value_convert2;
1963           token8 >> token_value_convert3;
1964           token9 >> CXfaqf_nice;
1965           convert_z = uiuc_convert(token_value_convert1);
1966           convert_x = uiuc_convert(token_value_convert2);
1967           convert_y = uiuc_convert(token_value_convert3);
1968           /* call 2D File Reader with file name (CXfaqf_file) and
1969              conversion factors; function returns array of
1970              elevator deflections (deArray) and corresponding
1971              alpha (aArray) and delta CZ (CZArray) values and
1972              max number of terms in alpha arrays (nAlphaArray)
1973              and delfection array (nde) */
1974           uiuc_2DdataFileReader(CXfaqf_file,
1975                                 datafile_xArray,
1976                                 datafile_yArray,
1977                                 datafile_zArray,
1978                                 datafile_nxArray,
1979                                 datafile_ny);
1980           d_2_to_3(datafile_xArray, CXfaqf_aArray, CXfaqf_index);
1981           d_1_to_2(datafile_yArray, CXfaqf_qArray, CXfaqf_index);
1982           d_2_to_3(datafile_zArray, CXfaqf_CXArray, CXfaqf_index);
1983           i_1_to_2(datafile_nxArray, CXfaqf_nAlphaArray, CXfaqf_index);
1984           CXfaqf_nq[CXfaqf_index] = datafile_ny;
1985           if (CXfaqf_first==true)
1986             {
1987               if (CXfaqf_nice == 1)
1988                 {
1989                   CXfaqf_na_nice = datafile_nxArray[1];
1990                   CXfaqf_nq_nice = datafile_ny;
1991                   d_1_to_1(datafile_yArray, CXfaqf_qArray_nice);
1992                   for (i=1; i<=CXfaqf_na_nice; i++)
1993                     CXfaqf_aArray_nice[i] = datafile_xArray[1][i];
1994                 }
1995               aeroDragParts -> storeCommands (*command_line);
1996               CXfaqf_first=false;
1997             }
1998           break;
1999         }
2000       default:
2001         {
2002           if (dont_ignore)
2003             uiuc_warnings_errors(2, *command_line);
2004           break;
2005         }
2006       };
2007 }
2008
2009
2010 void parse_CL( const string& linetoken2, const string& linetoken3,
2011                const string& linetoken4, const string& linetoken5,
2012                const string& linetoken6, const string& linetoken7,
2013                const string& linetoken8, const string& linetoken9,
2014                const string& aircraft_directory,
2015                bool &CZfabetaf_first, bool &CZfadef_first,
2016                bool &CZfaqf_first, LIST command_line ) {
2017     double token_value;
2018     int token_value_convert1, token_value_convert2, token_value_convert3;
2019     double datafile_xArray[100][100], datafile_yArray[100];
2020     double datafile_zArray[100][100];
2021     int datafile_nxArray[100], datafile_ny;
2022     istrstream token3(linetoken3.c_str());
2023     istrstream token4(linetoken4.c_str());
2024     istrstream token5(linetoken5.c_str());
2025     istrstream token6(linetoken6.c_str());
2026     istrstream token7(linetoken7.c_str());
2027     istrstream token8(linetoken8.c_str());
2028     istrstream token9(linetoken9.c_str());
2029
2030     switch(CL_map[linetoken2])
2031       {
2032       case CLo_flag:
2033         {
2034           if (check_float(linetoken3))
2035             token3 >> token_value;
2036           else
2037             uiuc_warnings_errors(1, *command_line);
2038
2039           CLo = token_value;
2040           CLo_clean = CLo;
2041           aeroLiftParts -> storeCommands (*command_line);
2042           break;
2043         }
2044       case CL_a_flag:
2045         {
2046           if (check_float(linetoken3))
2047             token3 >> token_value;
2048           else
2049             uiuc_warnings_errors(1, *command_line);
2050
2051           CL_a = token_value;
2052           CL_a_clean = CL_a;
2053           aeroLiftParts -> storeCommands (*command_line);
2054           break;
2055         }
2056       case CL_adot_flag:
2057         {
2058           if (check_float(linetoken3))
2059             token3 >> token_value;
2060           else
2061             uiuc_warnings_errors(1, *command_line);
2062
2063           CL_adot = token_value;
2064           CL_adot_clean = CL_adot;
2065           aeroLiftParts -> storeCommands (*command_line);
2066           break;
2067         }
2068       case CL_q_flag:
2069         {
2070           if (check_float(linetoken3))
2071             token3 >> token_value;
2072           else
2073             uiuc_warnings_errors(1, *command_line);
2074
2075           CL_q = token_value;
2076           CL_q_clean = CL_q;
2077           aeroLiftParts -> storeCommands (*command_line);
2078           break;
2079         }
2080       case CL_ih_flag:
2081         {
2082           if (check_float(linetoken3))
2083             token3 >> token_value;
2084           else
2085             uiuc_warnings_errors(1, *command_line);
2086
2087           CL_ih = token_value;
2088           aeroLiftParts -> storeCommands (*command_line);
2089           break;
2090         }
2091       case CL_de_flag:
2092         {
2093           if (check_float(linetoken3))
2094             token3 >> token_value;
2095           else
2096             uiuc_warnings_errors(1, *command_line);
2097
2098           CL_de = token_value;
2099           CL_de_clean = CL_de;
2100           aeroLiftParts -> storeCommands (*command_line);
2101           break;
2102         }
2103       case CLfa_flag:
2104         {
2105           CLfa = aircraft_directory + linetoken3;
2106           token4 >> token_value_convert1;
2107           token5 >> token_value_convert2;
2108           convert_y = uiuc_convert(token_value_convert1);
2109           convert_x = uiuc_convert(token_value_convert2);
2110           /* call 1D File Reader with file name (CLfa) and conversion
2111              factors; function returns array of alphas (aArray) and
2112              corresponding CL values (CLArray) and max number of
2113              terms in arrays (nAlpha) */
2114           uiuc_1DdataFileReader(CLfa,
2115                                 CLfa_aArray,
2116                                 CLfa_CLArray,
2117                                 CLfa_nAlpha);
2118           aeroLiftParts -> storeCommands (*command_line);
2119           break;
2120         }
2121       case CLfade_flag:
2122         {
2123           CLfade = aircraft_directory + linetoken3;
2124           token4 >> token_value_convert1;
2125           token5 >> token_value_convert2;
2126           token6 >> token_value_convert3;
2127           convert_z = uiuc_convert(token_value_convert1);
2128           convert_x = uiuc_convert(token_value_convert2);
2129           convert_y = uiuc_convert(token_value_convert3);
2130           /* call 2D File Reader with file name (CLfade) and
2131              conversion factors; function returns array of
2132              elevator deflections (deArray) and corresponding
2133              alpha (aArray) and delta CL (CLArray) values and
2134              max number of terms in alpha arrays (nAlphaArray)
2135              and deflection array (nde) */
2136           uiuc_2DdataFileReader(CLfade,
2137                                 CLfade_aArray,
2138                                 CLfade_deArray,
2139                                 CLfade_CLArray,
2140                                 CLfade_nAlphaArray,
2141                                 CLfade_nde);
2142           aeroLiftParts -> storeCommands (*command_line);
2143           break;
2144         }
2145       case CLfdf_flag:
2146         {
2147           CLfdf = aircraft_directory + linetoken3;
2148           token4 >> token_value_convert1;
2149           token5 >> token_value_convert2;
2150           convert_y = uiuc_convert(token_value_convert1);
2151           convert_x = uiuc_convert(token_value_convert2);
2152           /* call 1D File Reader with file name (CLfdf) and conversion
2153              factors; function returns array of dfs (dfArray) and
2154              corresponding CL values (CLArray) and max number of
2155              terms in arrays (ndf) */
2156           uiuc_1DdataFileReader(CLfdf,
2157                                 CLfdf_dfArray,
2158                                 CLfdf_CLArray,
2159                                 CLfdf_ndf);
2160           aeroLiftParts -> storeCommands (*command_line);
2161
2162           // additional variables to streamline flap routine in aerodeflections
2163           ndf = CLfdf_ndf;
2164           int temp_counter = 1;
2165           while (temp_counter <= ndf)
2166             {
2167               dfArray[temp_counter] = CLfdf_dfArray[temp_counter];
2168               TimeArray[temp_counter] = dfTimefdf_TimeArray[temp_counter];
2169               temp_counter++;
2170             }
2171           break;
2172         }
2173       case CLfadf_flag:
2174         {
2175           CLfadf = aircraft_directory + linetoken3;
2176           token4 >> token_value_convert1;
2177           token5 >> token_value_convert2;
2178           token6 >> token_value_convert3;
2179           convert_z = uiuc_convert(token_value_convert1);
2180           convert_x = uiuc_convert(token_value_convert2);
2181           convert_y = uiuc_convert(token_value_convert3);
2182           /* call 2D File Reader with file name (CLfadf) and
2183              conversion factors; function returns array of
2184              flap deflections (dfArray) and corresponding
2185              alpha (aArray) and delta CL (CLArray) values and
2186              max number of terms in alpha arrays (nAlphaArray)
2187              and deflection array (ndf) */
2188           uiuc_2DdataFileReader(CLfadf,
2189                                 CLfadf_aArray,
2190                                 CLfadf_dfArray,
2191                                 CLfadf_CLArray,
2192                                 CLfadf_nAlphaArray,
2193                                 CLfadf_ndf);
2194           aeroLiftParts -> storeCommands (*command_line);
2195           break;
2196         }
2197       case CZo_flag:
2198         {
2199           if (check_float(linetoken3))
2200             token3 >> token_value;
2201           else
2202             uiuc_warnings_errors(1, *command_line);
2203
2204           CZo = token_value;
2205           CZo_clean = CZo;
2206           aeroLiftParts -> storeCommands (*command_line);
2207           break;
2208         }
2209       case CZ_a_flag:
2210         {
2211           if (check_float(linetoken3))
2212             token3 >> token_value;
2213           else
2214             uiuc_warnings_errors(1, *command_line);
2215
2216           CZ_a = token_value;
2217           CZ_a_clean = CZ_a;
2218           aeroLiftParts -> storeCommands (*command_line);
2219           break;
2220         }
2221       case CZ_a2_flag:
2222         {
2223           if (check_float(linetoken3))
2224             token3 >> token_value;
2225           else
2226             uiuc_warnings_errors(1, *command_line);
2227
2228           CZ_a2 = token_value;
2229           CZ_a2_clean = CZ_a2;
2230           aeroLiftParts -> storeCommands (*command_line);
2231           break;
2232         }
2233       case CZ_a3_flag:
2234         {
2235           if (check_float(linetoken3))
2236             token3 >> token_value;
2237           else
2238             uiuc_warnings_errors(1, *command_line);
2239
2240           CZ_a3 = token_value;
2241           CZ_a3_clean = CZ_a3;
2242           aeroLiftParts -> storeCommands (*command_line);
2243           break;
2244         }
2245       case CZ_adot_flag:
2246         {
2247           if (check_float(linetoken3))
2248             token3 >> token_value;
2249           else
2250             uiuc_warnings_errors(1, *command_line);
2251
2252           CZ_adot = token_value;
2253           CZ_adot_clean = CZ_adot;
2254           aeroLiftParts -> storeCommands (*command_line);
2255           break;
2256         }
2257       case CZ_q_flag:
2258         {
2259           if (check_float(linetoken3))
2260             token3 >> token_value;
2261           else
2262             uiuc_warnings_errors(1, *command_line);
2263
2264           CZ_q = token_value;
2265           CZ_q_clean = CZ_q;
2266           aeroLiftParts -> storeCommands (*command_line);
2267           break;
2268         }
2269       case CZ_de_flag:
2270         {
2271           if (check_float(linetoken3))
2272             token3 >> token_value;
2273           else
2274             uiuc_warnings_errors(1, *command_line);
2275
2276           CZ_de = token_value;
2277           CZ_de_clean = CZ_de;
2278           aeroLiftParts -> storeCommands (*command_line);
2279           break;
2280         }
2281       case CZ_deb2_flag:
2282         {
2283           if (check_float(linetoken3))
2284             token3 >> token_value;
2285           else
2286             uiuc_warnings_errors(1, *command_line);
2287
2288           CZ_deb2 = token_value;
2289           CZ_deb2_clean = CZ_deb2;
2290           aeroLiftParts -> storeCommands (*command_line);
2291           break;
2292         }
2293       case CZ_df_flag:
2294         {
2295           if (check_float(linetoken3))
2296             token3 >> token_value;
2297           else
2298             uiuc_warnings_errors(1, *command_line);
2299
2300           CZ_df = token_value;
2301           CZ_df_clean = CZ_df;
2302           aeroLiftParts -> storeCommands (*command_line);
2303           break;
2304         }
2305       case CZ_adf_flag:
2306         {
2307           if (check_float(linetoken3))
2308             token3 >> token_value;
2309           else
2310             uiuc_warnings_errors(1, *command_line);
2311
2312           CZ_adf = token_value;
2313           CZ_adf_clean = CZ_adf;
2314           aeroLiftParts -> storeCommands (*command_line);
2315           break;
2316         }
2317       case CZfa_flag:
2318         {
2319           CZfa = aircraft_directory + linetoken3;
2320           token4 >> token_value_convert1;
2321           token5 >> token_value_convert2;
2322           convert_y = uiuc_convert(token_value_convert1);
2323           convert_x = uiuc_convert(token_value_convert2);
2324           /* call 1D File Reader with file name (CZfa) and conversion
2325              factors; function returns array of alphas (aArray) and
2326              corresponding CZ values (CZArray) and max number of
2327              terms in arrays (nAlpha) */
2328           uiuc_1DdataFileReader(CZfa,
2329                                 CZfa_aArray,
2330                                 CZfa_CZArray,
2331                                 CZfa_nAlpha);
2332           aeroLiftParts -> storeCommands (*command_line);
2333           break;
2334         }
2335       case CZfabetaf_flag:
2336         {
2337           int CZfabetaf_index, i;
2338           string CZfabetaf_file;
2339           double flap_value;
2340           CZfabetaf_file = aircraft_directory + linetoken3;
2341           token4 >> CZfabetaf_index;
2342           if (CZfabetaf_index < 0 || CZfabetaf_index >= 30)
2343             uiuc_warnings_errors(1, *command_line);
2344           if (CZfabetaf_index > CZfabetaf_nf)
2345             CZfabetaf_nf = CZfabetaf_index;
2346           token5 >> flap_value;
2347           CZfabetaf_fArray[CZfabetaf_index] = flap_value;
2348           token6 >> token_value_convert1;
2349           token7 >> token_value_convert2;
2350           token8 >> token_value_convert3;
2351           token9 >> CZfabetaf_nice;
2352           convert_z = uiuc_convert(token_value_convert1);
2353           convert_x = uiuc_convert(token_value_convert2);
2354           convert_y = uiuc_convert(token_value_convert3);
2355           /* call 2D File Reader with file name (CZfabetaf_file) and
2356              conversion factors; function returns array of
2357              beta (betaArray) and corresponding
2358              alpha (aArray) and CZ (CZArray) values and
2359              max number of terms in alpha arrays (nAlphaArray)
2360              and beta array (nbeta) */
2361           uiuc_2DdataFileReader(CZfabetaf_file,
2362                                 datafile_xArray,
2363                                 datafile_yArray,
2364                                 datafile_zArray,
2365                                 datafile_nxArray,
2366                                 datafile_ny);
2367           d_2_to_3(datafile_xArray, CZfabetaf_aArray, CZfabetaf_index);
2368           d_1_to_2(datafile_yArray, CZfabetaf_betaArray, CZfabetaf_index);
2369           d_2_to_3(datafile_zArray, CZfabetaf_CZArray, CZfabetaf_index);
2370           i_1_to_2(datafile_nxArray, CZfabetaf_nAlphaArray, CZfabetaf_index);
2371           CZfabetaf_nbeta[CZfabetaf_index] = datafile_ny;
2372           if (CZfabetaf_first==true)
2373             {
2374               if (CZfabetaf_nice == 1)
2375                 {
2376                   CZfabetaf_na_nice = datafile_nxArray[1];
2377                   CZfabetaf_nb_nice = datafile_ny;
2378                   d_1_to_1(datafile_yArray, CZfabetaf_bArray_nice);
2379                   for (i=1; i<=CZfabetaf_na_nice; i++)
2380                     CZfabetaf_aArray_nice[i] = datafile_xArray[1][i];
2381                 }
2382               aeroLiftParts -> storeCommands (*command_line);
2383               CZfabetaf_first=false;
2384             }
2385           break;
2386         }
2387       case CZfadef_flag:
2388         {
2389           int CZfadef_index, i;
2390           string CZfadef_file;
2391           double flap_value;
2392           CZfadef_file = aircraft_directory + linetoken3;
2393           token4 >> CZfadef_index;
2394           if (CZfadef_index < 0 || CZfadef_index >= 30)
2395             uiuc_warnings_errors(1, *command_line);
2396           if (CZfadef_index > CZfadef_nf)
2397             CZfadef_nf = CZfadef_index;
2398           token5 >> flap_value;
2399           CZfadef_fArray[CZfadef_index] = flap_value;
2400           token6 >> token_value_convert1;
2401           token7 >> token_value_convert2;
2402           token8 >> token_value_convert3;
2403           token9 >> CZfadef_nice;
2404           convert_z = uiuc_convert(token_value_convert1);
2405           convert_x = uiuc_convert(token_value_convert2);
2406           convert_y = uiuc_convert(token_value_convert3);
2407           /* call 2D File Reader with file name (CZfadef_file) and
2408              conversion factors; function returns array of
2409              elevator deflections (deArray) and corresponding
2410              alpha (aArray) and delta CZ (CZArray) values and
2411              max number of terms in alpha arrays (nAlphaArray)
2412              and delfection array (nde) */
2413           uiuc_2DdataFileReader(CZfadef_file,
2414                                 datafile_xArray,
2415                                 datafile_yArray,
2416                                 datafile_zArray,
2417                                 datafile_nxArray,
2418                                 datafile_ny);
2419           d_2_to_3(datafile_xArray, CZfadef_aArray, CZfadef_index);
2420           d_1_to_2(datafile_yArray, CZfadef_deArray, CZfadef_index);
2421           d_2_to_3(datafile_zArray, CZfadef_CZArray, CZfadef_index);
2422           i_1_to_2(datafile_nxArray, CZfadef_nAlphaArray, CZfadef_index);
2423           CZfadef_nde[CZfadef_index] = datafile_ny;
2424           if (CZfadef_first==true)
2425             {
2426               if (CZfadef_nice == 1)
2427                 {
2428                   CZfadef_na_nice = datafile_nxArray[1];
2429                   CZfadef_nde_nice = datafile_ny;
2430                   d_1_to_1(datafile_yArray, CZfadef_deArray_nice);
2431                   for (i=1; i<=CZfadef_na_nice; i++)
2432                     CZfadef_aArray_nice[i] = datafile_xArray[1][i];
2433                 }
2434               aeroLiftParts -> storeCommands (*command_line);
2435               CZfadef_first=false;
2436             }
2437           break;
2438         }
2439       case CZfaqf_flag:
2440         {
2441           int CZfaqf_index, i;
2442           string CZfaqf_file;
2443           double flap_value;
2444           CZfaqf_file = aircraft_directory + linetoken3;
2445           token4 >> CZfaqf_index;
2446           if (CZfaqf_index < 0 || CZfaqf_index >= 30)
2447             uiuc_warnings_errors(1, *command_line);
2448           if (CZfaqf_index > CZfaqf_nf)
2449             CZfaqf_nf = CZfaqf_index;
2450           token5 >> flap_value;
2451           CZfaqf_fArray[CZfaqf_index] = flap_value;
2452           token6 >> token_value_convert1;
2453           token7 >> token_value_convert2;
2454           token8 >> token_value_convert3;
2455           token9 >> CZfaqf_nice;
2456           convert_z = uiuc_convert(token_value_convert1);
2457           convert_x = uiuc_convert(token_value_convert2);
2458           convert_y = uiuc_convert(token_value_convert3);
2459           /* call 2D File Reader with file name (CZfaqf_file) and
2460              conversion factors; function returns array of
2461              pitch rate (qArray) and corresponding
2462              alpha (aArray) and delta CZ (CZArray) values and
2463              max number of terms in alpha arrays (nAlphaArray)
2464              and pitch rate array (nq) */
2465           uiuc_2DdataFileReader(CZfaqf_file,
2466                                 datafile_xArray,
2467                                 datafile_yArray,
2468                                 datafile_zArray,
2469                                 datafile_nxArray,
2470                                 datafile_ny);
2471           d_2_to_3(datafile_xArray, CZfaqf_aArray, CZfaqf_index);
2472           d_1_to_2(datafile_yArray, CZfaqf_qArray, CZfaqf_index);
2473           d_2_to_3(datafile_zArray, CZfaqf_CZArray, CZfaqf_index);
2474           i_1_to_2(datafile_nxArray, CZfaqf_nAlphaArray, CZfaqf_index);
2475           CZfaqf_nq[CZfaqf_index] = datafile_ny;
2476           if (CZfaqf_first==true)
2477             {
2478               if (CZfaqf_nice == 1)
2479                 {
2480                   CZfaqf_na_nice = datafile_nxArray[1];
2481                   CZfaqf_nq_nice = datafile_ny;
2482                   d_1_to_1(datafile_yArray, CZfaqf_qArray_nice);
2483                   for (i=1; i<=CZfaqf_na_nice; i++)
2484                     CZfaqf_aArray_nice[i] = datafile_xArray[1][i];
2485                 }
2486               aeroLiftParts -> storeCommands (*command_line);
2487               CZfaqf_first=false;
2488             }
2489           break;
2490         }
2491       default:
2492         {
2493           if (dont_ignore)
2494             uiuc_warnings_errors(2, *command_line);
2495           break;
2496         }
2497       };
2498 }
2499
2500
2501 void parse_Cm( const string& linetoken2, const string& linetoken3,
2502                const string& linetoken4, const string& linetoken5,
2503                const string& linetoken6, const string& linetoken7,
2504                const string& linetoken8, const string& linetoken9,
2505                const string& aircraft_directory,
2506                bool &Cmfabetaf_first, bool &Cmfadef_first,
2507                bool &Cmfaqf_first, LIST command_line ) {
2508     double token_value;
2509     int token_value_convert1, token_value_convert2, token_value_convert3;
2510     double datafile_xArray[100][100], datafile_yArray[100];
2511     double datafile_zArray[100][100];
2512     int datafile_nxArray[100], datafile_ny;
2513     istrstream token3(linetoken3.c_str());
2514     istrstream token4(linetoken4.c_str());
2515     istrstream token5(linetoken5.c_str());
2516     istrstream token6(linetoken6.c_str());
2517     istrstream token7(linetoken7.c_str());
2518     istrstream token8(linetoken8.c_str());
2519     istrstream token9(linetoken9.c_str());
2520
2521     switch(Cm_map[linetoken2])
2522       {
2523       case Cmo_flag:
2524         {
2525           if (check_float(linetoken3))
2526             token3 >> token_value;
2527           else
2528             uiuc_warnings_errors(1, *command_line);
2529
2530           Cmo = token_value;
2531           Cmo_clean = Cmo;
2532           aeroPitchParts -> storeCommands (*command_line);
2533           break;
2534         }
2535       case Cm_a_flag:
2536         {
2537           if (check_float(linetoken3))
2538             token3 >> token_value;
2539           else
2540             uiuc_warnings_errors(1, *command_line);
2541
2542           Cm_a = token_value;
2543           Cm_a_clean = Cm_a;
2544           aeroPitchParts -> storeCommands (*command_line);
2545           break;
2546         }
2547       case Cm_a2_flag:
2548         {
2549           if (check_float(linetoken3))
2550             token3 >> token_value;
2551           else
2552             uiuc_warnings_errors(1, *command_line);
2553
2554           Cm_a2 = token_value;
2555           Cm_a2_clean = Cm_a2;
2556           aeroPitchParts -> storeCommands (*command_line);
2557           break;
2558         }
2559       case Cm_adot_flag:
2560         {
2561           if (check_float(linetoken3))
2562             token3 >> token_value;
2563           else
2564             uiuc_warnings_errors(1, *command_line);
2565
2566           Cm_adot = token_value;
2567           Cm_adot_clean = Cm_adot;
2568           aeroPitchParts -> storeCommands (*command_line);
2569           break;
2570         }
2571       case Cm_q_flag:
2572         {
2573           if (check_float(linetoken3))
2574             token3 >> token_value;
2575           else
2576             uiuc_warnings_errors(1, *command_line);
2577
2578           Cm_q = token_value;
2579           Cm_q_clean = Cm_q;
2580           aeroPitchParts -> storeCommands (*command_line);
2581           break;
2582         }
2583       case Cm_ih_flag:
2584         {
2585           if (check_float(linetoken3))
2586             token3 >> token_value;
2587           else
2588             uiuc_warnings_errors(1, *command_line);
2589
2590           Cm_ih = token_value;
2591           aeroPitchParts -> storeCommands (*command_line);
2592           break;
2593         }
2594       case Cm_de_flag:
2595         {
2596           if (check_float(linetoken3))
2597             token3 >> token_value;
2598           else
2599             uiuc_warnings_errors(1, *command_line);
2600
2601           Cm_de = token_value;
2602           Cm_de_clean = Cm_de;
2603           aeroPitchParts -> storeCommands (*command_line);
2604           break;
2605         }
2606       case Cm_b2_flag:
2607         {
2608           if (check_float(linetoken3))
2609             token3 >> token_value;
2610           else
2611             uiuc_warnings_errors(1, *command_line);
2612
2613           Cm_b2 = token_value;
2614           Cm_b2_clean = Cm_b2;
2615           aeroPitchParts -> storeCommands (*command_line);
2616           break;
2617         }
2618       case Cm_r_flag:
2619         {
2620           if (check_float(linetoken3))
2621             token3 >> token_value;
2622           else
2623             uiuc_warnings_errors(1, *command_line);
2624
2625           Cm_r = token_value;
2626           Cm_r_clean = Cm_r;
2627           aeroPitchParts -> storeCommands (*command_line);
2628           break;
2629         }
2630       case Cm_df_flag:
2631         {
2632           if (check_float(linetoken3))
2633             token3 >> token_value;
2634           else
2635             uiuc_warnings_errors(1, *command_line);
2636
2637           Cm_df = token_value;
2638           Cm_df_clean = Cm_df;
2639           aeroPitchParts -> storeCommands (*command_line);
2640           break;
2641         }
2642       case Cmfa_flag:
2643         {
2644           Cmfa = aircraft_directory + linetoken3;
2645           token4 >> token_value_convert1;
2646           token5 >> token_value_convert2;
2647           convert_y = uiuc_convert(token_value_convert1);
2648           convert_x = uiuc_convert(token_value_convert2);
2649           /* call 1D File Reader with file name (Cmfa) and conversion
2650              factors; function returns array of alphas (aArray) and
2651              corresponding Cm values (CmArray) and max number of
2652              terms in arrays (nAlpha) */
2653           uiuc_1DdataFileReader(Cmfa,
2654                                 Cmfa_aArray,
2655                                 Cmfa_CmArray,
2656                                 Cmfa_nAlpha);
2657           aeroPitchParts -> storeCommands (*command_line);
2658           break;
2659         }
2660       case Cmfade_flag:
2661         {
2662           Cmfade = aircraft_directory + linetoken3;
2663           token4 >> token_value_convert1;
2664           token5 >> token_value_convert2;
2665           token6 >> token_value_convert3;
2666           convert_z = uiuc_convert(token_value_convert1);
2667           convert_x = uiuc_convert(token_value_convert2);
2668           convert_y = uiuc_convert(token_value_convert3);
2669           /* call 2D File Reader with file name (Cmfade) and
2670              conversion factors; function returns array of
2671              elevator deflections (deArray) and corresponding
2672              alpha (aArray) and delta Cm (CmArray) values and
2673              max number of terms in alpha arrays (nAlphaArray)
2674              and deflection array (nde) */
2675           uiuc_2DdataFileReader(Cmfade,
2676                                 Cmfade_aArray,
2677                                 Cmfade_deArray,
2678                                 Cmfade_CmArray,
2679                                 Cmfade_nAlphaArray,
2680                                 Cmfade_nde);
2681           aeroPitchParts -> storeCommands (*command_line);
2682           break;
2683         }
2684       case Cmfdf_flag:
2685         {
2686           Cmfdf = aircraft_directory + linetoken3;
2687           token4 >> token_value_convert1;
2688           token5 >> token_value_convert2;
2689           convert_y = uiuc_convert(token_value_convert1);
2690           convert_x = uiuc_convert(token_value_convert2);
2691           /* call 1D File Reader with file name (Cmfdf) and conversion
2692              factors; function returns array of dfs (dfArray) and
2693              corresponding Cm values (CmArray) and max number of
2694              terms in arrays (ndf) */
2695           uiuc_1DdataFileReader(Cmfdf,
2696                                 Cmfdf_dfArray,
2697                                 Cmfdf_CmArray,
2698                                 Cmfdf_ndf);
2699           aeroPitchParts -> storeCommands (*command_line);
2700           break;
2701         }
2702       case Cmfadf_flag:
2703         {
2704           Cmfadf = aircraft_directory + linetoken3;
2705           token4 >> token_value_convert1;
2706           token5 >> token_value_convert2;
2707           token6 >> token_value_convert3;
2708           convert_z = uiuc_convert(token_value_convert1);
2709           convert_x = uiuc_convert(token_value_convert2);
2710           convert_y = uiuc_convert(token_value_convert3);
2711           /* call 2D File Reader with file name (Cmfadf) and
2712              conversion factors; function returns array of
2713              flap deflections (dfArray) and corresponding
2714              alpha (aArray) and delta Cm (CmArray) values and
2715              max number of terms in alpha arrays (nAlphaArray)
2716              and deflection array (ndf) */
2717           uiuc_2DdataFileReader(Cmfadf,
2718                                 Cmfadf_aArray,
2719                                 Cmfadf_dfArray,
2720                                 Cmfadf_CmArray,
2721                                 Cmfadf_nAlphaArray,
2722                                 Cmfadf_ndf);
2723           aeroPitchParts -> storeCommands (*command_line);
2724           break;
2725         }
2726       case Cmfabetaf_flag:
2727         {
2728           int Cmfabetaf_index, i;
2729           string Cmfabetaf_file;
2730           double flap_value;
2731           Cmfabetaf_file = aircraft_directory + linetoken3;
2732           token4 >> Cmfabetaf_index;
2733           if (Cmfabetaf_index < 0 || Cmfabetaf_index >= 30)
2734             uiuc_warnings_errors(1, *command_line);
2735           if (Cmfabetaf_index > Cmfabetaf_nf)
2736             Cmfabetaf_nf = Cmfabetaf_index;
2737           token5 >> flap_value;
2738           Cmfabetaf_fArray[Cmfabetaf_index] = flap_value;
2739           token6 >> token_value_convert1;
2740           token7 >> token_value_convert2;
2741           token8 >> token_value_convert3;
2742           token9 >> Cmfabetaf_nice;
2743           convert_z = uiuc_convert(token_value_convert1);
2744           convert_x = uiuc_convert(token_value_convert2);
2745           convert_y = uiuc_convert(token_value_convert3);
2746           /* call 2D File Reader with file name (Cmfabetaf_file) and
2747              conversion factors; function returns array of
2748              elevator deflections (deArray) and corresponding
2749              alpha (aArray) and delta CZ (CZArray) values and
2750              max number of terms in alpha arrays (nAlphaArray)
2751              and delfection array (nde) */
2752           uiuc_2DdataFileReader(Cmfabetaf_file,
2753                                 datafile_xArray,
2754                                 datafile_yArray,
2755                                 datafile_zArray,
2756                                 datafile_nxArray,
2757                                 datafile_ny);
2758           d_2_to_3(datafile_xArray, Cmfabetaf_aArray, Cmfabetaf_index);
2759           d_1_to_2(datafile_yArray, Cmfabetaf_betaArray, Cmfabetaf_index);
2760           d_2_to_3(datafile_zArray, Cmfabetaf_CmArray, Cmfabetaf_index);
2761           i_1_to_2(datafile_nxArray, Cmfabetaf_nAlphaArray, Cmfabetaf_index);
2762           Cmfabetaf_nbeta[Cmfabetaf_index] = datafile_ny;
2763           if (Cmfabetaf_first==true)
2764             {
2765               if (Cmfabetaf_nice == 1)
2766                 {
2767                   Cmfabetaf_na_nice = datafile_nxArray[1];
2768                   Cmfabetaf_nb_nice = datafile_ny;
2769                   d_1_to_1(datafile_yArray, Cmfabetaf_bArray_nice);
2770                   for (i=1; i<=Cmfabetaf_na_nice; i++)
2771                     Cmfabetaf_aArray_nice[i] = datafile_xArray[1][i];
2772                 }
2773               aeroPitchParts -> storeCommands (*command_line);
2774               Cmfabetaf_first=false;
2775             }
2776           break;
2777         }
2778       case Cmfadef_flag:
2779         {
2780           int Cmfadef_index, i;
2781           string Cmfadef_file;
2782           double flap_value;
2783           Cmfadef_file = aircraft_directory + linetoken3;
2784           token4 >> Cmfadef_index;
2785           if (Cmfadef_index < 0 || Cmfadef_index >= 30)
2786             uiuc_warnings_errors(1, *command_line);
2787           if (Cmfadef_index > Cmfadef_nf)
2788             Cmfadef_nf = Cmfadef_index;
2789           token5 >> flap_value;
2790           Cmfadef_fArray[Cmfadef_index] = flap_value;
2791           token6 >> token_value_convert1;
2792           token7 >> token_value_convert2;
2793           token8 >> token_value_convert3;
2794           token9 >> Cmfadef_nice;
2795           convert_z = uiuc_convert(token_value_convert1);
2796           convert_x = uiuc_convert(token_value_convert2);
2797           convert_y = uiuc_convert(token_value_convert3);
2798           /* call 2D File Reader with file name (Cmfadef_file) and
2799              conversion factors; function returns array of
2800              elevator deflections (deArray) and corresponding
2801              alpha (aArray) and delta CZ (CZArray) values and
2802              max number of terms in alpha arrays (nAlphaArray)
2803              and delfection array (nde) */
2804           uiuc_2DdataFileReader(Cmfadef_file,
2805                                 datafile_xArray,
2806                                 datafile_yArray,
2807                                 datafile_zArray,
2808                                 datafile_nxArray,
2809                                 datafile_ny);
2810           d_2_to_3(datafile_xArray, Cmfadef_aArray, Cmfadef_index);
2811           d_1_to_2(datafile_yArray, Cmfadef_deArray, Cmfadef_index);
2812           d_2_to_3(datafile_zArray, Cmfadef_CmArray, Cmfadef_index);
2813           i_1_to_2(datafile_nxArray, Cmfadef_nAlphaArray, Cmfadef_index);
2814           Cmfadef_nde[Cmfadef_index] = datafile_ny;
2815           if (Cmfadef_first==true)
2816             {
2817               if (Cmfadef_nice == 1)
2818                 {
2819                   Cmfadef_na_nice = datafile_nxArray[1];
2820                   Cmfadef_nde_nice = datafile_ny;
2821                   d_1_to_1(datafile_yArray, Cmfadef_deArray_nice);
2822                   for (i=1; i<=Cmfadef_na_nice; i++)
2823                     Cmfadef_aArray_nice[i] = datafile_xArray[1][i];
2824                 }
2825               aeroPitchParts -> storeCommands (*command_line);
2826               Cmfadef_first=false;
2827             }
2828           break;
2829         }
2830       case Cmfaqf_flag:
2831         {
2832           int Cmfaqf_index, i;
2833           string Cmfaqf_file;
2834           double flap_value;
2835           Cmfaqf_file = aircraft_directory + linetoken3;
2836           token4 >> Cmfaqf_index;
2837           if (Cmfaqf_index < 0 || Cmfaqf_index >= 30)
2838             uiuc_warnings_errors(1, *command_line);
2839           if (Cmfaqf_index > Cmfaqf_nf)
2840             Cmfaqf_nf = Cmfaqf_index;
2841           token5 >> flap_value;
2842           Cmfaqf_fArray[Cmfaqf_index] = flap_value;
2843           token6 >> token_value_convert1;
2844           token7 >> token_value_convert2;
2845           token8 >> token_value_convert3;
2846           token9 >> Cmfaqf_nice;
2847           convert_z = uiuc_convert(token_value_convert1);
2848           convert_x = uiuc_convert(token_value_convert2);
2849           convert_y = uiuc_convert(token_value_convert3);
2850           /* call 2D File Reader with file name (Cmfaqf_file) and
2851              conversion factors; function returns array of
2852              elevator deflections (deArray) and corresponding
2853              alpha (aArray) and delta CZ (CZArray) values and
2854              max number of terms in alpha arrays (nAlphaArray)
2855              and delfection array (nde) */
2856           uiuc_2DdataFileReader(Cmfaqf_file,
2857                                 datafile_xArray,
2858                                 datafile_yArray,
2859                                 datafile_zArray,
2860                                 datafile_nxArray,
2861                                 datafile_ny);
2862           d_2_to_3(datafile_xArray, Cmfaqf_aArray, Cmfaqf_index);
2863           d_1_to_2(datafile_yArray, Cmfaqf_qArray, Cmfaqf_index);
2864           d_2_to_3(datafile_zArray, Cmfaqf_CmArray, Cmfaqf_index);
2865           i_1_to_2(datafile_nxArray, Cmfaqf_nAlphaArray, Cmfaqf_index);
2866           Cmfaqf_nq[Cmfaqf_index] = datafile_ny;
2867           if (Cmfaqf_first==true)
2868             {
2869               if (Cmfaqf_nice == 1)
2870                 {
2871                   Cmfaqf_na_nice = datafile_nxArray[1];
2872                   Cmfaqf_nq_nice = datafile_ny;
2873                   d_1_to_1(datafile_yArray, Cmfaqf_qArray_nice);
2874                   for (i=1; i<=Cmfaqf_na_nice; i++)
2875                     Cmfaqf_aArray_nice[i] = datafile_xArray[1][i];
2876                 }
2877               aeroPitchParts -> storeCommands (*command_line);
2878               Cmfaqf_first=false;
2879             }
2880           break;
2881         }
2882       default:
2883         {
2884           if (dont_ignore)
2885             uiuc_warnings_errors(2, *command_line);
2886           break;
2887         }
2888       };
2889 }
2890
2891
2892 void parse_CY( const string& linetoken2, const string& linetoken3,
2893                const string& linetoken4, const string& linetoken5,
2894                const string& linetoken6, const string& linetoken7,
2895                const string& linetoken8, const string& linetoken9,
2896                const string& aircraft_directory,
2897                bool &CYfabetaf_first, bool &CYfadaf_first,
2898                bool &CYfadrf_first, bool &CYfapf_first,
2899                bool &CYfarf_first, LIST command_line ) {
2900     double token_value;
2901     int token_value_convert1, token_value_convert2, token_value_convert3;
2902     double datafile_xArray[100][100], datafile_yArray[100];
2903     double datafile_zArray[100][100];
2904     int datafile_nxArray[100], datafile_ny;
2905     istrstream token3(linetoken3.c_str());
2906     istrstream token4(linetoken4.c_str());
2907     istrstream token5(linetoken5.c_str());
2908     istrstream token6(linetoken6.c_str());
2909     istrstream token7(linetoken7.c_str());
2910     istrstream token8(linetoken8.c_str());
2911     istrstream token9(linetoken9.c_str());
2912
2913     switch(CY_map[linetoken2])
2914       {
2915       case CYo_flag:
2916         {
2917           if (check_float(linetoken3))
2918             token3 >> token_value;
2919           else
2920             uiuc_warnings_errors(1, *command_line);
2921
2922           CYo = token_value;
2923           CYo_clean = CYo;
2924           aeroSideforceParts -> storeCommands (*command_line);
2925           break;
2926         }
2927       case CY_beta_flag:
2928         {
2929           if (check_float(linetoken3))
2930             token3 >> token_value;
2931           else
2932             uiuc_warnings_errors(1, *command_line);
2933
2934           CY_beta = token_value;
2935           CY_beta_clean = CY_beta;
2936           aeroSideforceParts -> storeCommands (*command_line);
2937           break;
2938         }
2939       case CY_p_flag:
2940         {
2941           if (check_float(linetoken3))
2942             token3 >> token_value;
2943           else
2944             uiuc_warnings_errors(1, *command_line);
2945
2946           CY_p = token_value;
2947           CY_p_clean = CY_p;
2948           aeroSideforceParts -> storeCommands (*command_line);
2949           break;
2950         }
2951       case CY_r_flag:
2952         {
2953           if (check_float(linetoken3))
2954             token3 >> token_value;
2955           else
2956             uiuc_warnings_errors(1, *command_line);
2957
2958           CY_r = token_value;
2959           CY_r_clean = CY_r;
2960           aeroSideforceParts -> storeCommands (*command_line);
2961           break;
2962         }
2963       case CY_da_flag:
2964         {
2965           if (check_float(linetoken3))
2966             token3 >> token_value;
2967           else
2968             uiuc_warnings_errors(1, *command_line);
2969
2970           CY_da = token_value;
2971           CY_da_clean = CY_da;
2972           aeroSideforceParts -> storeCommands (*command_line);
2973           break;
2974         }
2975       case CY_dr_flag:
2976         {
2977           if (check_float(linetoken3))
2978             token3 >> token_value;
2979           else
2980             uiuc_warnings_errors(2, *command_line);
2981
2982           CY_dr = token_value;
2983           CY_dr_clean = CY_dr;
2984           aeroSideforceParts -> storeCommands (*command_line);
2985           break;
2986         }
2987       case CY_dra_flag:
2988         {
2989           if (check_float(linetoken3))
2990             token3 >> token_value;
2991           else
2992             uiuc_warnings_errors(2, *command_line);
2993
2994           CY_dra = token_value;
2995           CY_dra_clean = CY_dra;
2996           aeroSideforceParts -> storeCommands (*command_line);
2997           break;
2998         }
2999       case CY_bdot_flag:
3000         {
3001           if (check_float(linetoken3))
3002             token3 >> token_value;
3003           else
3004             uiuc_warnings_errors(2, *command_line);
3005
3006           CY_bdot = token_value;
3007           CY_bdot_clean = CY_bdot;
3008           aeroSideforceParts -> storeCommands (*command_line);
3009           break;
3010         }
3011       case CYfada_flag:
3012         {
3013           CYfada = aircraft_directory + linetoken3;
3014           token4 >> token_value_convert1;
3015           token5 >> token_value_convert2;
3016           token6 >> token_value_convert3;
3017           convert_z = uiuc_convert(token_value_convert1);
3018           convert_x = uiuc_convert(token_value_convert2);
3019           convert_y = uiuc_convert(token_value_convert3);
3020           /* call 2D File Reader with file name (CYfada) and
3021              conversion factors; function returns array of
3022              aileron deflections (daArray) and corresponding
3023              alpha (aArray) and delta CY (CYArray) values and
3024              max number of terms in alpha arrays (nAlphaArray)
3025              and deflection array (nda) */
3026           uiuc_2DdataFileReader(CYfada,
3027                                 CYfada_aArray,
3028                                 CYfada_daArray,
3029                                 CYfada_CYArray,
3030                                 CYfada_nAlphaArray,
3031                                 CYfada_nda);
3032           aeroSideforceParts -> storeCommands (*command_line);
3033           break;
3034         }
3035       case CYfbetadr_flag:
3036         {
3037           CYfbetadr = aircraft_directory + linetoken3;
3038           token4 >> token_value_convert1;
3039           token5 >> token_value_convert2;
3040           token6 >> token_value_convert3;
3041           convert_z = uiuc_convert(token_value_convert1);
3042           convert_x = uiuc_convert(token_value_convert2);
3043           convert_y = uiuc_convert(token_value_convert3);
3044           /* call 2D File Reader with file name (CYfbetadr) and
3045              conversion factors; function returns array of
3046              rudder deflections (drArray) and corresponding
3047              beta (betaArray) and delta CY (CYArray) values and
3048              max number of terms in beta arrays (nBetaArray)
3049              and deflection array (ndr) */
3050           uiuc_2DdataFileReader(CYfbetadr,
3051                                 CYfbetadr_betaArray,
3052                                 CYfbetadr_drArray,
3053                                 CYfbetadr_CYArray,
3054                                 CYfbetadr_nBetaArray,
3055                                 CYfbetadr_ndr);
3056           aeroSideforceParts -> storeCommands (*command_line);
3057           break;
3058         }
3059       case CYfabetaf_flag:
3060         {
3061           int CYfabetaf_index, i;
3062           string CYfabetaf_file;
3063           double flap_value;
3064           CYfabetaf_file = aircraft_directory + linetoken3;
3065           token4 >> CYfabetaf_index;
3066           if (CYfabetaf_index < 0 || CYfabetaf_index >= 30)
3067             uiuc_warnings_errors(1, *command_line);
3068           if (CYfabetaf_index > CYfabetaf_nf)
3069             CYfabetaf_nf = CYfabetaf_index;
3070           token5 >> flap_value;
3071           CYfabetaf_fArray[CYfabetaf_index] = flap_value;
3072           token6 >> token_value_convert1;
3073           token7 >> token_value_convert2;
3074           token8 >> token_value_convert3;
3075           token9 >> CYfabetaf_nice;
3076           convert_z = uiuc_convert(token_value_convert1);
3077           convert_x = uiuc_convert(token_value_convert2);
3078           convert_y = uiuc_convert(token_value_convert3);
3079           /* call 2D File Reader with file name (CYfabetaf_file) and
3080              conversion factors; function returns array of
3081              elevator deflections (deArray) and corresponding
3082              alpha (aArray) and delta CZ (CZArray) values and
3083              max number of terms in alpha arrays (nAlphaArray)
3084              and delfection array (nde) */
3085           uiuc_2DdataFileReader(CYfabetaf_file,
3086                                 datafile_xArray,
3087                                 datafile_yArray,
3088                                 datafile_zArray,
3089                                 datafile_nxArray,
3090                                 datafile_ny);
3091           d_2_to_3(datafile_xArray, CYfabetaf_aArray, CYfabetaf_index);
3092           d_1_to_2(datafile_yArray, CYfabetaf_betaArray, CYfabetaf_index);
3093           d_2_to_3(datafile_zArray, CYfabetaf_CYArray, CYfabetaf_index);
3094           i_1_to_2(datafile_nxArray, CYfabetaf_nAlphaArray, CYfabetaf_index);
3095           CYfabetaf_nbeta[CYfabetaf_index] = datafile_ny;
3096           if (CYfabetaf_first==true)
3097             {
3098               if (CYfabetaf_nice == 1)
3099                 {
3100                   CYfabetaf_na_nice = datafile_nxArray[1];
3101                   CYfabetaf_nb_nice = datafile_ny;
3102                   d_1_to_1(datafile_yArray, CYfabetaf_bArray_nice);
3103                   for (i=1; i<=CYfabetaf_na_nice; i++)
3104                     CYfabetaf_aArray_nice[i] = datafile_xArray[1][i];
3105                 }
3106               aeroSideforceParts -> storeCommands (*command_line);
3107               CYfabetaf_first=false;
3108             }
3109           break;
3110         }
3111       case CYfadaf_flag:
3112         {
3113           int CYfadaf_index, i;
3114           string CYfadaf_file;
3115           double flap_value;
3116           CYfadaf_file = aircraft_directory + linetoken3;
3117           token4 >> CYfadaf_index;
3118           if (CYfadaf_index < 0 || CYfadaf_index >= 30)
3119             uiuc_warnings_errors(1, *command_line);
3120           if (CYfadaf_index > CYfadaf_nf)
3121             CYfadaf_nf = CYfadaf_index;
3122           token5 >> flap_value;
3123           CYfadaf_fArray[CYfadaf_index] = flap_value;
3124           token6 >> token_value_convert1;
3125           token7 >> token_value_convert2;
3126           token8 >> token_value_convert3;
3127           token9 >> CYfadaf_nice;
3128           convert_z = uiuc_convert(token_value_convert1);
3129           convert_x = uiuc_convert(token_value_convert2);
3130           convert_y = uiuc_convert(token_value_convert3);
3131           /* call 2D File Reader with file name (CYfadaf_file) and
3132              conversion factors; function returns array of
3133              elevator deflections (deArray) and corresponding
3134              alpha (aArray) and delta CZ (CZArray) values and
3135              max number of terms in alpha arrays (nAlphaArray)
3136              and delfection array (nde) */
3137           uiuc_2DdataFileReader(CYfadaf_file,
3138                                 datafile_xArray,
3139                                 datafile_yArray,
3140                                 datafile_zArray,
3141                                 datafile_nxArray,
3142                                 datafile_ny);
3143           d_2_to_3(datafile_xArray, CYfadaf_aArray, CYfadaf_index);
3144           d_1_to_2(datafile_yArray, CYfadaf_daArray, CYfadaf_index);
3145           d_2_to_3(datafile_zArray, CYfadaf_CYArray, CYfadaf_index);
3146           i_1_to_2(datafile_nxArray, CYfadaf_nAlphaArray, CYfadaf_index);
3147           CYfadaf_nda[CYfadaf_index] = datafile_ny;
3148           if (CYfadaf_first==true)
3149             {
3150               if (CYfadaf_nice == 1)
3151                 {
3152                   CYfadaf_na_nice = datafile_nxArray[1];
3153                   CYfadaf_nda_nice = datafile_ny;
3154                   d_1_to_1(datafile_yArray, CYfadaf_daArray_nice);
3155                   for (i=1; i<=CYfadaf_na_nice; i++)
3156                     CYfadaf_aArray_nice[i] = datafile_xArray[1][i];
3157                 }
3158               aeroSideforceParts -> storeCommands (*command_line);
3159               CYfadaf_first=false;
3160             }
3161           break;
3162         }
3163       case CYfadrf_flag:
3164         {
3165           int CYfadrf_index, i;
3166           string CYfadrf_file;
3167           double flap_value;
3168           CYfadrf_file = aircraft_directory + linetoken3;
3169           token4 >> CYfadrf_index;
3170           if (CYfadrf_index < 0 || CYfadrf_index >= 30)
3171             uiuc_warnings_errors(1, *command_line);
3172           if (CYfadrf_index > CYfadrf_nf)
3173             CYfadrf_nf = CYfadrf_index;
3174           token5 >> flap_value;
3175           CYfadrf_fArray[CYfadrf_index] = flap_value;
3176           token6 >> token_value_convert1;
3177           token7 >> token_value_convert2;
3178           token8 >> token_value_convert3;
3179           token9 >> CYfadrf_nice;
3180           convert_z = uiuc_convert(token_value_convert1);
3181           convert_x = uiuc_convert(token_value_convert2);
3182           convert_y = uiuc_convert(token_value_convert3);
3183           /* call 2D File Reader with file name (CYfadrf_file) and
3184              conversion factors; function returns array of
3185              elevator deflections (deArray) and corresponding
3186              alpha (aArray) and delta CZ (CZArray) values and
3187              max number of terms in alpha arrays (nAlphaArray)
3188              and delfection array (nde) */
3189           uiuc_2DdataFileReader(CYfadrf_file,
3190                                 datafile_xArray,
3191                                 datafile_yArray,
3192                                 datafile_zArray,
3193                                 datafile_nxArray,
3194                                 datafile_ny);
3195           d_2_to_3(datafile_xArray, CYfadrf_aArray, CYfadrf_index);
3196           d_1_to_2(datafile_yArray, CYfadrf_drArray, CYfadrf_index);
3197           d_2_to_3(datafile_zArray, CYfadrf_CYArray, CYfadrf_index);
3198           i_1_to_2(datafile_nxArray, CYfadrf_nAlphaArray, CYfadrf_index);
3199           CYfadrf_ndr[CYfadrf_index] = datafile_ny;
3200           if (CYfadrf_first==true)
3201             {
3202               if (CYfadrf_nice == 1)
3203                 {
3204                   CYfadrf_na_nice = datafile_nxArray[1];
3205                   CYfadrf_ndr_nice = datafile_ny;
3206                   d_1_to_1(datafile_yArray, CYfadrf_drArray_nice);
3207                   for (i=1; i<=CYfadrf_na_nice; i++)
3208                     CYfadrf_aArray_nice[i] = datafile_xArray[1][i];
3209                 }
3210               aeroSideforceParts -> storeCommands (*command_line);
3211               CYfadrf_first=false;
3212             }
3213           break;
3214         }
3215       case CYfapf_flag:
3216         {
3217           int CYfapf_index, i;
3218           string CYfapf_file;
3219           double flap_value;
3220           CYfapf_file = aircraft_directory + linetoken3;
3221           token4 >> CYfapf_index;
3222           if (CYfapf_index < 0 || CYfapf_index >= 30)
3223             uiuc_warnings_errors(1, *command_line);
3224           if (CYfapf_index > CYfapf_nf)
3225             CYfapf_nf = CYfapf_index;
3226           token5 >> flap_value;
3227           CYfapf_fArray[CYfapf_index] = flap_value;
3228           token6 >> token_value_convert1;
3229           token7 >> token_value_convert2;
3230           token8 >> token_value_convert3;
3231           token9 >> CYfapf_nice;
3232           convert_z = uiuc_convert(token_value_convert1);
3233           convert_x = uiuc_convert(token_value_convert2);
3234           convert_y = uiuc_convert(token_value_convert3);
3235           /* call 2D File Reader with file name (CYfapf_file) and
3236              conversion factors; function returns array of
3237              elevator deflections (deArray) and corresponding
3238              alpha (aArray) and delta CZ (CZArray) values and
3239              max number of terms in alpha arrays (nAlphaArray)
3240              and delfection array (nde) */
3241           uiuc_2DdataFileReader(CYfapf_file,
3242                                 datafile_xArray,
3243                                 datafile_yArray,
3244                                 datafile_zArray,
3245                                 datafile_nxArray,
3246                                 datafile_ny);
3247           d_2_to_3(datafile_xArray, CYfapf_aArray, CYfapf_index);
3248           d_1_to_2(datafile_yArray, CYfapf_pArray, CYfapf_index);
3249           d_2_to_3(datafile_zArray, CYfapf_CYArray, CYfapf_index);
3250           i_1_to_2(datafile_nxArray, CYfapf_nAlphaArray, CYfapf_index);
3251           CYfapf_np[CYfapf_index] = datafile_ny;
3252           if (CYfapf_first==true)
3253             {
3254               if (CYfapf_nice == 1)
3255                 {
3256                   CYfapf_na_nice = datafile_nxArray[1];
3257                   CYfapf_np_nice = datafile_ny;
3258                   d_1_to_1(datafile_yArray, CYfapf_pArray_nice);
3259                   for (i=1; i<=CYfapf_na_nice; i++)
3260                     CYfapf_aArray_nice[i] = datafile_xArray[1][i];
3261                 }
3262               aeroSideforceParts -> storeCommands (*command_line);
3263               CYfapf_first=false;
3264             }
3265           break;
3266         }
3267       case CYfarf_flag:
3268         {
3269           int CYfarf_index, i;
3270           string CYfarf_file;
3271           double flap_value;
3272           CYfarf_file = aircraft_directory + linetoken3;
3273           token4 >> CYfarf_index;
3274           if (CYfarf_index < 0 || CYfarf_index >= 30)
3275             uiuc_warnings_errors(1, *command_line);
3276           if (CYfarf_index > CYfarf_nf)
3277             CYfarf_nf = CYfarf_index;
3278           token5 >> flap_value;
3279           CYfarf_fArray[CYfarf_index] = flap_value;
3280           token6 >> token_value_convert1;
3281           token7 >> token_value_convert2;
3282           token8 >> token_value_convert3;
3283           token9 >> CYfarf_nice;
3284           convert_z = uiuc_convert(token_value_convert1);
3285           convert_x = uiuc_convert(token_value_convert2);
3286           convert_y = uiuc_convert(token_value_convert3);
3287           /* call 2D File Reader with file name (CYfarf_file) and
3288              conversion factors; function returns array of
3289              elevator deflections (deArray) and corresponding
3290              alpha (aArray) and delta CZ (CZArray) values and
3291              max number of terms in alpha arrays (nAlphaArray)
3292              and delfection array (nde) */
3293           uiuc_2DdataFileReader(CYfarf_file,
3294                                 datafile_xArray,
3295                                 datafile_yArray,
3296                                 datafile_zArray,
3297                                 datafile_nxArray,
3298                                 datafile_ny);
3299           d_2_to_3(datafile_xArray, CYfarf_aArray, CYfarf_index);
3300           d_1_to_2(datafile_yArray, CYfarf_rArray, CYfarf_index);
3301           d_2_to_3(datafile_zArray, CYfarf_CYArray, CYfarf_index);
3302           i_1_to_2(datafile_nxArray, CYfarf_nAlphaArray, CYfarf_index);
3303           CYfarf_nr[CYfarf_index] = datafile_ny;
3304           if (CYfarf_first==true)
3305             {
3306               if (CYfarf_nice == 1)
3307                 {
3308                   CYfarf_na_nice = datafile_nxArray[1];
3309                   CYfarf_nr_nice = datafile_ny;
3310                   d_1_to_1(datafile_yArray, CYfarf_rArray_nice);
3311                   for (i=1; i<=CYfarf_na_nice; i++)
3312                     CYfarf_aArray_nice[i] = datafile_xArray[1][i];
3313                 }
3314               aeroSideforceParts -> storeCommands (*command_line);
3315               CYfarf_first=false;
3316             }
3317           break;
3318         }
3319       default:
3320         {
3321           if (dont_ignore)
3322             uiuc_warnings_errors(2, *command_line);
3323           break;
3324         }
3325       };
3326 }
3327
3328 void parse_Cl( const string& linetoken2, const string& linetoken3,
3329                const string& linetoken4, const string& linetoken5,
3330                const string& linetoken6, const string& linetoken7,
3331                const string& linetoken8, const string& linetoken9,
3332                const string& aircraft_directory,
3333                bool &Clfabetaf_first, bool &Clfadaf_first,
3334                bool &Clfadrf_first, bool &Clfapf_first,
3335                bool &Clfarf_first, LIST command_line ) {
3336     double token_value;
3337     int token_value_convert1, token_value_convert2, token_value_convert3;
3338     double datafile_xArray[100][100], datafile_yArray[100];
3339     double datafile_zArray[100][100];
3340     int datafile_nxArray[100], datafile_ny;
3341     istrstream token3(linetoken3.c_str());
3342     istrstream token4(linetoken4.c_str());
3343     istrstream token5(linetoken5.c_str());
3344     istrstream token6(linetoken6.c_str());
3345     istrstream token7(linetoken7.c_str());
3346     istrstream token8(linetoken8.c_str());
3347     istrstream token9(linetoken9.c_str());
3348
3349     switch(Cl_map[linetoken2])
3350       {
3351       case Clo_flag:
3352         {
3353           if (check_float(linetoken3))
3354             token3 >> token_value;
3355           else
3356             uiuc_warnings_errors(1, *command_line);
3357
3358           Clo = token_value;
3359           Clo_clean = Clo;
3360           aeroRollParts -> storeCommands (*command_line);
3361           break;
3362         }
3363       case Cl_beta_flag:
3364         {
3365           if (check_float(linetoken3))
3366             token3 >> token_value;
3367           else
3368             uiuc_warnings_errors(1, *command_line);
3369
3370           Cl_beta = token_value;
3371           Cl_beta_clean = Cl_beta;
3372           aeroRollParts -> storeCommands (*command_line);
3373           break;
3374         }
3375       case Cl_p_flag:
3376         {
3377           if (check_float(linetoken3))
3378             token3 >> token_value;
3379           else
3380             uiuc_warnings_errors(1, *command_line);
3381
3382           Cl_p = token_value;
3383           Cl_p_clean = Cl_p;
3384           aeroRollParts -> storeCommands (*command_line);
3385           break;
3386         }
3387       case Cl_r_flag:
3388         {
3389           if (check_float(linetoken3))
3390             token3 >> token_value;
3391           else
3392             uiuc_warnings_errors(1, *command_line);
3393
3394           Cl_r = token_value;
3395           Cl_r_clean = Cl_r;
3396           aeroRollParts -> storeCommands (*command_line);
3397           break;
3398         }
3399       case Cl_da_flag:
3400         {
3401           if (check_float(linetoken3))
3402             token3 >> token_value;
3403           else
3404             uiuc_warnings_errors(1, *command_line);
3405
3406           Cl_da = token_value;
3407           Cl_da_clean = Cl_da;
3408           aeroRollParts -> storeCommands (*command_line);
3409           break;
3410         }
3411       case Cl_dr_flag:
3412         {
3413           if (check_float(linetoken3))
3414             token3 >> token_value;
3415           else
3416             uiuc_warnings_errors(1, *command_line);
3417
3418           Cl_dr = token_value;
3419           Cl_dr_clean = Cl_dr;
3420           aeroRollParts -> storeCommands (*command_line);
3421           break;
3422         }
3423       case Cl_daa_flag:
3424         {
3425           if (check_float(linetoken3))
3426             token3 >> token_value;
3427           else
3428             uiuc_warnings_errors(1, *command_line);
3429
3430           Cl_daa = token_value;
3431           Cl_daa_clean = Cl_daa;
3432           aeroRollParts -> storeCommands (*command_line);
3433           break;
3434         }
3435       case Clfada_flag:
3436         {
3437           Clfada = aircraft_directory + linetoken3;
3438           token4 >> token_value_convert1;
3439           token5 >> token_value_convert2;
3440           token6 >> token_value_convert3;
3441           convert_z = uiuc_convert(token_value_convert1);
3442           convert_x = uiuc_convert(token_value_convert2);
3443           convert_y = uiuc_convert(token_value_convert3);
3444           /* call 2D File Reader with file name (Clfada) and
3445              conversion factors; function returns array of
3446              aileron deflections (daArray) and corresponding
3447              alpha (aArray) and delta Cl (ClArray) values and
3448              max number of terms in alpha arrays (nAlphaArray)
3449              and deflection array (nda) */
3450           uiuc_2DdataFileReader(Clfada,
3451                                 Clfada_aArray,
3452                                 Clfada_daArray,
3453                                 Clfada_ClArray,
3454                                 Clfada_nAlphaArray,
3455                                 Clfada_nda);
3456           aeroRollParts -> storeCommands (*command_line);
3457           break;
3458         }
3459       case Clfbetadr_flag:
3460         {
3461           Clfbetadr = aircraft_directory + linetoken3;
3462           token4 >> token_value_convert1;
3463           token5 >> token_value_convert2;
3464           token6 >> token_value_convert3;
3465           convert_z = uiuc_convert(token_value_convert1);
3466           convert_x = uiuc_convert(token_value_convert2);
3467           convert_y = uiuc_convert(token_value_convert3);
3468           /* call 2D File Reader with file name (Clfbetadr) and
3469              conversion factors; function returns array of
3470              rudder deflections (drArray) and corresponding
3471              beta (betaArray) and delta Cl (ClArray) values and
3472              max number of terms in beta arrays (nBetaArray)
3473              and deflection array (ndr) */
3474           uiuc_2DdataFileReader(Clfbetadr,
3475                                 Clfbetadr_betaArray,
3476                                 Clfbetadr_drArray,
3477                                 Clfbetadr_ClArray,
3478                                 Clfbetadr_nBetaArray,
3479                                 Clfbetadr_ndr);
3480           aeroRollParts -> storeCommands (*command_line);
3481           break;
3482         }
3483       case Clfabetaf_flag:
3484         {
3485           int Clfabetaf_index, i;
3486           string Clfabetaf_file;
3487           double flap_value;
3488           Clfabetaf_file = aircraft_directory + linetoken3;
3489           token4 >> Clfabetaf_index;
3490           if (Clfabetaf_index < 0 || Clfabetaf_index >= 100)
3491             uiuc_warnings_errors(1, *command_line);
3492           if (Clfabetaf_index > Clfabetaf_nf)
3493             Clfabetaf_nf = Clfabetaf_index;
3494           token5 >> flap_value;
3495           Clfabetaf_fArray[Clfabetaf_index] = flap_value;
3496           token6 >> token_value_convert1;
3497           token7 >> token_value_convert2;
3498           token8 >> token_value_convert3;
3499           token9 >> Clfabetaf_nice;
3500           convert_z = uiuc_convert(token_value_convert1);
3501           convert_x = uiuc_convert(token_value_convert2);
3502           convert_y = uiuc_convert(token_value_convert3);
3503           /* call 2D File Reader with file name (Clfabetaf_file) and
3504              conversion factors; function returns array of
3505              elevator deflections (deArray) and corresponding
3506              alpha (aArray) and delta CZ (CZArray) values and
3507              max number of terms in alpha arrays (nAlphaArray)
3508              and delfection array (nde) */
3509           uiuc_2DdataFileReader(Clfabetaf_file,
3510                                 datafile_xArray,
3511                                 datafile_yArray,
3512                                 datafile_zArray,
3513                                 datafile_nxArray,
3514                                 datafile_ny);
3515           d_2_to_3(datafile_xArray, Clfabetaf_aArray, Clfabetaf_index);
3516           d_1_to_2(datafile_yArray, Clfabetaf_betaArray, Clfabetaf_index);
3517           d_2_to_3(datafile_zArray, Clfabetaf_ClArray, Clfabetaf_index);
3518           i_1_to_2(datafile_nxArray, Clfabetaf_nAlphaArray, Clfabetaf_index);
3519           Clfabetaf_nbeta[Clfabetaf_index] = datafile_ny;
3520           if (Clfabetaf_first==true)
3521             {
3522               if (Clfabetaf_nice == 1)
3523                 {
3524                   Clfabetaf_na_nice = datafile_nxArray[1];
3525                   Clfabetaf_nb_nice = datafile_ny;
3526                   d_1_to_1(datafile_yArray, Clfabetaf_bArray_nice);
3527                   for (i=1; i<=Clfabetaf_na_nice; i++)
3528                     Clfabetaf_aArray_nice[i] = datafile_xArray[1][i];
3529                 }
3530               aeroRollParts -> storeCommands (*command_line);
3531               Clfabetaf_first=false;
3532             }
3533           break;
3534         }
3535       case Clfadaf_flag:
3536         {
3537           int Clfadaf_index, i;
3538           string Clfadaf_file;
3539           double flap_value;
3540           Clfadaf_file = aircraft_directory + linetoken3;
3541           token4 >> Clfadaf_index;
3542           if (Clfadaf_index < 0 || Clfadaf_index >= 100)
3543             uiuc_warnings_errors(1, *command_line);
3544           if (Clfadaf_index > Clfadaf_nf)
3545             Clfadaf_nf = Clfadaf_index;
3546           token5 >> flap_value;
3547           Clfadaf_fArray[Clfadaf_index] = flap_value;
3548           token6 >> token_value_convert1;
3549           token7 >> token_value_convert2;
3550           token8 >> token_value_convert3;
3551           token9 >> Clfadaf_nice;
3552           convert_z = uiuc_convert(token_value_convert1);
3553           convert_x = uiuc_convert(token_value_convert2);
3554           convert_y = uiuc_convert(token_value_convert3);
3555           /* call 2D File Reader with file name (Clfadaf_file) and
3556              conversion factors; function returns array of
3557              elevator deflections (deArray) and corresponding
3558              alpha (aArray) and delta CZ (CZArray) values and
3559              max number of terms in alpha arrays (nAlphaArray)
3560              and delfection array (nde) */
3561           uiuc_2DdataFileReader(Clfadaf_file,
3562                                 datafile_xArray,
3563                                 datafile_yArray,
3564                                 datafile_zArray,
3565                                 datafile_nxArray,
3566                                 datafile_ny);
3567           d_2_to_3(datafile_xArray, Clfadaf_aArray, Clfadaf_index);
3568           d_1_to_2(datafile_yArray, Clfadaf_daArray, Clfadaf_index);
3569           d_2_to_3(datafile_zArray, Clfadaf_ClArray, Clfadaf_index);
3570           i_1_to_2(datafile_nxArray, Clfadaf_nAlphaArray, Clfadaf_index);
3571           Clfadaf_nda[Clfadaf_index] = datafile_ny;
3572           if (Clfadaf_first==true)
3573             {
3574               if (Clfadaf_nice == 1)
3575                 {
3576                   Clfadaf_na_nice = datafile_nxArray[1];
3577                   Clfadaf_nda_nice = datafile_ny;
3578                   d_1_to_1(datafile_yArray, Clfadaf_daArray_nice);
3579                   for (i=1; i<=Clfadaf_na_nice; i++)
3580                     Clfadaf_aArray_nice[i] = datafile_xArray[1][i];
3581                 }
3582               aeroRollParts -> storeCommands (*command_line);
3583               Clfadaf_first=false;
3584             }
3585           break;
3586         }
3587       case Clfadrf_flag:
3588         {
3589           int Clfadrf_index, i;
3590           string Clfadrf_file;
3591           double flap_value;
3592           Clfadrf_file = aircraft_directory + linetoken3;
3593           token4 >> Clfadrf_index;
3594           if (Clfadrf_index < 0 || Clfadrf_index >= 100)
3595             uiuc_warnings_errors(1, *command_line);
3596           if (Clfadrf_index > Clfadrf_nf)
3597             Clfadrf_nf = Clfadrf_index;
3598           token5 >> flap_value;
3599           Clfadrf_fArray[Clfadrf_index] = flap_value;
3600           token6 >> token_value_convert1;
3601           token7 >> token_value_convert2;
3602           token8 >> token_value_convert3;
3603           token9 >> Clfadrf_nice;
3604           convert_z = uiuc_convert(token_value_convert1);
3605           convert_x = uiuc_convert(token_value_convert2);
3606           convert_y = uiuc_convert(token_value_convert3);
3607           /* call 2D File Reader with file name (Clfadrf_file) and
3608              conversion factors; function returns array of
3609              elevator deflections (deArray) and corresponding
3610              alpha (aArray) and delta CZ (CZArray) values and
3611              max number of terms in alpha arrays (nAlphaArray)
3612              and delfection array (nde) */
3613           uiuc_2DdataFileReader(Clfadrf_file,
3614                                 datafile_xArray,
3615                                 datafile_yArray,
3616                                 datafile_zArray,
3617                                 datafile_nxArray,
3618                                 datafile_ny);
3619           d_2_to_3(datafile_xArray, Clfadrf_aArray, Clfadrf_index);
3620           d_1_to_2(datafile_yArray, Clfadrf_drArray, Clfadrf_index);
3621           d_2_to_3(datafile_zArray, Clfadrf_ClArray, Clfadrf_index);
3622           i_1_to_2(datafile_nxArray, Clfadrf_nAlphaArray, Clfadrf_index);
3623           Clfadrf_ndr[Clfadrf_index] = datafile_ny;
3624           if (Clfadrf_first==true)
3625             {
3626               if (Clfadrf_nice == 1)
3627                 {
3628                   Clfadrf_na_nice = datafile_nxArray[1];
3629                   Clfadrf_ndr_nice = datafile_ny;
3630                   d_1_to_1(datafile_yArray, Clfadrf_drArray_nice);
3631                   for (i=1; i<=Clfadrf_na_nice; i++)
3632                     Clfadrf_aArray_nice[i] = datafile_xArray[1][i];
3633                 }
3634               aeroRollParts -> storeCommands (*command_line);
3635               Clfadrf_first=false;
3636             }
3637           break;
3638         }
3639       case Clfapf_flag:
3640         {
3641           int Clfapf_index, i;
3642           string Clfapf_file;
3643           double flap_value;
3644           Clfapf_file = aircraft_directory + linetoken3;
3645           token4 >> Clfapf_index;
3646           if (Clfapf_index < 0 || Clfapf_index >= 100)
3647             uiuc_warnings_errors(1, *command_line);
3648           if (Clfapf_index > Clfapf_nf)
3649             Clfapf_nf = Clfapf_index;
3650           token5 >> flap_value;
3651           Clfapf_fArray[Clfapf_index] = flap_value;
3652           token6 >> token_value_convert1;
3653           token7 >> token_value_convert2;
3654           token8 >> token_value_convert3;
3655           token9 >> Clfapf_nice;
3656           convert_z = uiuc_convert(token_value_convert1);
3657           convert_x = uiuc_convert(token_value_convert2);
3658           convert_y = uiuc_convert(token_value_convert3);
3659           /* call 2D File Reader with file name (Clfapf_file) and
3660              conversion factors; function returns array of
3661              elevator deflections (deArray) and corresponding
3662              alpha (aArray) and delta CZ (CZArray) values and
3663              max number of terms in alpha arrays (nAlphaArray)
3664              and delfection array (nde) */
3665           uiuc_2DdataFileReader(Clfapf_file,
3666                                 datafile_xArray,
3667                                 datafile_yArray,
3668                                 datafile_zArray,
3669                                 datafile_nxArray,
3670                                 datafile_ny);
3671           d_2_to_3(datafile_xArray, Clfapf_aArray, Clfapf_index);
3672           d_1_to_2(datafile_yArray, Clfapf_pArray, Clfapf_index);
3673           d_2_to_3(datafile_zArray, Clfapf_ClArray, Clfapf_index);
3674           i_1_to_2(datafile_nxArray, Clfapf_nAlphaArray, Clfapf_index);
3675           Clfapf_np[Clfapf_index] = datafile_ny;
3676           if (Clfapf_first==true)
3677             {
3678               if (Clfapf_nice == 1)
3679                 {
3680                   Clfapf_na_nice = datafile_nxArray[1];
3681                   Clfapf_np_nice = datafile_ny;
3682                   d_1_to_1(datafile_yArray, Clfapf_pArray_nice);
3683                   for (i=1; i<=Clfapf_na_nice; i++)
3684                     Clfapf_aArray_nice[i] = datafile_xArray[1][i];
3685                 }
3686               aeroRollParts -> storeCommands (*command_line);
3687               Clfapf_first=false;
3688             }
3689           break;
3690         }
3691       case Clfarf_flag:
3692         {
3693           int Clfarf_index, i;
3694           string Clfarf_file;
3695           double flap_value;
3696           Clfarf_file = aircraft_directory + linetoken3;
3697           token4 >> Clfarf_index;
3698           if (Clfarf_index < 0 || Clfarf_index >= 100)
3699             uiuc_warnings_errors(1, *command_line);
3700           if (Clfarf_index > Clfarf_nf)
3701             Clfarf_nf = Clfarf_index;
3702           token5 >> flap_value;
3703           Clfarf_fArray[Clfarf_index] = flap_value;
3704           token6 >> token_value_convert1;
3705           token7 >> token_value_convert2;
3706           token8 >> token_value_convert3;
3707           token9 >> Clfarf_nice;
3708           convert_z = uiuc_convert(token_value_convert1);
3709           convert_x = uiuc_convert(token_value_convert2);
3710           convert_y = uiuc_convert(token_value_convert3);
3711           /* call 2D File Reader with file name (Clfarf_file) and
3712              conversion factors; function returns array of
3713              elevator deflections (deArray) and corresponding
3714              alpha (aArray) and delta CZ (CZArray) values and
3715              max number of terms in alpha arrays (nAlphaArray)
3716              and delfection array (nde) */
3717           uiuc_2DdataFileReader(Clfarf_file,
3718                                 datafile_xArray,
3719                                 datafile_yArray,
3720                                 datafile_zArray,
3721                                 datafile_nxArray,
3722                                 datafile_ny);
3723           d_2_to_3(datafile_xArray, Clfarf_aArray, Clfarf_index);
3724           d_1_to_2(datafile_yArray, Clfarf_rArray, Clfarf_index);
3725           d_2_to_3(datafile_zArray, Clfarf_ClArray, Clfarf_index);
3726           i_1_to_2(datafile_nxArray, Clfarf_nAlphaArray, Clfarf_index);
3727           Clfarf_nr[Clfarf_index] = datafile_ny;
3728           if (Clfarf_first==true)
3729             {
3730               if (Clfarf_nice == 1)
3731                 {
3732                   Clfarf_na_nice = datafile_nxArray[1];
3733                   Clfarf_nr_nice = datafile_ny;
3734                   d_1_to_1(datafile_yArray, Clfarf_rArray_nice);
3735                   for (i=1; i<=Clfarf_na_nice; i++)
3736                     Clfarf_aArray_nice[i] = datafile_xArray[1][i];
3737                 }
3738               aeroRollParts -> storeCommands (*command_line);
3739               Clfarf_first=false;
3740             }
3741           break;
3742         }
3743       default:
3744         {
3745           if (dont_ignore)
3746             uiuc_warnings_errors(2, *command_line);
3747           break;
3748         }
3749       };
3750 }
3751
3752
3753 void parse_Cn( const string& linetoken2, const string& linetoken3,
3754                const string& linetoken4, const string& linetoken5,
3755                const string& linetoken6, const string& linetoken7,
3756                const string& linetoken8, const string& linetoken9,
3757                const string& aircraft_directory,
3758                bool &Cnfabetaf_first, bool &Cnfadaf_first,
3759                bool &Cnfadrf_first, bool &Cnfapf_first,
3760                bool &Cnfarf_first, LIST command_line ) {
3761     double token_value;
3762     int token_value_convert1, token_value_convert2, token_value_convert3;
3763     double datafile_xArray[100][100], datafile_yArray[100];
3764     double datafile_zArray[100][100];
3765     int datafile_nxArray[100], datafile_ny;
3766     istrstream token3(linetoken3.c_str());
3767     istrstream token4(linetoken4.c_str());
3768     istrstream token5(linetoken5.c_str());
3769     istrstream token6(linetoken6.c_str());
3770     istrstream token7(linetoken7.c_str());
3771     istrstream token8(linetoken8.c_str());
3772     istrstream token9(linetoken9.c_str());
3773
3774     switch(Cn_map[linetoken2])
3775       {
3776       case Cno_flag:
3777         {
3778           if (check_float(linetoken3))
3779             token3 >> token_value;
3780           else
3781             uiuc_warnings_errors(1, *command_line);
3782
3783           Cno = token_value;
3784           Cno_clean = Cno;
3785           aeroYawParts -> storeCommands (*command_line);
3786           break;
3787         }
3788       case Cn_beta_flag:
3789         {
3790           if (check_float(linetoken3))
3791             token3 >> token_value;
3792           else
3793             uiuc_warnings_errors(1, *command_line);
3794
3795           Cn_beta = token_value;
3796           Cn_beta_clean = Cn_beta;
3797           aeroYawParts -> storeCommands (*command_line);
3798           break;
3799         }
3800       case Cn_p_flag:
3801         {
3802           if (check_float(linetoken3))
3803             token3 >> token_value;
3804           else
3805             uiuc_warnings_errors(1, *command_line);
3806
3807           Cn_p = token_value;
3808           Cn_p_clean = Cn_p;
3809           aeroYawParts -> storeCommands (*command_line);
3810           break;
3811         }
3812       case Cn_r_flag:
3813         {
3814           if (check_float(linetoken3))
3815             token3 >> token_value;
3816           else
3817             uiuc_warnings_errors(1, *command_line);
3818
3819           Cn_r = token_value;
3820           Cn_r_clean = Cn_r;
3821           aeroYawParts -> storeCommands (*command_line);
3822           break;
3823         }
3824       case Cn_da_flag:
3825         {
3826           if (check_float(linetoken3))
3827             token3 >> token_value;
3828           else
3829             uiuc_warnings_errors(1, *command_line);
3830
3831           Cn_da = token_value;
3832           Cn_da_clean = Cn_da;
3833           aeroYawParts -> storeCommands (*command_line);
3834           break;
3835         }
3836       case Cn_dr_flag:
3837         {
3838           if (check_float(linetoken3))
3839             token3 >> token_value;
3840           else
3841             uiuc_warnings_errors(1, *command_line);
3842
3843           Cn_dr = token_value;
3844           Cn_dr_clean = Cn_dr;
3845           aeroYawParts -> storeCommands (*command_line);
3846           break;
3847         }
3848       case Cn_q_flag:
3849         {
3850           if (check_float(linetoken3))
3851             token3 >> token_value;
3852           else
3853             uiuc_warnings_errors(1, *command_line);
3854
3855           Cn_q = token_value;
3856           Cn_q_clean = Cn_q;
3857           aeroYawParts -> storeCommands (*command_line);
3858           break;
3859         }
3860       case Cn_b3_flag:
3861         {
3862           if (check_float(linetoken3))
3863             token3 >> token_value;
3864           else
3865             uiuc_warnings_errors(1, *command_line);
3866
3867           Cn_b3 = token_value;
3868           Cn_b3_clean = Cn_b3;
3869           aeroYawParts -> storeCommands (*command_line);
3870           break;
3871         }
3872       case Cnfada_flag:
3873         {
3874           Cnfada = aircraft_directory + linetoken3;
3875           token4 >> token_value_convert1;
3876           token5 >> token_value_convert2;
3877           token6 >> token_value_convert3;
3878           convert_z = uiuc_convert(token_value_convert1);
3879           convert_x = uiuc_convert(token_value_convert2);
3880           convert_y = uiuc_convert(token_value_convert3);
3881           /* call 2D File Reader with file name (Cnfada) and
3882              conversion factors; function returns array of
3883              aileron deflections (daArray) and corresponding
3884              alpha (aArray) and delta Cn (CnArray) values and
3885              max number of terms in alpha arrays (nAlphaArray)
3886              and deflection array (nda) */
3887           uiuc_2DdataFileReader(Cnfada,
3888                                 Cnfada_aArray,
3889                                 Cnfada_daArray,
3890                                 Cnfada_CnArray,
3891                                 Cnfada_nAlphaArray,
3892                                 Cnfada_nda);
3893           aeroYawParts -> storeCommands (*command_line);
3894           break;
3895         }
3896       case Cnfbetadr_flag:
3897         {
3898           Cnfbetadr = aircraft_directory + linetoken3;
3899           token4 >> token_value_convert1;
3900           token5 >> token_value_convert2;
3901           token6 >> token_value_convert3;
3902           convert_z = uiuc_convert(token_value_convert1);
3903           convert_x = uiuc_convert(token_value_convert2);
3904           convert_y = uiuc_convert(token_value_convert3);
3905           /* call 2D File Reader with file name (Cnfbetadr) and
3906              conversion factors; function returns array of
3907              rudder deflections (drArray) and corresponding
3908              beta (betaArray) and delta Cn (CnArray) values and
3909              max number of terms in beta arrays (nBetaArray)
3910              and deflection array (ndr) */
3911           uiuc_2DdataFileReader(Cnfbetadr,
3912                                 Cnfbetadr_betaArray,
3913                                 Cnfbetadr_drArray,
3914                                 Cnfbetadr_CnArray,
3915                                 Cnfbetadr_nBetaArray,
3916                                 Cnfbetadr_ndr);
3917           aeroYawParts -> storeCommands (*command_line);
3918           break;
3919         }
3920       case Cnfabetaf_flag:
3921         {
3922           int Cnfabetaf_index, i;
3923           string Cnfabetaf_file;
3924           double flap_value;
3925           Cnfabetaf_file = aircraft_directory + linetoken3;
3926           token4 >> Cnfabetaf_index;
3927           if (Cnfabetaf_index < 0 || Cnfabetaf_index >= 100)
3928             uiuc_warnings_errors(1, *command_line);
3929           if (Cnfabetaf_index > Cnfabetaf_nf)
3930             Cnfabetaf_nf = Cnfabetaf_index;
3931           token5 >> flap_value;
3932           Cnfabetaf_fArray[Cnfabetaf_index] = flap_value;
3933           token6 >> token_value_convert1;
3934           token7 >> token_value_convert2;
3935           token8 >> token_value_convert3;
3936           token9 >> Cnfabetaf_nice;
3937           convert_z = uiuc_convert(token_value_convert1);
3938           convert_x = uiuc_convert(token_value_convert2);
3939           convert_y = uiuc_convert(token_value_convert3);
3940           /* call 2D File Reader with file name (Cnfabetaf_file) and
3941              conversion factors; function returns array of
3942              elevator deflections (deArray) and corresponding
3943              alpha (aArray) and delta CZ (CZArray) values and
3944              max number of terms in alpha arrays (nAlphaArray)
3945              and delfection array (nde) */
3946           uiuc_2DdataFileReader(Cnfabetaf_file,
3947                                 datafile_xArray,
3948                                 datafile_yArray,
3949                                 datafile_zArray,
3950                                 datafile_nxArray,
3951                                 datafile_ny);
3952           d_2_to_3(datafile_xArray, Cnfabetaf_aArray, Cnfabetaf_index);
3953           d_1_to_2(datafile_yArray, Cnfabetaf_betaArray, Cnfabetaf_index);
3954           d_2_to_3(datafile_zArray, Cnfabetaf_CnArray, Cnfabetaf_index);
3955           i_1_to_2(datafile_nxArray, Cnfabetaf_nAlphaArray, Cnfabetaf_index);
3956           Cnfabetaf_nbeta[Cnfabetaf_index] = datafile_ny;
3957           if (Cnfabetaf_first==true)
3958             {
3959               if (Cnfabetaf_nice == 1)
3960                 {
3961                   Cnfabetaf_na_nice = datafile_nxArray[1];
3962                   Cnfabetaf_nb_nice = datafile_ny;
3963                   d_1_to_1(datafile_yArray, Cnfabetaf_bArray_nice);
3964                   for (i=1; i<=Cnfabetaf_na_nice; i++)
3965                     Cnfabetaf_aArray_nice[i] = datafile_xArray[1][i];
3966                 }
3967               aeroYawParts -> storeCommands (*command_line);
3968               Cnfabetaf_first=false;
3969             }
3970           break;
3971         }
3972       case Cnfadaf_flag:
3973         {
3974           int Cnfadaf_index, i;
3975           string Cnfadaf_file;
3976           double flap_value;
3977           Cnfadaf_file = aircraft_directory + linetoken3;
3978           token4 >> Cnfadaf_index;
3979           if (Cnfadaf_index < 0 || Cnfadaf_index >= 100)
3980             uiuc_warnings_errors(1, *command_line);
3981           if (Cnfadaf_index > Cnfadaf_nf)
3982             Cnfadaf_nf = Cnfadaf_index;
3983           token5 >> flap_value;
3984           Cnfadaf_fArray[Cnfadaf_index] = flap_value;
3985           token6 >> token_value_convert1;
3986           token7 >> token_value_convert2;
3987           token8 >> token_value_convert3;
3988           token9 >> Cnfadaf_nice;
3989           convert_z = uiuc_convert(token_value_convert1);
3990           convert_x = uiuc_convert(token_value_convert2);
3991           convert_y = uiuc_convert(token_value_convert3);
3992           /* call 2D File Reader with file name (Cnfadaf_file) and
3993              conversion factors; function returns array of
3994              elevator deflections (deArray) and corresponding
3995              alpha (aArray) and delta CZ (CZArray) values and
3996              max number of terms in alpha arrays (nAlphaArray)
3997              and delfection array (nde) */
3998           uiuc_2DdataFileReader(Cnfadaf_file,
3999                                 datafile_xArray,
4000                                 datafile_yArray,
4001                                 datafile_zArray,
4002                                 datafile_nxArray,
4003                                 datafile_ny);
4004           d_2_to_3(datafile_xArray, Cnfadaf_aArray, Cnfadaf_index);
4005           d_1_to_2(datafile_yArray, Cnfadaf_daArray, Cnfadaf_index);
4006           d_2_to_3(datafile_zArray, Cnfadaf_CnArray, Cnfadaf_index);
4007           i_1_to_2(datafile_nxArray, Cnfadaf_nAlphaArray, Cnfadaf_index);
4008           Cnfadaf_nda[Cnfadaf_index] = datafile_ny;
4009           if (Cnfadaf_first==true)
4010             {
4011               if (Cnfadaf_nice == 1)
4012                 {
4013                   Cnfadaf_na_nice = datafile_nxArray[1];
4014                   Cnfadaf_nda_nice = datafile_ny;
4015                   d_1_to_1(datafile_yArray, Cnfadaf_daArray_nice);
4016                   for (i=1; i<=Cnfadaf_na_nice; i++)
4017                     Cnfadaf_aArray_nice[i] = datafile_xArray[1][i];
4018                 }
4019               aeroYawParts -> storeCommands (*command_line);
4020               Cnfadaf_first=false;
4021             }
4022           break;
4023         }
4024       case Cnfadrf_flag:
4025         {
4026           int Cnfadrf_index, i;
4027           string Cnfadrf_file;
4028           double flap_value;
4029           Cnfadrf_file = aircraft_directory + linetoken3;
4030           token4 >> Cnfadrf_index;
4031           if (Cnfadrf_index < 0 || Cnfadrf_index >= 100)
4032             uiuc_warnings_errors(1, *command_line);
4033           if (Cnfadrf_index > Cnfadrf_nf)
4034             Cnfadrf_nf = Cnfadrf_index;
4035           token5 >> flap_value;
4036           Cnfadrf_fArray[Cnfadrf_index] = flap_value;
4037           token6 >> token_value_convert1;
4038           token7 >> token_value_convert2;
4039           token8 >> token_value_convert3;
4040           token9 >> Cnfadrf_nice;
4041           convert_z = uiuc_convert(token_value_convert1);
4042           convert_x = uiuc_convert(token_value_convert2);
4043           convert_y = uiuc_convert(token_value_convert3);
4044           /* call 2D File Reader with file name (Cnfadrf_file) and
4045              conversion factors; function returns array of
4046              elevator deflections (deArray) and corresponding
4047              alpha (aArray) and delta CZ (CZArray) values and
4048              max number of terms in alpha arrays (nAlphaArray)
4049              and delfection array (nde) */
4050           uiuc_2DdataFileReader(Cnfadrf_file,
4051                                 datafile_xArray,
4052                                 datafile_yArray,
4053                                 datafile_zArray,
4054                                 datafile_nxArray,
4055                                 datafile_ny);
4056           d_2_to_3(datafile_xArray, Cnfadrf_aArray, Cnfadrf_index);
4057           d_1_to_2(datafile_yArray, Cnfadrf_drArray, Cnfadrf_index);
4058           d_2_to_3(datafile_zArray, Cnfadrf_CnArray, Cnfadrf_index);
4059           i_1_to_2(datafile_nxArray, Cnfadrf_nAlphaArray, Cnfadrf_index);
4060           Cnfadrf_ndr[Cnfadrf_index] = datafile_ny;
4061           if (Cnfadrf_first==true)
4062             {
4063               if (Cnfadrf_nice == 1)
4064                 {
4065                   Cnfadrf_na_nice = datafile_nxArray[1];
4066                   Cnfadrf_ndr_nice = datafile_ny;
4067                   d_1_to_1(datafile_yArray, Cnfadrf_drArray_nice);
4068                   for (i=1; i<=Cnfadrf_na_nice; i++)
4069                     Cnfadrf_aArray_nice[i] = datafile_xArray[1][i];
4070                 }
4071               aeroYawParts -> storeCommands (*command_line);
4072               Cnfadrf_first=false;
4073             }
4074           break;
4075         }
4076       case Cnfapf_flag:
4077         {
4078           int Cnfapf_index, i;
4079           string Cnfapf_file;
4080           double flap_value;
4081           Cnfapf_file = aircraft_directory + linetoken3;
4082           token4 >> Cnfapf_index;
4083           if (Cnfapf_index < 0 || Cnfapf_index >= 100)
4084             uiuc_warnings_errors(1, *command_line);
4085           if (Cnfapf_index > Cnfapf_nf)
4086             Cnfapf_nf = Cnfapf_index;
4087           token5 >> flap_value;
4088           Cnfapf_fArray[Cnfapf_index] = flap_value;
4089           token6 >> token_value_convert1;
4090           token7 >> token_value_convert2;
4091           token8 >> token_value_convert3;
4092           token9 >> Cnfapf_nice;
4093           convert_z = uiuc_convert(token_value_convert1);
4094           convert_x = uiuc_convert(token_value_convert2);
4095           convert_y = uiuc_convert(token_value_convert3);
4096           /* call 2D File Reader with file name (Cnfapf_file) and
4097              conversion factors; function returns array of
4098              elevator deflections (deArray) and corresponding
4099              alpha (aArray) and delta CZ (CZArray) values and
4100              max number of terms in alpha arrays (nAlphaArray)
4101              and delfection array (nde) */
4102           uiuc_2DdataFileReader(Cnfapf_file,
4103                                 datafile_xArray,
4104                                 datafile_yArray,
4105                                 datafile_zArray,
4106                                 datafile_nxArray,
4107                                 datafile_ny);
4108           d_2_to_3(datafile_xArray, Cnfapf_aArray, Cnfapf_index);
4109           d_1_to_2(datafile_yArray, Cnfapf_pArray, Cnfapf_index);
4110           d_2_to_3(datafile_zArray, Cnfapf_CnArray, Cnfapf_index);
4111           i_1_to_2(datafile_nxArray, Cnfapf_nAlphaArray, Cnfapf_index);
4112           Cnfapf_np[Cnfapf_index] = datafile_ny;
4113           if (Cnfapf_first==true)
4114             {
4115               if (Cnfapf_nice == 1)
4116                 {
4117                   Cnfapf_na_nice = datafile_nxArray[1];
4118                   Cnfapf_np_nice = datafile_ny;
4119                   d_1_to_1(datafile_yArray, Cnfapf_pArray_nice);
4120                   for (i=1; i<=Cnfapf_na_nice; i++)
4121                     Cnfapf_aArray_nice[i] = datafile_xArray[1][i];
4122                 }
4123               aeroYawParts -> storeCommands (*command_line);
4124               Cnfapf_first=false;
4125             }
4126           break;
4127         }
4128       case Cnfarf_flag:
4129         {
4130           int Cnfarf_index, i;
4131           string Cnfarf_file;
4132           double flap_value;
4133           Cnfarf_file = aircraft_directory + linetoken3;
4134           token4 >> Cnfarf_index;
4135           if (Cnfarf_index < 0 || Cnfarf_index >= 100)
4136             uiuc_warnings_errors(1, *command_line);
4137           if (Cnfarf_index > Cnfarf_nf)
4138             Cnfarf_nf = Cnfarf_index;
4139           token5 >> flap_value;
4140           Cnfarf_fArray[Cnfarf_index] = flap_value;
4141           token6 >> token_value_convert1;
4142           token7 >> token_value_convert2;
4143           token8 >> token_value_convert3;
4144           token9 >> Cnfarf_nice;
4145           convert_z = uiuc_convert(token_value_convert1);
4146           convert_x = uiuc_convert(token_value_convert2);
4147           convert_y = uiuc_convert(token_value_convert3);
4148           /* call 2D File Reader with file name (Cnfarf_file) and
4149              conversion factors; function returns array of
4150              elevator deflections (deArray) and corresponding
4151              alpha (aArray) and delta CZ (CZArray) values and
4152              max number of terms in alpha arrays (nAlphaArray)
4153              and delfection array (nde) */
4154           uiuc_2DdataFileReader(Cnfarf_file,
4155                                 datafile_xArray,
4156                                 datafile_yArray,
4157                                 datafile_zArray,
4158                                 datafile_nxArray,
4159                                 datafile_ny);
4160           d_2_to_3(datafile_xArray, Cnfarf_aArray, Cnfarf_index);
4161           d_1_to_2(datafile_yArray, Cnfarf_rArray, Cnfarf_index);
4162           d_2_to_3(datafile_zArray, Cnfarf_CnArray, Cnfarf_index);
4163           i_1_to_2(datafile_nxArray, Cnfarf_nAlphaArray, Cnfarf_index);
4164           Cnfarf_nr[Cnfarf_index] = datafile_ny;
4165           if (Cnfarf_first==true)
4166             {
4167               if (Cnfarf_nice == 1)
4168                 {
4169                   Cnfarf_na_nice = datafile_nxArray[1];
4170                   Cnfarf_nr_nice = datafile_ny;
4171                   d_1_to_1(datafile_yArray, Cnfarf_rArray_nice);
4172                   for (i=1; i<=Cnfarf_na_nice; i++)
4173                     Cnfarf_aArray_nice[i] = datafile_xArray[1][i];
4174                 }
4175               aeroYawParts -> storeCommands (*command_line);
4176               Cnfarf_first=false;
4177             }
4178           break;
4179         }
4180       default:
4181         {
4182           if (dont_ignore)
4183             uiuc_warnings_errors(2, *command_line);
4184           break;
4185         }
4186       };
4187 }
4188
4189 void parse_gear( const string& linetoken2, const string& linetoken3,
4190                  const string& linetoken4, const int& index,
4191                  LIST command_line ) {
4192     double token_value;
4193     istrstream token3(linetoken3.c_str());
4194     istrstream token4(linetoken4.c_str());
4195
4196     switch(gear_map[linetoken2])
4197       {
4198       case Dx_gear_flag:
4199         {
4200           if (check_float(linetoken3))
4201             token4 >> token_value;
4202           else
4203             uiuc_warnings_errors(1, *command_line);
4204           D_gear_v[index][0] = token_value;
4205           gear_model[index] = true;
4206           break;
4207         }
4208       case Dy_gear_flag:
4209         {
4210           if (check_float(linetoken3))
4211             token4 >> token_value;
4212           else
4213             uiuc_warnings_errors(1, *command_line);
4214           D_gear_v[index][1] = token_value;
4215           gear_model[index] = true;
4216           break;
4217         }
4218       case Dz_gear_flag:
4219         {
4220           if (check_float(linetoken3))
4221             token4 >> token_value;
4222           else
4223             uiuc_warnings_errors(1, *command_line);
4224           D_gear_v[index][2] = token_value;
4225           gear_model[index] = true;
4226           break;
4227         }
4228       case cgear_flag:
4229         {
4230           if (check_float(linetoken3))
4231             token4 >> token_value;
4232           else
4233             uiuc_warnings_errors(1, *command_line);
4234           cgear[index] = token_value;
4235           gear_model[index] = true;
4236           break;
4237         }
4238       case kgear_flag:
4239         {
4240           if (check_float(linetoken3))
4241             token4 >> token_value;
4242           else
4243             uiuc_warnings_errors(1, *command_line);
4244           kgear[index] = token_value;
4245           gear_model[index] = true;
4246           break;
4247         }
4248       case muGear_flag:
4249         {
4250           if (check_float(linetoken3))
4251             token4 >> token_value;
4252           else
4253             uiuc_warnings_errors(1, *command_line);
4254           muGear[index] = token_value;
4255           gear_model[index] = true;
4256           break;
4257         }
4258       case strutLength_flag:
4259         {
4260           if (check_float(linetoken3))
4261             token4 >> token_value;
4262           else
4263             uiuc_warnings_errors(1, *command_line);
4264           strutLength[index] = token_value;
4265           gear_model[index] = true;
4266           break;
4267         }
4268       default:
4269         {
4270           if (dont_ignore)
4271             uiuc_warnings_errors(2, *command_line);
4272           break;
4273         }
4274       };
4275 }
4276
4277
4278 void parse_ice( const string& linetoken2, const string& linetoken3,
4279                 const string& linetoken4, const string& linetoken5,
4280                 const string& linetoken6, const string& linetoken7,
4281                 const string& linetoken8, const string& linetoken9,
4282                 const string& aircraft_directory,
4283                 bool &tactilefadef_first, LIST command_line ) {
4284     double token_value;
4285     int token_value_convert1, token_value_convert2, token_value_convert3;
4286     double datafile_xArray[100][100], datafile_yArray[100];
4287     double datafile_zArray[100][100];
4288     int datafile_nxArray[100], datafile_ny;
4289     istrstream token3(linetoken3.c_str());
4290     istrstream token4(linetoken4.c_str());
4291     istrstream token5(linetoken5.c_str());
4292     istrstream token6(linetoken6.c_str());
4293     istrstream token7(linetoken7.c_str());
4294     istrstream token8(linetoken8.c_str());
4295     istrstream token9(linetoken9.c_str());
4296
4297     switch(ice_map[linetoken2])
4298       {
4299       case iceTime_flag:
4300         {
4301           if (check_float(linetoken3))
4302             token3 >> token_value;
4303
4304           else
4305             uiuc_warnings_errors(1, *command_line);
4306
4307           ice_model = true;
4308           iceTime = token_value;
4309           break;
4310         }
4311       case transientTime_flag:
4312         {
4313           if (check_float(linetoken3))
4314             token3 >> token_value;
4315           else
4316             uiuc_warnings_errors(1, *command_line);
4317
4318           transientTime = token_value;
4319           break;
4320         }
4321       case eta_ice_final_flag:
4322         {
4323           if (check_float(linetoken3))
4324             token3 >> token_value;
4325           else
4326             uiuc_warnings_errors(1, *command_line);
4327
4328           eta_ice_final = token_value;
4329           break;
4330         }
4331       case beta_probe_wing_flag:
4332         {
4333           if (check_float(linetoken3))
4334             token3 >> token_value;
4335           else
4336             uiuc_warnings_errors(1, *command_line);
4337
4338           beta_model = true;
4339           x_probe_wing = token_value;
4340           break;
4341         }
4342       case beta_probe_tail_flag:
4343         {
4344           if (check_float(linetoken3))
4345             token3 >> token_value;
4346           else
4347             uiuc_warnings_errors(1, *command_line);
4348
4349           beta_model = true;
4350           x_probe_tail = token_value;
4351           break;
4352         }
4353       case kCDo_flag:
4354         {
4355           if (check_float(linetoken3))
4356             token3 >> token_value;
4357           else
4358             uiuc_warnings_errors(1, *command_line);
4359
4360           kCDo = token_value;
4361           break;
4362         }
4363       case kCDK_flag:
4364         {
4365           if (check_float(linetoken3))
4366             token3 >> token_value;
4367           else
4368             uiuc_warnings_errors(1, *command_line);
4369
4370           kCDK = token_value;
4371           break;
4372         }
4373       case kCD_a_flag:
4374         {
4375           if (check_float(linetoken3))
4376             token3 >> token_value;
4377           else
4378             uiuc_warnings_errors(1, *command_line);
4379
4380           kCD_a = token_value;
4381           break;
4382         }
4383       case kCD_adot_flag:
4384         {
4385           if (check_float(linetoken3))
4386             token3 >> token_value;
4387           else
4388             uiuc_warnings_errors(1, *command_line);
4389
4390           kCD_adot = token_value;
4391           break;
4392         }
4393       case kCD_q_flag:
4394         {
4395           if (check_float(linetoken3))
4396             token3 >> token_value;
4397           else
4398             uiuc_warnings_errors(1, *command_line);
4399
4400           kCD_q = token_value;
4401           break;
4402         }
4403       case kCD_de_flag:
4404         {
4405           if (check_float(linetoken3))
4406             token3 >> token_value;
4407           else
4408             uiuc_warnings_errors(1, *command_line);
4409
4410           kCD_de = token_value;
4411           break;
4412         }
4413       case kCXo_flag:
4414         {
4415           if (check_float(linetoken3))
4416             token3 >> token_value;
4417           else
4418             uiuc_warnings_errors(1, *command_line);
4419
4420           kCXo = token_value;
4421           break;
4422         }
4423       case kCXK_flag:
4424         {
4425           if (check_float(linetoken3))
4426             token3 >> token_value;
4427           else
4428             uiuc_warnings_errors(1, *command_line);
4429
4430           kCXK = token_value;
4431           break;
4432         }
4433       case kCX_a_flag:
4434         {
4435           if (check_float(linetoken3))
4436             token3 >> token_value;
4437           else
4438             uiuc_warnings_errors(1, *command_line);
4439
4440           kCX_a = token_value;
4441           break;
4442         }
4443       case kCX_a2_flag:
4444         {
4445           if (check_float(linetoken3))
4446             token3 >> token_value;
4447           else
4448             uiuc_warnings_errors(1, *command_line);
4449
4450           kCX_a2 = token_value;
4451           break;
4452         }
4453       case kCX_a3_flag:
4454         {
4455           if (check_float(linetoken3))
4456             token3 >> token_value;
4457           else
4458             uiuc_warnings_errors(1, *command_line);
4459
4460           kCX_a3 = token_value;
4461           break;
4462         }
4463       case kCX_adot_flag:
4464         {
4465           if (check_float(linetoken3))
4466             token3 >> token_value;
4467           else
4468             uiuc_warnings_errors(1, *command_line);
4469
4470           kCX_adot = token_value;
4471           break;
4472         }
4473       case kCX_q_flag:
4474         {
4475           if (check_float(linetoken3))
4476             token3 >> token_value;
4477           else
4478             uiuc_warnings_errors(1, *command_line);
4479
4480           kCX_q = token_value;
4481           break;
4482         }
4483       case kCX_de_flag:
4484         {
4485           if (check_float(linetoken3))
4486             token3 >> token_value;
4487           else
4488             uiuc_warnings_errors(1, *command_line);
4489
4490           kCX_de = token_value;
4491           break;
4492         }
4493       case kCX_dr_flag:
4494         {
4495           if (check_float(linetoken3))
4496             token3 >> token_value;
4497           else
4498             uiuc_warnings_errors(1, *command_line);
4499
4500           kCX_dr = token_value;
4501           break;
4502         }
4503       case kCX_df_flag:
4504         {
4505           if (check_float(linetoken3))
4506             token3 >> token_value;
4507           else
4508             uiuc_warnings_errors(1, *command_line);
4509
4510           kCX_df = token_value;
4511           break;
4512         }
4513       case kCX_adf_flag:
4514         {
4515           if (check_float(linetoken3))
4516             token3 >> token_value;
4517           else
4518             uiuc_warnings_errors(1, *command_line);
4519
4520           kCX_adf = token_value;
4521           break;
4522         }
4523       case kCLo_flag:
4524         {
4525           if (check_float(linetoken3))
4526             token3 >> token_value;
4527           else
4528             uiuc_warnings_errors(1, *command_line);
4529
4530           kCLo = token_value;
4531           break;
4532         }
4533       case kCL_a_flag:
4534         {
4535           if (check_float(linetoken3))
4536             token3 >> token_value;
4537           else
4538             uiuc_warnings_errors(1, *command_line);
4539
4540           kCL_a = token_value;
4541           break;
4542         }
4543       case kCL_adot_flag:
4544         {
4545           if (check_float(linetoken3))
4546             token3 >> token_value;
4547           else
4548             uiuc_warnings_errors(1, *command_line);
4549
4550           kCL_adot = token_value;
4551           break;
4552         }
4553       case kCL_q_flag:
4554         {
4555           if (check_float(linetoken3))
4556             token3 >> token_value;
4557           else
4558             uiuc_warnings_errors(1, *command_line);
4559
4560           kCL_q = token_value;
4561           break;
4562         }
4563       case kCL_de_flag:
4564         {
4565           if (check_float(linetoken3))
4566             token3 >> token_value;
4567           else
4568             uiuc_warnings_errors(1, *command_line);
4569
4570           kCL_de = token_value;
4571           break;
4572         }
4573       case kCZo_flag:
4574         {
4575           if (check_float(linetoken3))
4576             token3 >> token_value;
4577           else
4578             uiuc_warnings_errors(1, *command_line);
4579
4580           kCZo = token_value;
4581           break;
4582         }
4583       case kCZ_a_flag:
4584         {
4585           if (check_float(linetoken3))
4586             token3 >> token_value;
4587           else
4588             uiuc_warnings_errors(1, *command_line);
4589
4590           kCZ_a = token_value;
4591           break;
4592         }
4593       case kCZ_a2_flag:
4594         {
4595           if (check_float(linetoken3))
4596             token3 >> token_value;
4597           else
4598             uiuc_warnings_errors(1, *command_line);
4599
4600           kCZ_a2 = token_value;
4601           break;
4602         }
4603       case kCZ_a3_flag:
4604         {
4605           if (check_float(linetoken3))
4606             token3 >> token_value;
4607           else
4608             uiuc_warnings_errors(1, *command_line);
4609
4610           kCZ_a3 = token_value;
4611           break;
4612         }
4613       case kCZ_adot_flag:
4614         {
4615           if (check_float(linetoken3))
4616             token3 >> token_value;
4617           else
4618             uiuc_warnings_errors(1, *command_line);
4619
4620           kCZ_adot = token_value;
4621           break;
4622         }
4623       case kCZ_q_flag:
4624         {
4625           if (check_float(linetoken3))
4626             token3 >> token_value;
4627           else
4628             uiuc_warnings_errors(1, *command_line);
4629
4630           kCZ_q = token_value;
4631           break;
4632         }
4633       case kCZ_de_flag:
4634         {
4635           if (check_float(linetoken3))
4636             token3 >> token_value;
4637           else
4638             uiuc_warnings_errors(1, *command_line);
4639
4640           kCZ_de = token_value;
4641           break;
4642         }
4643       case kCZ_deb2_flag:
4644         {
4645           if (check_float(linetoken3))
4646             token3 >> token_value;
4647           else
4648             uiuc_warnings_errors(1, *command_line);
4649
4650           kCZ_deb2 = token_value;
4651           break;
4652         }
4653       case kCZ_df_flag:
4654         {
4655           if (check_float(linetoken3))
4656             token3 >> token_value;
4657           else
4658             uiuc_warnings_errors(1, *command_line);
4659
4660           kCZ_df = token_value;
4661           break;
4662         }
4663       case kCZ_adf_flag:
4664         {
4665           if (check_float(linetoken3))
4666             token3 >> token_value;
4667           else
4668             uiuc_warnings_errors(1, *command_line);
4669
4670           kCZ_adf = token_value;
4671           break;
4672         }
4673       case kCmo_flag:
4674         {
4675           if (check_float(linetoken3))
4676             token3 >> token_value;
4677           else
4678             uiuc_warnings_errors(1, *command_line);
4679
4680           kCmo = token_value;
4681           break;
4682         }
4683       case kCm_a_flag:
4684         {
4685           if (check_float(linetoken3))
4686             token3 >> token_value;
4687           else
4688             uiuc_warnings_errors(1, *command_line);
4689
4690           kCm_a = token_value;
4691           break;
4692         }
4693       case kCm_a2_flag:
4694         {
4695           if (check_float(linetoken3))
4696             token3 >> token_value;
4697           else
4698             uiuc_warnings_errors(1, *command_line);
4699
4700           kCm_a2 = token_value;
4701           break;
4702         }
4703       case kCm_adot_flag:
4704         {
4705           if (check_float(linetoken3))
4706             token3 >> token_value;
4707           else
4708             uiuc_warnings_errors(1, *command_line);
4709
4710           kCm_adot = token_value;
4711           break;
4712         }
4713       case kCm_q_flag:
4714         {
4715           if (check_float(linetoken3))
4716             token3 >> token_value;
4717           else
4718             uiuc_warnings_errors(1, *command_line);
4719
4720           kCm_q = token_value;
4721           break;
4722         }
4723       case kCm_de_flag:
4724         {
4725           if (check_float(linetoken3))
4726             token3 >> token_value;
4727           else
4728             uiuc_warnings_errors(1, *command_line);
4729
4730           kCm_de = token_value;
4731           break;
4732         }
4733       case kCm_b2_flag:
4734         {
4735           if (check_float(linetoken3))
4736             token3 >> token_value;
4737           else
4738             uiuc_warnings_errors(1, *command_line);
4739
4740           kCm_b2 = token_value;
4741           break;
4742         }
4743       case kCm_r_flag:
4744         {
4745           if (check_float(linetoken3))
4746             token3 >> token_value;
4747           else
4748             uiuc_warnings_errors(1, *command_line);
4749
4750           kCm_r = token_value;
4751           break;
4752         }
4753       case kCm_df_flag:
4754         {
4755           if (check_float(linetoken3))
4756             token3 >> token_value;
4757           else
4758             uiuc_warnings_errors(1, *command_line);
4759
4760           kCm_df = token_value;
4761           break;
4762         }
4763       case kCYo_flag:
4764         {
4765           if (check_float(linetoken3))
4766             token3 >> token_value;
4767           else
4768             uiuc_warnings_errors(1, *command_line);
4769
4770           kCYo = token_value;
4771           break;
4772         }
4773       case kCY_beta_flag:
4774         {
4775           if (check_float(linetoken3))
4776             token3 >> token_value;
4777           else
4778             uiuc_warnings_errors(1, *command_line);
4779
4780           kCY_beta = token_value;
4781           break;
4782         }
4783       case kCY_p_flag:
4784         {
4785           if (check_float(linetoken3))
4786             token3 >> token_value;
4787           else
4788             uiuc_warnings_errors(1, *command_line);
4789
4790           kCY_p = token_value;
4791           break;
4792         }
4793       case kCY_r_flag:
4794         {
4795           if (check_float(linetoken3))
4796             token3 >> token_value;
4797           else
4798             uiuc_warnings_errors(1, *command_line);
4799
4800           kCY_r = token_value;
4801           break;
4802         }
4803       case kCY_da_flag:
4804         {
4805           if (check_float(linetoken3))
4806             token3 >> token_value;
4807           else
4808             uiuc_warnings_errors(1, *command_line);
4809
4810           kCY_da = token_value;
4811           break;
4812         }
4813       case kCY_dr_flag:
4814         {
4815           if (check_float(linetoken3))
4816             token3 >> token_value;
4817           else
4818             uiuc_warnings_errors(1, *command_line);
4819
4820           kCY_dr = token_value;
4821           break;
4822         }
4823       case kCY_dra_flag:
4824         {
4825           if (check_float(linetoken3))
4826             token3 >> token_value;
4827           else
4828             uiuc_warnings_errors(1, *command_line);
4829
4830           kCY_dra = token_value;
4831           break;
4832         }
4833       case kCY_bdot_flag:
4834         {
4835           if (check_float(linetoken3))
4836             token3 >> token_value;
4837           else
4838             uiuc_warnings_errors(1, *command_line);
4839
4840           kCY_bdot = token_value;
4841           break;
4842         }
4843       case kClo_flag:
4844         {
4845           if (check_float(linetoken3))
4846             token3 >> token_value;
4847           else
4848             uiuc_warnings_errors(1, *command_line);
4849
4850           kClo = token_value;
4851           break;
4852         }
4853       case kCl_beta_flag:
4854         {
4855           if (check_float(linetoken3))
4856             token3 >> token_value;
4857           else
4858             uiuc_warnings_errors(1, *command_line);
4859
4860           kCl_beta = token_value;
4861           break;
4862         }
4863       case kCl_p_flag:
4864         {
4865           if (check_float(linetoken3))
4866             token3 >> token_value;
4867           else
4868             uiuc_warnings_errors(1, *command_line);
4869
4870           kCl_p = token_value;
4871           break;
4872         }
4873       case kCl_r_flag:
4874         {
4875           if (check_float(linetoken3))
4876             token3 >> token_value;
4877           else
4878             uiuc_warnings_errors(1, *command_line);
4879
4880           kCl_r = token_value;
4881           break;
4882         }
4883       case kCl_da_flag:
4884         {
4885           if (check_float(linetoken3))
4886             token3 >> token_value;
4887           else
4888             uiuc_warnings_errors(1, *command_line);
4889
4890           kCl_da = token_value;
4891           break;
4892         }
4893       case kCl_dr_flag:
4894         {
4895           if (check_float(linetoken3))
4896             token3 >> token_value;
4897           else
4898             uiuc_warnings_errors(1, *command_line);
4899
4900           kCl_dr = token_value;
4901           break;
4902         }
4903       case kCl_daa_flag:
4904         {
4905           if (check_float(linetoken3))
4906             token3 >> token_value;
4907           else
4908             uiuc_warnings_errors(1, *command_line);
4909
4910           kCl_daa = token_value;
4911           break;
4912         }
4913       case kCno_flag:
4914         {
4915           if (check_float(linetoken3))
4916             token3 >> token_value;
4917           else
4918             uiuc_warnings_errors(1, *command_line);
4919
4920           kCno = token_value;
4921           break;
4922         }
4923       case kCn_beta_flag:
4924         {
4925           if (check_float(linetoken3))
4926             token3 >> token_value;
4927           else
4928             uiuc_warnings_errors(1, *command_line);
4929
4930           kCn_beta = token_value;
4931           break;
4932         }
4933       case kCn_p_flag:
4934         {
4935           if (check_float(linetoken3))
4936             token3 >> token_value;
4937           else
4938             uiuc_warnings_errors(1, *command_line);
4939
4940           kCn_p = token_value;
4941           break;
4942         }
4943       case kCn_r_flag:
4944         {
4945           if (check_float(linetoken3))
4946             token3 >> token_value;
4947           else
4948             uiuc_warnings_errors(1, *command_line);
4949
4950           kCn_r = token_value;
4951           break;
4952         }
4953       case kCn_da_flag:
4954         {
4955           if (check_float(linetoken3))
4956             token3 >> token_value;
4957           else
4958             uiuc_warnings_errors(1, *command_line);
4959
4960           kCn_da = token_value;
4961           break;
4962         }
4963       case kCn_dr_flag:
4964         {
4965           if (check_float(linetoken3))
4966             token3 >> token_value;
4967           else
4968             uiuc_warnings_errors(1, *command_line);
4969
4970           kCn_dr = token_value;
4971           break;
4972         }
4973       case kCn_q_flag:
4974         {
4975           if (check_float(linetoken3))
4976             token3 >> token_value;
4977           else
4978             uiuc_warnings_errors(1, *command_line);
4979
4980           kCn_q = token_value;
4981           break;
4982         }
4983       case kCn_b3_flag:
4984         {
4985           if (check_float(linetoken3))
4986             token3 >> token_value;
4987           else
4988             uiuc_warnings_errors(1, *command_line);
4989
4990           kCn_b3 = token_value;
4991           break;
4992         }
4993       case bootTime_flag:
4994         {
4995           int index;
4996           if (check_float(linetoken4))
4997             token4 >> token_value;
4998           else
4999             uiuc_warnings_errors(1, *command_line);
5000           token3 >> index;
5001           if (index < 0 || index >= 20)
5002             uiuc_warnings_errors(1, *command_line);
5003           bootTime[index] = token_value;
5004           bootTrue[index] = true;
5005           break;
5006         }
5007       case eta_wing_left_input_flag:
5008         {
5009           eta_from_file = true;
5010           eta_wing_left_input = true;
5011           eta_wing_left_input_file = aircraft_directory + linetoken3;
5012           token4 >> token_value_convert1;
5013           token5 >> token_value_convert2;
5014           convert_y = uiuc_convert(token_value_convert1);
5015           convert_x = uiuc_convert(token_value_convert2);
5016           uiuc_1DdataFileReader(eta_wing_left_input_file,
5017                                 eta_wing_left_input_timeArray,
5018                                 eta_wing_left_input_daArray,
5019                                 eta_wing_left_input_ntime);
5020           token6 >> token_value;
5021           eta_wing_left_input_startTime = token_value;
5022           break;
5023         }
5024       case eta_wing_right_input_flag:
5025         {
5026           eta_from_file = true;
5027           eta_wing_right_input = true;
5028           eta_wing_right_input_file = aircraft_directory + linetoken3;
5029           token4 >> token_value_convert1;
5030           token5 >> token_value_convert2;
5031           convert_y = uiuc_convert(token_value_convert1);
5032           convert_x = uiuc_convert(token_value_convert2);
5033           uiuc_1DdataFileReader(eta_wing_right_input_file,
5034                                 eta_wing_right_input_timeArray,
5035                                 eta_wing_right_input_daArray,
5036                                 eta_wing_right_input_ntime);
5037           token6 >> token_value;
5038           eta_wing_right_input_startTime = token_value;
5039           break;
5040         }
5041       case eta_tail_input_flag:
5042         {
5043           eta_from_file = true;
5044           eta_tail_input = true;
5045           eta_tail_input_file = aircraft_directory + linetoken3;
5046           token4 >> token_value_convert1;
5047           token5 >> token_value_convert2;
5048           convert_y = uiuc_convert(token_value_convert1);
5049           convert_x = uiuc_convert(token_value_convert2);
5050           uiuc_1DdataFileReader(eta_tail_input_file,
5051                                 eta_tail_input_timeArray,
5052                                 eta_tail_input_daArray,
5053                                 eta_tail_input_ntime);
5054           token6 >> token_value;
5055           eta_tail_input_startTime = token_value;
5056           break;
5057         }
5058       case nonlin_ice_case_flag:
5059         {
5060           token3 >> nonlin_ice_case;
5061           break;
5062         }
5063       case eta_tail_flag:
5064         {
5065           if (check_float(linetoken3))
5066             token3 >> token_value;
5067           else
5068             uiuc_warnings_errors(1, *command_line);
5069
5070           eta_tail = token_value;
5071           break;
5072         }
5073       case eta_wing_left_flag:
5074         {
5075           if (check_float(linetoken3))
5076             token3 >> token_value;
5077           else
5078             uiuc_warnings_errors(1, *command_line);
5079
5080           eta_wing_left = token_value;
5081           break;
5082         }
5083       case eta_wing_right_flag:
5084         {
5085           if (check_float(linetoken3))
5086             token3 >> token_value;
5087           else
5088             uiuc_warnings_errors(1, *command_line);
5089
5090           eta_wing_right = token_value;
5091           break;
5092         }
5093       case demo_eps_alpha_max_flag:
5094         {
5095           demo_eps_alpha_max = true;
5096           demo_eps_alpha_max_file = aircraft_directory + linetoken3;
5097           token4 >> token_value_convert1;
5098           token5 >> token_value_convert2;
5099           convert_y = uiuc_convert(token_value_convert1);
5100           convert_x = uiuc_convert(token_value_convert2);
5101           uiuc_1DdataFileReader(demo_eps_alpha_max_file,
5102                                 demo_eps_alpha_max_timeArray,
5103                                 demo_eps_alpha_max_daArray,
5104                                 demo_eps_alpha_max_ntime);
5105           token6 >> token_value;
5106           demo_eps_alpha_max_startTime = token_value;
5107           break;
5108         }
5109       case demo_eps_pitch_max_flag:
5110         {
5111           demo_eps_pitch_max = true;
5112           demo_eps_pitch_max_file = aircraft_directory + linetoken3;
5113           token4 >> token_value_convert1;
5114           token5 >> token_value_convert2;
5115           convert_y = uiuc_convert(token_value_convert1);
5116           convert_x = uiuc_convert(token_value_convert2);
5117           uiuc_1DdataFileReader(demo_eps_pitch_max_file,
5118                                 demo_eps_pitch_max_timeArray,
5119                                 demo_eps_pitch_max_daArray,
5120                                 demo_eps_pitch_max_ntime);
5121           token6 >> token_value;
5122           demo_eps_pitch_max_startTime = token_value;
5123           break;
5124         }
5125       case demo_eps_pitch_min_flag:
5126         {
5127           demo_eps_pitch_min = true;
5128           demo_eps_pitch_min_file = aircraft_directory + linetoken3;
5129           token4 >> token_value_convert1;
5130           token5 >> token_value_convert2;
5131           convert_y = uiuc_convert(token_value_convert1);
5132           convert_x = uiuc_convert(token_value_convert2);
5133           uiuc_1DdataFileReader(demo_eps_pitch_min_file,
5134                                 demo_eps_pitch_min_timeArray,
5135                                 demo_eps_pitch_min_daArray,
5136                                 demo_eps_pitch_min_ntime);
5137           token6 >> token_value;
5138           demo_eps_pitch_min_startTime = token_value;
5139           break;
5140         }
5141       case demo_eps_roll_max_flag:
5142         {
5143           demo_eps_roll_max = true;
5144           demo_eps_roll_max_file = aircraft_directory + linetoken3;
5145           token4 >> token_value_convert1;
5146           token5 >> token_value_convert2;
5147           convert_y = uiuc_convert(token_value_convert1);
5148           convert_x = uiuc_convert(token_value_convert2);
5149           uiuc_1DdataFileReader(demo_eps_roll_max_file,
5150                                 demo_eps_roll_max_timeArray,
5151                                 demo_eps_roll_max_daArray,
5152                                 demo_eps_roll_max_ntime);
5153           token6 >> token_value;
5154           demo_eps_roll_max_startTime = token_value;
5155           break;
5156         }
5157       case demo_eps_thrust_min_flag:
5158         {
5159           demo_eps_thrust_min = true;
5160           demo_eps_thrust_min_file = aircraft_directory + linetoken3;
5161           token4 >> token_value_convert1;
5162           token5 >> token_value_convert2;
5163           convert_y = uiuc_convert(token_value_convert1);
5164           convert_x = uiuc_convert(token_value_convert2);
5165           uiuc_1DdataFileReader(demo_eps_thrust_min_file,
5166                                 demo_eps_thrust_min_timeArray,
5167                                 demo_eps_thrust_min_daArray,
5168                                 demo_eps_thrust_min_ntime);
5169           token6 >> token_value;
5170           demo_eps_thrust_min_startTime = token_value;
5171           break;
5172         }
5173       case demo_eps_airspeed_max_flag:
5174         {
5175           demo_eps_airspeed_max = true;
5176           demo_eps_airspeed_max_file = aircraft_directory + linetoken3;
5177           token4 >> token_value_convert1;
5178           token5 >> token_value_convert2;
5179           convert_y = uiuc_convert(token_value_convert1);
5180           convert_x = uiuc_convert(token_value_convert2);
5181           uiuc_1DdataFileReader(demo_eps_airspeed_max_file,
5182                                 demo_eps_airspeed_max_timeArray,
5183                                 demo_eps_airspeed_max_daArray,
5184                                 demo_eps_airspeed_max_ntime);
5185           token6 >> token_value;
5186           demo_eps_airspeed_max_startTime = token_value;
5187           break;
5188         }
5189       case demo_eps_airspeed_min_flag:
5190         {
5191           demo_eps_airspeed_min = true;
5192           demo_eps_airspeed_min_file = aircraft_directory + linetoken3;
5193           token4 >> token_value_convert1;
5194           token5 >> token_value_convert2;
5195           convert_y = uiuc_convert(token_value_convert1);
5196           convert_x = uiuc_convert(token_value_convert2);
5197           uiuc_1DdataFileReader(demo_eps_airspeed_min_file,
5198                                 demo_eps_airspeed_min_timeArray,
5199                                 demo_eps_airspeed_min_daArray,
5200                                 demo_eps_airspeed_min_ntime);
5201           token6 >> token_value;
5202           demo_eps_airspeed_min_startTime = token_value;
5203           break;
5204         }
5205       case demo_eps_flap_max_flag:
5206         {
5207           demo_eps_flap_max = true;
5208           demo_eps_flap_max_file = aircraft_directory + linetoken3;
5209           token4 >> token_value_convert1;
5210           token5 >> token_value_convert2;
5211           convert_y = uiuc_convert(token_value_convert1);
5212           convert_x = uiuc_convert(token_value_convert2);
5213           uiuc_1DdataFileReader(demo_eps_flap_max_file,
5214                                 demo_eps_flap_max_timeArray,
5215                                 demo_eps_flap_max_daArray,
5216                                 demo_eps_flap_max_ntime);
5217           token6 >> token_value;
5218           demo_eps_flap_max_startTime = token_value;
5219           break;
5220         }
5221       case demo_boot_cycle_tail_flag:
5222         {
5223           demo_boot_cycle_tail = true;
5224           demo_boot_cycle_tail_file = aircraft_directory + linetoken3;
5225           token4 >> token_value_convert1;
5226           token5 >> token_value_convert2;
5227           convert_y = uiuc_convert(token_value_convert1);
5228           convert_x = uiuc_convert(token_value_convert2);
5229           uiuc_1DdataFileReader(demo_boot_cycle_tail_file,
5230                                 demo_boot_cycle_tail_timeArray,
5231                                 demo_boot_cycle_tail_daArray,
5232                                 demo_boot_cycle_tail_ntime);
5233           token6 >> token_value;
5234           demo_boot_cycle_tail_startTime = token_value;
5235           break;
5236         }
5237       case demo_boot_cycle_wing_left_flag:
5238         {
5239           demo_boot_cycle_wing_left = true;
5240           demo_boot_cycle_wing_left_file = aircraft_directory + linetoken3;
5241           token4 >> token_value_convert1;
5242           token5 >> token_value_convert2;
5243           convert_y = uiuc_convert(token_value_convert1);
5244           convert_x = uiuc_convert(token_value_convert2);
5245           uiuc_1DdataFileReader(demo_boot_cycle_wing_left_file,
5246                                 demo_boot_cycle_wing_left_timeArray,
5247                                 demo_boot_cycle_wing_left_daArray,
5248                                 demo_boot_cycle_wing_left_ntime);
5249           token6 >> token_value;
5250           demo_boot_cycle_wing_left_startTime = token_value;
5251           break;
5252         }
5253       case demo_boot_cycle_wing_right_flag:
5254         {
5255           demo_boot_cycle_wing_right = true;
5256           demo_boot_cycle_wing_right_file = aircraft_directory + linetoken3;
5257           token4 >> token_value_convert1;
5258           token5 >> token_value_convert2;
5259           convert_y = uiuc_convert(token_value_convert1);
5260           convert_x = uiuc_convert(token_value_convert2);
5261           uiuc_1DdataFileReader(demo_boot_cycle_wing_right_file,
5262                                 demo_boot_cycle_wing_right_timeArray,
5263                                 demo_boot_cycle_wing_right_daArray,
5264                                 demo_boot_cycle_wing_right_ntime);
5265           token6 >> token_value;
5266           demo_boot_cycle_wing_right_startTime = token_value;
5267           break;
5268         }
5269       case demo_eps_pitch_input_flag:
5270         {
5271           demo_eps_pitch_input = true;
5272           demo_eps_pitch_input_file = aircraft_directory + linetoken3;
5273           token4 >> token_value_convert1;
5274           token5 >> token_value_convert2;
5275           convert_y = uiuc_convert(token_value_convert1);
5276           convert_x = uiuc_convert(token_value_convert2);
5277           uiuc_1DdataFileReader(demo_eps_pitch_input_file,
5278                                 demo_eps_pitch_input_timeArray,
5279                                 demo_eps_pitch_input_daArray,
5280                                 demo_eps_pitch_input_ntime);
5281           token6 >> token_value;
5282           demo_eps_pitch_input_startTime = token_value;
5283           break;
5284         }
5285       case demo_ap_Theta_ref_deg_flag:
5286         {
5287           demo_ap_Theta_ref_deg = true;
5288           demo_ap_Theta_ref_deg_file = aircraft_directory + linetoken3;
5289           token4 >> token_value_convert1;
5290           token5 >> token_value_convert2;
5291           convert_y = uiuc_convert(token_value_convert1);
5292           convert_x = uiuc_convert(token_value_convert2);
5293           uiuc_1DdataFileReader(demo_ap_Theta_ref_deg_file,
5294                                 demo_ap_Theta_ref_deg_timeArray,
5295                                 demo_ap_Theta_ref_deg_daArray,
5296                                 demo_ap_Theta_ref_deg_ntime);
5297           token6 >> token_value;
5298           demo_ap_Theta_ref_deg_startTime = token_value;
5299           break;
5300         }
5301       case demo_ap_pah_on_flag:
5302         {
5303           demo_ap_pah_on = true;
5304           demo_ap_pah_on_file = aircraft_directory + linetoken3;
5305           token4 >> token_value_convert1;
5306           token5 >> token_value_convert2;
5307           convert_y = uiuc_convert(token_value_convert1);
5308           convert_x = uiuc_convert(token_value_convert2);
5309           uiuc_1DdataFileReader(demo_ap_pah_on_file,
5310                                 demo_ap_pah_on_timeArray,
5311                                 demo_ap_pah_on_daArray,
5312                                 demo_ap_pah_on_ntime);
5313           token6 >> token_value;
5314           demo_ap_pah_on_startTime = token_value;
5315           break;
5316         }
5317       case tactilefadef_flag:
5318         {
5319           int tactilefadef_index, i;
5320           string tactilefadef_file;
5321           double flap_value;
5322           tactilefadef = true;
5323           tactilefadef_file = aircraft_directory + linetoken3;
5324           token4 >> tactilefadef_index;
5325           if (tactilefadef_index < 0 || tactilefadef_index >= 30)
5326             uiuc_warnings_errors(1, *command_line);
5327           if (tactilefadef_index > tactilefadef_nf)
5328             tactilefadef_nf = tactilefadef_index;
5329           token5 >> flap_value;
5330           tactilefadef_fArray[tactilefadef_index] = flap_value;
5331           token6 >> token_value_convert1;
5332           token7 >> token_value_convert2;
5333           token8 >> token_value_convert3;
5334           token9 >> tactilefadef_nice;
5335           convert_z = uiuc_convert(token_value_convert1);
5336           convert_x = uiuc_convert(token_value_convert2);
5337           convert_y = uiuc_convert(token_value_convert3);
5338           /* call 2D File Reader with file name (tactilefadef_file) and
5339              conversion factors; function returns array of
5340              elevator deflections (deArray) and corresponding
5341              alpha (aArray) and delta CZ (CZArray) values and
5342              max number of terms in alpha arrays (nAlphaArray)
5343              and delfection array (nde) */
5344           uiuc_2DdataFileReader(tactilefadef_file,
5345                                 datafile_xArray,
5346                                 datafile_yArray,
5347                                 datafile_zArray,
5348                                 datafile_nxArray,
5349                                 datafile_ny);
5350           d_2_to_3(datafile_xArray, tactilefadef_aArray, tactilefadef_index);
5351           d_1_to_2(datafile_yArray, tactilefadef_deArray, tactilefadef_index);
5352           d_2_to_3(datafile_zArray, tactilefadef_tactileArray, tactilefadef_index);
5353           i_1_to_2(datafile_nxArray, tactilefadef_nAlphaArray, tactilefadef_index);
5354           tactilefadef_nde[tactilefadef_index] = datafile_ny;
5355           if (tactilefadef_first==true)
5356             {
5357               if (tactilefadef_nice == 1)
5358                 {
5359                   tactilefadef_na_nice = datafile_nxArray[1];
5360                   tactilefadef_nde_nice = datafile_ny;
5361                   d_1_to_1(datafile_yArray, tactilefadef_deArray_nice);
5362                   for (i=1; i<=tactilefadef_na_nice; i++)
5363                     tactilefadef_aArray_nice[i] = datafile_xArray[1][i];
5364                 }
5365               tactilefadef_first=false;
5366             }
5367           break;
5368         }
5369       case tactile_pitch_flag:
5370         {
5371           tactile_pitch = 1;
5372           break;
5373         }
5374       case demo_tactile_flag:
5375         {
5376           demo_tactile = true;
5377           demo_tactile_file = aircraft_directory + linetoken3;
5378           token4 >> token_value_convert1;
5379           token5 >> token_value_convert2;
5380           convert_y = uiuc_convert(token_value_convert1);
5381           convert_x = uiuc_convert(token_value_convert2);
5382           uiuc_1DdataFileReader(demo_tactile_file,
5383                                 demo_tactile_timeArray,
5384                                 demo_tactile_daArray,
5385                                 demo_tactile_ntime);
5386           token6 >> token_value;
5387           demo_tactile_startTime = token_value;
5388           break;
5389         }
5390       case demo_ice_tail_flag:
5391         {
5392           demo_ice_tail = true;
5393           demo_ice_tail_file = aircraft_directory + linetoken3;
5394           token4 >> token_value_convert1;
5395           token5 >> token_value_convert2;
5396           convert_y = uiuc_convert(token_value_convert1);
5397           convert_x = uiuc_convert(token_value_convert2);
5398           uiuc_1DdataFileReader(demo_ice_tail_file,
5399                                 demo_ice_tail_timeArray,
5400                                 demo_ice_tail_daArray,
5401                                 demo_ice_tail_ntime);
5402           token6 >> token_value;
5403           demo_ice_tail_startTime = token_value;
5404           break;
5405         }
5406       case demo_ice_left_flag:
5407         {
5408           demo_ice_left = true;
5409           demo_ice_left_file = aircraft_directory + linetoken3;
5410           token4 >> token_value_convert1;
5411           token5 >> token_value_convert2;
5412           convert_y = uiuc_convert(token_value_convert1);
5413           convert_x = uiuc_convert(token_value_convert2);
5414           uiuc_1DdataFileReader(demo_ice_left_file,
5415                                 demo_ice_left_timeArray,
5416                                 demo_ice_left_daArray,
5417                                 demo_ice_left_ntime);
5418           token6 >> token_value;
5419           demo_ice_left_startTime = token_value;
5420           break;
5421         }
5422       case demo_ice_right_flag:
5423         {
5424           demo_ice_right = true;
5425           demo_ice_right_file = aircraft_directory + linetoken3;
5426           token4 >> token_value_convert1;
5427           token5 >> token_value_convert2;
5428           convert_y = uiuc_convert(token_value_convert1);
5429           convert_x = uiuc_convert(token_value_convert2);
5430           uiuc_1DdataFileReader(demo_ice_right_file,
5431                                 demo_ice_right_timeArray,
5432                                 demo_ice_right_daArray,
5433                                 demo_ice_right_ntime);
5434           token6 >> token_value;
5435           demo_ice_right_startTime = token_value;
5436           break;
5437         }
5438       default:
5439         {
5440           if (dont_ignore)
5441             uiuc_warnings_errors(2, *command_line);
5442           break;
5443         }
5444       };
5445 }
5446
5447
5448 void parse_fog( const string& linetoken2, const string& linetoken3,
5449                 const string& linetoken4, LIST command_line ) {
5450   double token_value;
5451   int token_value_convert1;
5452   istrstream token3(linetoken3.c_str());
5453   istrstream token4(linetoken4.c_str());
5454
5455     switch(fog_map[linetoken2])
5456       {
5457       case fog_segments_flag:
5458         {
5459           if (check_float(linetoken3))
5460             token3 >> token_value_convert1;
5461           else
5462             uiuc_warnings_errors(1, *command_line);
5463
5464           if (token_value_convert1 < 1 || token_value_convert1 > 100)
5465             uiuc_warnings_errors(1, *command_line);
5466
5467           fog_field = true;
5468           fog_point_index = 0;
5469           delete[] fog_time;
5470           delete[] fog_value;
5471           fog_segments = token_value_convert1;
5472           fog_time = new double[fog_segments+1];
5473           fog_time[0] = 0.0;
5474           fog_value = new int[fog_segments+1];
5475           fog_value[0] = 0;
5476
5477           break;
5478         }
5479       case fog_point_flag:
5480         {
5481           if (check_float(linetoken3))
5482             token3 >> token_value;
5483           else
5484             uiuc_warnings_errors(1, *command_line);
5485
5486           if (token_value < 0.1)
5487             uiuc_warnings_errors(1, *command_line);
5488
5489           if (check_float(linetoken4))
5490             token4 >> token_value_convert1;
5491           else
5492             uiuc_warnings_errors(1, *command_line);
5493
5494           if (token_value_convert1 < -1000 || token_value_convert1 > 1000)
5495             uiuc_warnings_errors(1, *command_line);
5496
5497           if (fog_point_index == fog_segments || fog_point_index == -1)
5498             uiuc_warnings_errors(1, *command_line);
5499
5500           fog_point_index++;
5501           fog_time[fog_point_index] = token_value;
5502           fog_value[fog_point_index] = token_value_convert1;
5503
5504           break;
5505         }
5506       default:
5507         {
5508           if (dont_ignore)
5509             uiuc_warnings_errors(2, *command_line);
5510           break;
5511         }
5512       };
5513 }
5514
5515
5516 void parse_record( const string& linetoken2, LIST command_line ) {
5517
5518   switch(record_map[linetoken2])
5519     {
5520       /************************* Time ************************/
5521     case Simtime_record:
5522       {
5523         recordParts -> storeCommands (*command_line);
5524         break;
5525       }
5526     case dt_record:
5527       {
5528         recordParts -> storeCommands (*command_line);
5529         break;
5530       }
5531
5532       /************************* Mass ************************/
5533     case Weight_record:
5534       {
5535         recordParts -> storeCommands (*command_line);
5536         break;
5537       }
5538     case Mass_record:
5539       {
5540         recordParts -> storeCommands (*command_line);
5541         break;
5542       }
5543     case I_xx_record:
5544       {
5545         recordParts -> storeCommands (*command_line);
5546         break;
5547       }
5548     case I_yy_record:
5549       {
5550         recordParts -> storeCommands (*command_line);
5551         break;
5552       }
5553     case I_zz_record:
5554       {
5555         recordParts -> storeCommands (*command_line);
5556         break;
5557       }
5558     case I_xz_record:
5559       {
5560         recordParts -> storeCommands (*command_line);
5561         break;
5562       }
5563
5564       /*********************** Geometry **********************/
5565     case Dx_pilot_record:
5566       {
5567         recordParts -> storeCommands (*command_line);
5568         break;
5569       }
5570     case Dy_pilot_record:
5571       {
5572         recordParts -> storeCommands (*command_line);
5573         break;
5574       }
5575     case Dz_pilot_record:
5576       {
5577         recordParts -> storeCommands (*command_line);
5578         break;
5579       }
5580     case Dx_cg_record:
5581       {
5582         recordParts -> storeCommands (*command_line);
5583         break;
5584       }
5585     case Dy_cg_record:
5586       {
5587         recordParts -> storeCommands (*command_line);
5588         break;
5589       }
5590     case Dz_cg_record:
5591       {
5592         recordParts -> storeCommands (*command_line);
5593         break;
5594       }
5595
5596       /********************** Positions **********************/
5597     case Lat_geocentric_record:
5598       {
5599         recordParts -> storeCommands (*command_line);
5600         break;
5601       }
5602     case Lon_geocentric_record:
5603       {
5604         recordParts -> storeCommands (*command_line);
5605         break;
5606       }
5607     case Radius_to_vehicle_record:
5608       {
5609         recordParts -> storeCommands (*command_line);
5610         break;
5611       }
5612     case Latitude_record:
5613       {
5614         recordParts -> storeCommands (*command_line);
5615         break;
5616       }
5617     case Longitude_record:
5618       {
5619         recordParts -> storeCommands (*command_line);
5620         break;
5621       }
5622     case Altitude_record:
5623       {
5624         recordParts -> storeCommands (*command_line);
5625         break;
5626       }
5627     case Phi_record:
5628       {
5629         recordParts -> storeCommands (*command_line);
5630         break;
5631       }
5632     case Theta_record:
5633       {
5634         recordParts -> storeCommands (*command_line);
5635         break;
5636       }
5637     case Psi_record:
5638       {
5639         recordParts -> storeCommands (*command_line);
5640         break;
5641       }
5642
5643       /******************** Accelerations ********************/
5644     case V_dot_north_record:
5645       {
5646         recordParts -> storeCommands (*command_line);
5647         break;
5648       }
5649     case V_dot_east_record:
5650       {
5651         recordParts -> storeCommands (*command_line);
5652         break;
5653       }
5654     case V_dot_down_record:
5655       {
5656         recordParts -> storeCommands (*command_line);
5657         break;
5658       }
5659     case U_dot_body_record:
5660       {
5661         recordParts -> storeCommands (*command_line);
5662         break;
5663       }
5664     case V_dot_body_record:
5665       {
5666         recordParts -> storeCommands (*command_line);
5667         break;
5668       }
5669     case W_dot_body_record:
5670       {
5671         recordParts -> storeCommands (*command_line);
5672         break;
5673       }
5674     case A_X_pilot_record:
5675       {
5676         recordParts -> storeCommands (*command_line);
5677         break;
5678       }
5679     case A_Y_pilot_record:
5680       {
5681         recordParts -> storeCommands (*command_line);
5682         break;
5683       }
5684     case A_Z_pilot_record:
5685       {
5686         recordParts -> storeCommands (*command_line);
5687         break;
5688       }
5689     case A_X_cg_record:
5690       {
5691         recordParts -> storeCommands (*command_line);
5692         break;
5693       }
5694     case A_Y_cg_record:
5695       {
5696         recordParts -> storeCommands (*command_line);
5697         break;
5698       }
5699     case A_Z_cg_record:
5700       {
5701         recordParts -> storeCommands (*command_line);
5702         break;
5703       }
5704     case N_X_pilot_record:
5705       {
5706         recordParts -> storeCommands (*command_line);
5707         break;
5708       }
5709     case N_Y_pilot_record:
5710       {
5711         recordParts -> storeCommands (*command_line);
5712         break;
5713       }
5714     case N_Z_pilot_record:
5715       {
5716         recordParts -> storeCommands (*command_line);
5717         break;
5718       }
5719     case N_X_cg_record:
5720       {
5721         recordParts -> storeCommands (*command_line);
5722         break;
5723       }
5724     case N_Y_cg_record:
5725       {
5726         recordParts -> storeCommands (*command_line);
5727         break;
5728       }
5729     case N_Z_cg_record:
5730       {
5731         recordParts -> storeCommands (*command_line);
5732         break;
5733       }
5734     case P_dot_body_record:
5735       {
5736         recordParts -> storeCommands (*command_line);
5737         break;
5738       }
5739     case Q_dot_body_record:
5740       {
5741         recordParts -> storeCommands (*command_line);
5742         break;
5743       }
5744     case R_dot_body_record:
5745       {
5746         recordParts -> storeCommands (*command_line);
5747         break;
5748       }
5749
5750       /********************** Velocities *********************/
5751     case V_north_record:
5752       {
5753         recordParts -> storeCommands (*command_line);
5754         break;
5755       }
5756     case V_east_record:
5757       {
5758         recordParts -> storeCommands (*command_line);
5759         break;
5760       }
5761     case V_down_record:
5762       {
5763         recordParts -> storeCommands (*command_line);
5764         break;
5765       }
5766     case V_north_rel_ground_record:
5767       {
5768         recordParts -> storeCommands (*command_line);
5769         break;
5770       }
5771     case V_east_rel_ground_record:
5772       {
5773         recordParts -> storeCommands (*command_line);
5774         break;
5775       }
5776     case V_down_rel_ground_record:
5777       {
5778         recordParts -> storeCommands (*command_line);
5779         break;
5780       }
5781     case V_north_airmass_record:
5782       {
5783         recordParts -> storeCommands (*command_line);
5784         break;
5785       }
5786     case V_east_airmass_record:
5787       {
5788         recordParts -> storeCommands (*command_line);
5789         break;
5790       }
5791     case V_down_airmass_record:
5792       {
5793         recordParts -> storeCommands (*command_line);
5794         break;
5795       }
5796     case V_north_rel_airmass_record:
5797       {
5798         recordParts -> storeCommands (*command_line);
5799         break;
5800       }
5801     case V_east_rel_airmass_record:
5802       {
5803         recordParts -> storeCommands (*command_line);
5804         break;
5805       }
5806     case V_down_rel_airmass_record:
5807       {
5808         recordParts -> storeCommands (*command_line);
5809         break;
5810       }
5811     case U_gust_record:
5812       {
5813         recordParts -> storeCommands (*command_line);
5814         break;
5815       }
5816     case V_gust_record:
5817       {
5818         recordParts -> storeCommands (*command_line);
5819         break;
5820       }
5821     case W_gust_record:
5822       {
5823         recordParts -> storeCommands (*command_line);
5824         break;
5825       }
5826     case U_body_record:
5827       {
5828         recordParts -> storeCommands (*command_line);
5829         break;
5830       }
5831     case V_body_record:
5832       {
5833         recordParts -> storeCommands (*command_line);
5834         break;
5835       }
5836     case W_body_record:
5837       {
5838         recordParts -> storeCommands (*command_line);
5839         break;
5840       }
5841     case V_rel_wind_record:
5842       {
5843         recordParts -> storeCommands (*command_line);
5844         break;
5845       }
5846     case V_true_kts_record:
5847       {
5848         recordParts -> storeCommands (*command_line);
5849         break;
5850       }
5851     case V_rel_ground_record:
5852       {
5853         recordParts -> storeCommands (*command_line);
5854         break;
5855       }
5856     case V_inertial_record:
5857       {
5858         recordParts -> storeCommands (*command_line);
5859         break;
5860       }
5861     case V_ground_speed_record:
5862       {
5863         recordParts -> storeCommands (*command_line);
5864         break;
5865       }
5866     case V_equiv_record:
5867       {
5868         recordParts -> storeCommands (*command_line);
5869         break;
5870       }
5871     case V_equiv_kts_record:
5872       {
5873         recordParts -> storeCommands (*command_line);
5874         break;
5875       }
5876     case V_calibrated_record:
5877       {
5878         recordParts -> storeCommands (*command_line);
5879         break;
5880       }
5881     case V_calibrated_kts_record:
5882       {
5883         recordParts -> storeCommands (*command_line);
5884         break;
5885       }
5886     case P_local_record:
5887       {
5888         recordParts -> storeCommands (*command_line);
5889         break;
5890       }
5891     case Q_local_record:
5892       {
5893         recordParts -> storeCommands (*command_line);
5894         break;
5895       }
5896     case R_local_record:
5897       {
5898         recordParts -> storeCommands (*command_line);
5899         break;
5900       }
5901     case P_body_record:
5902       {
5903         recordParts -> storeCommands (*command_line);
5904         break;
5905       }
5906     case Q_body_record:
5907       {
5908         recordParts -> storeCommands (*command_line);
5909         break;
5910       }
5911     case R_body_record:
5912       {
5913         recordParts -> storeCommands (*command_line);
5914         break;
5915       }
5916     case P_total_record:
5917       {
5918         recordParts -> storeCommands (*command_line);
5919         break;
5920       }
5921     case Q_total_record:
5922       {
5923         recordParts -> storeCommands (*command_line);
5924         break;
5925       }
5926     case R_total_record:
5927       {
5928         recordParts -> storeCommands (*command_line);
5929         break;
5930       }
5931     case Phi_dot_record:
5932       {
5933         recordParts -> storeCommands (*command_line);
5934         break;
5935       }
5936     case Theta_dot_record:
5937       {
5938         recordParts -> storeCommands (*command_line);
5939         break;
5940       }
5941     case Psi_dot_record:
5942       {
5943         recordParts -> storeCommands (*command_line);
5944         break;
5945       }
5946     case Latitude_dot_record:
5947       {
5948         recordParts -> storeCommands (*command_line);
5949         break;
5950       }
5951     case Longitude_dot_record:
5952       {
5953         recordParts -> storeCommands (*command_line);
5954         break;
5955       }
5956     case Radius_dot_record:
5957       {
5958         recordParts -> storeCommands (*command_line);
5959         break;
5960       }
5961
5962       /************************ Angles ***********************/
5963     case Alpha_record:
5964       {
5965         recordParts -> storeCommands (*command_line);
5966         break;
5967       }
5968     case Alpha_deg_record:
5969       {
5970         recordParts -> storeCommands (*command_line);
5971         break;
5972       }
5973     case Alpha_dot_record:
5974       {
5975         recordParts -> storeCommands (*command_line);
5976         break;
5977       }
5978     case Alpha_dot_deg_record:
5979       {
5980         recordParts -> storeCommands (*command_line);
5981         break;
5982       }
5983     case Beta_record:
5984       {
5985         recordParts -> storeCommands (*command_line);
5986         break;
5987       }
5988     case Beta_deg_record:
5989       {
5990         recordParts -> storeCommands (*command_line);
5991         break;
5992       }
5993     case Beta_dot_record:
5994       {
5995         recordParts -> storeCommands (*command_line);
5996         break;
5997       }
5998     case Beta_dot_deg_record:
5999       {
6000         recordParts -> storeCommands (*command_line);
6001         break;
6002       }
6003     case Gamma_vert_record:
6004       {
6005         recordParts -> storeCommands (*command_line);
6006         break;
6007       }
6008     case Gamma_vert_deg_record:
6009       {
6010         recordParts -> storeCommands (*command_line);
6011         break;
6012       }
6013     case Gamma_horiz_record:
6014       {
6015         recordParts -> storeCommands (*command_line);
6016         break;
6017       }
6018     case Gamma_horiz_deg_record:
6019       {
6020         recordParts -> storeCommands (*command_line);
6021         break;
6022       }
6023
6024       /**************** Atmospheric Properties ***************/
6025     case Density_record:
6026       {
6027         recordParts -> storeCommands (*command_line);
6028         break;
6029       }
6030     case V_sound_record:
6031       {
6032         recordParts -> storeCommands (*command_line);
6033         break;
6034       }
6035     case Mach_number_record:
6036       {
6037         recordParts -> storeCommands (*command_line);
6038         break;
6039       }
6040     case Static_pressure_record:
6041       {
6042         recordParts -> storeCommands (*command_line);
6043         break;
6044       }
6045     case Total_pressure_record:
6046       {
6047         recordParts -> storeCommands (*command_line);
6048         break;
6049       }
6050     case Impact_pressure_record:
6051       {
6052         recordParts -> storeCommands (*command_line);
6053         break;
6054       }
6055     case Dynamic_pressure_record:
6056       {
6057         recordParts -> storeCommands (*command_line);
6058         break;
6059       }
6060     case Static_temperature_record:
6061       {
6062         recordParts -> storeCommands (*command_line);
6063         break;
6064       }
6065     case Total_temperature_record:
6066       {
6067         recordParts -> storeCommands (*command_line);
6068         break;
6069       }
6070
6071       /******************** Earth Properties *****************/
6072     case Gravity_record:
6073       {
6074         recordParts -> storeCommands (*command_line);
6075         break;
6076       }
6077     case Sea_level_radius_record:
6078       {
6079         recordParts -> storeCommands (*command_line);
6080         break;
6081       }
6082     case Earth_position_angle_record:
6083       {
6084         recordParts -> storeCommands (*command_line);
6085         break;
6086       }
6087     case Runway_altitude_record:
6088       {
6089         recordParts -> storeCommands (*command_line);
6090         break;
6091       }
6092     case Runway_latitude_record:
6093       {
6094         recordParts -> storeCommands (*command_line);
6095         break;
6096       }
6097     case Runway_longitude_record:
6098       {
6099         recordParts -> storeCommands (*command_line);
6100         break;
6101       }
6102     case Runway_heading_record:
6103       {
6104         recordParts -> storeCommands (*command_line);
6105         break;
6106       }
6107     case Radius_to_rwy_record:
6108       {
6109         recordParts -> storeCommands (*command_line);
6110         break;
6111       }
6112     case D_pilot_north_of_rwy_record:
6113       {
6114         recordParts -> storeCommands (*command_line);
6115         break;
6116       }
6117     case D_pilot_east_of_rwy_record:
6118       {
6119         recordParts -> storeCommands (*command_line);
6120         break;
6121       }
6122     case D_pilot_above_rwy_record:
6123                 {
6124                   recordParts -> storeCommands (*command_line);
6125                   break;
6126                 }
6127     case X_pilot_rwy_record:
6128       {
6129         recordParts -> storeCommands (*command_line);
6130         break;
6131       }
6132     case Y_pilot_rwy_record:
6133       {
6134         recordParts -> storeCommands (*command_line);
6135         break;
6136       }
6137     case H_pilot_rwy_record:
6138       {
6139         recordParts -> storeCommands (*command_line);
6140         break;
6141       }
6142     case D_cg_north_of_rwy_record:
6143       {
6144         recordParts -> storeCommands (*command_line);
6145         break;
6146       }
6147     case D_cg_east_of_rwy_record:
6148       {
6149         recordParts -> storeCommands (*command_line);
6150         break;
6151       }
6152     case D_cg_above_rwy_record:
6153       {
6154         recordParts -> storeCommands (*command_line);
6155         break;
6156       }
6157     case X_cg_rwy_record:
6158       {
6159         recordParts -> storeCommands (*command_line);
6160         break;
6161       }
6162     case Y_cg_rwy_record:
6163       {
6164         recordParts -> storeCommands (*command_line);
6165         break;
6166       }
6167     case H_cg_rwy_record:
6168       {
6169         recordParts -> storeCommands (*command_line);
6170         break;
6171       }
6172
6173       /********************* Engine Inputs *******************/
6174     case Throttle_pct_record:
6175       {
6176         recordParts -> storeCommands (*command_line);
6177         break;
6178       }
6179     case Throttle_3_record:
6180       {
6181         recordParts -> storeCommands (*command_line);
6182         break;
6183       }
6184
6185       /******************** Control Inputs *******************/
6186     case Long_control_record:
6187       {
6188         recordParts -> storeCommands (*command_line);
6189         break;
6190       }
6191     case Long_trim_record:
6192       {
6193         recordParts -> storeCommands (*command_line);
6194         break;
6195       }
6196     case Long_trim_deg_record:
6197       {
6198         recordParts -> storeCommands (*command_line);
6199         break;
6200       }
6201     case elevator_record:
6202       {
6203         recordParts -> storeCommands (*command_line);
6204         break;
6205       }
6206     case elevator_deg_record:
6207       {
6208         recordParts -> storeCommands (*command_line);
6209         break;
6210       }
6211     case Lat_control_record:
6212       {
6213         recordParts -> storeCommands (*command_line);
6214         break;
6215       }
6216     case aileron_record:
6217       {
6218         recordParts -> storeCommands (*command_line);
6219         break;
6220       }
6221     case aileron_deg_record:
6222       {
6223         recordParts -> storeCommands (*command_line);
6224         break;
6225       }
6226     case Rudder_pedal_record:
6227       {
6228         recordParts -> storeCommands (*command_line);
6229         break;
6230       }
6231     case rudder_record:
6232       {
6233         recordParts -> storeCommands (*command_line);
6234         break;
6235       }
6236     case rudder_deg_record:
6237       {
6238         recordParts -> storeCommands (*command_line);
6239         break;
6240       }
6241     case Flap_handle_record:
6242       {
6243         recordParts -> storeCommands (*command_line);
6244         break;
6245       }
6246     case flap_record:
6247       {
6248         recordParts -> storeCommands (*command_line);
6249         break;
6250       }
6251     case flap_deg_record:
6252       {
6253         recordParts -> storeCommands (*command_line);
6254         break;
6255       }
6256     case flap_goal_record:
6257       {
6258         recordParts -> storeCommands (*command_line);
6259         break;
6260       }
6261     case flap_pos_record:
6262       {
6263         recordParts -> storeCommands (*command_line);
6264         break;
6265       }
6266
6267       /****************** Aero Coefficients ******************/
6268     case CD_record:
6269       {
6270         recordParts -> storeCommands (*command_line);
6271         break;
6272       }
6273     case CDfaI_record:
6274       {
6275         recordParts -> storeCommands (*command_line);
6276         break;
6277       }
6278     case CDfadeI_record:
6279       {
6280         recordParts -> storeCommands (*command_line);
6281         break;
6282       }
6283     case CDfdfI_record:
6284       {
6285         recordParts -> storeCommands (*command_line);
6286         break;
6287       }
6288     case CDfadfI_record:
6289       {
6290         recordParts -> storeCommands (*command_line);
6291         break;
6292       }
6293     case CX_record:
6294       {
6295         recordParts -> storeCommands (*command_line);
6296         break;
6297       }
6298     case CXfabetafI_record:
6299       {
6300         recordParts -> storeCommands (*command_line);
6301         break;
6302       }
6303     case CXfadefI_record:
6304       {
6305         recordParts -> storeCommands (*command_line);
6306         break;
6307       }
6308     case CXfaqfI_record:
6309       {
6310         recordParts -> storeCommands (*command_line);
6311         break;
6312       }
6313     case CDo_save_record:
6314       {
6315         recordParts -> storeCommands (*command_line);
6316         break;
6317       }
6318     case CDK_save_record:
6319       {
6320         recordParts -> storeCommands (*command_line);
6321         break;
6322       }
6323     case CD_a_save_record:
6324       {
6325         recordParts -> storeCommands (*command_line);
6326         break;
6327       }
6328     case CD_adot_save_record:
6329       {
6330         recordParts -> storeCommands (*command_line);
6331         break;
6332       }
6333     case CD_q_save_record:
6334       {
6335         recordParts -> storeCommands (*command_line);
6336         break;
6337       }
6338     case CD_ih_save_record:
6339       {
6340         recordParts -> storeCommands (*command_line);
6341         break;
6342       }
6343     case CD_de_save_record:
6344       {
6345         recordParts -> storeCommands (*command_line);
6346         break;
6347       }
6348     case CXo_save_record:
6349       {
6350         recordParts -> storeCommands (*command_line);
6351         break;
6352       }
6353     case CXK_save_record:
6354       {
6355         recordParts -> storeCommands (*command_line);
6356         break;
6357       }
6358     case CX_a_save_record:
6359       {
6360         recordParts -> storeCommands (*command_line);
6361         break;
6362       }
6363     case CX_a2_save_record:
6364       {
6365         recordParts -> storeCommands (*command_line);
6366         break;
6367       }
6368     case CX_a3_save_record:
6369       {
6370         recordParts -> storeCommands (*command_line);
6371         break;
6372       }
6373     case CX_adot_save_record:
6374       {
6375         recordParts -> storeCommands (*command_line);
6376         break;
6377       }
6378     case CX_q_save_record:
6379       {
6380         recordParts -> storeCommands (*command_line);
6381         break;
6382       }
6383     case CX_de_save_record:
6384       {
6385         recordParts -> storeCommands (*command_line);
6386         break;
6387       }
6388     case CX_dr_save_record:
6389       {
6390         recordParts -> storeCommands (*command_line);
6391         break;
6392       }
6393     case CX_df_save_record:
6394       {
6395         recordParts -> storeCommands (*command_line);
6396         break;
6397       }
6398     case CX_adf_save_record:
6399       {
6400         recordParts -> storeCommands (*command_line);
6401         break;
6402       }
6403     case CL_record:
6404       {
6405         recordParts -> storeCommands (*command_line);
6406         break;
6407       }
6408     case CLfaI_record:
6409       {
6410         recordParts -> storeCommands (*command_line);
6411         break;
6412       }
6413     case CLfadeI_record:
6414       {
6415         recordParts -> storeCommands (*command_line);
6416         break;
6417       }
6418     case CLfdfI_record:
6419       {
6420         recordParts -> storeCommands (*command_line);
6421         break;
6422       }
6423     case CLfadfI_record:
6424       {
6425         recordParts -> storeCommands (*command_line);
6426         break;
6427       }
6428     case CZ_record:
6429       {
6430         recordParts -> storeCommands (*command_line);
6431         break;
6432       }
6433     case CZfaI_record:
6434       {
6435         recordParts -> storeCommands (*command_line);
6436         break;
6437       }
6438     case CZfabetafI_record:
6439       {
6440         recordParts -> storeCommands (*command_line);
6441         break;
6442       }
6443     case CZfadefI_record:
6444       {
6445         recordParts -> storeCommands (*command_line);
6446         break;
6447       }
6448     case CZfaqfI_record:
6449       {
6450         recordParts -> storeCommands (*command_line);
6451         break;
6452       }
6453     case CLo_save_record:
6454       {
6455         recordParts -> storeCommands (*command_line);
6456         break;
6457       }
6458     case CL_a_save_record:
6459       {
6460         recordParts -> storeCommands (*command_line);
6461         break;
6462       }
6463     case CL_adot_save_record:
6464       {
6465         recordParts -> storeCommands (*command_line);
6466         break;
6467       }
6468     case CL_q_save_record:
6469       {
6470         recordParts -> storeCommands (*command_line);
6471         break;
6472       }
6473     case CL_ih_save_record:
6474       {
6475         recordParts -> storeCommands (*command_line);
6476         break;
6477       }
6478     case CL_de_save_record:
6479       {
6480         recordParts -> storeCommands (*command_line);
6481         break;
6482       }
6483     case CZo_save_record:
6484       {
6485         recordParts -> storeCommands (*command_line);
6486         break;
6487       }
6488     case CZ_a_save_record:
6489       {
6490         recordParts -> storeCommands (*command_line);
6491         break;
6492       }
6493     case CZ_a2_save_record:
6494       {
6495         recordParts -> storeCommands (*command_line);
6496         break;
6497       }
6498     case CZ_a3_save_record:
6499       {
6500         recordParts -> storeCommands (*command_line);
6501         break;
6502       }
6503     case CZ_adot_save_record:
6504       {
6505         recordParts -> storeCommands (*command_line);
6506         break;
6507       }
6508     case CZ_q_save_record:
6509       {
6510         recordParts -> storeCommands (*command_line);
6511         break;
6512       }
6513     case CZ_de_save_record:
6514       {
6515         recordParts -> storeCommands (*command_line);
6516         break;
6517       }
6518     case CZ_deb2_save_record:
6519       {
6520         recordParts -> storeCommands (*command_line);
6521         break;
6522       }
6523     case CZ_df_save_record:
6524       {
6525         recordParts -> storeCommands (*command_line);
6526         break;
6527       }
6528     case CZ_adf_save_record:
6529       {
6530         recordParts -> storeCommands (*command_line);
6531         break;
6532       }
6533     case Cm_record:
6534       {
6535         recordParts -> storeCommands (*command_line);
6536         break;
6537       }
6538     case CmfaI_record:
6539       {
6540         recordParts -> storeCommands (*command_line);
6541         break;
6542       }
6543     case CmfadeI_record:
6544       {
6545         recordParts -> storeCommands (*command_line);
6546         break;
6547       }
6548     case CmfdfI_record:
6549       {
6550         recordParts -> storeCommands (*command_line);
6551         break;
6552       }
6553     case CmfadfI_record:
6554       {
6555         recordParts -> storeCommands (*command_line);
6556         break;
6557       }
6558     case CmfabetafI_record:
6559       {
6560         recordParts -> storeCommands (*command_line);
6561         break;
6562       }
6563     case CmfadefI_record:
6564       {
6565         recordParts -> storeCommands (*command_line);
6566         break;
6567       }
6568     case CmfaqfI_record:
6569       {
6570         recordParts -> storeCommands (*command_line);
6571         break;
6572       }
6573     case Cmo_save_record:
6574       {
6575         recordParts -> storeCommands (*command_line);
6576         break;
6577       }
6578     case Cm_a_save_record:
6579       {
6580         recordParts -> storeCommands (*command_line);
6581         break;
6582       }
6583     case Cm_a2_save_record:
6584       {
6585         recordParts -> storeCommands (*command_line);
6586         break;
6587       }
6588     case Cm_adot_save_record:
6589       {
6590         recordParts -> storeCommands (*command_line);
6591         break;
6592       }
6593     case Cm_q_save_record:
6594       {
6595         recordParts -> storeCommands (*command_line);
6596         break;
6597       }
6598     case Cm_ih_save_record:
6599       {
6600         recordParts -> storeCommands (*command_line);
6601         break;
6602       }
6603     case Cm_de_save_record:
6604       {
6605         recordParts -> storeCommands (*command_line);
6606         break;
6607       }
6608     case Cm_b2_save_record:
6609       {
6610         recordParts -> storeCommands (*command_line);
6611         break;
6612       }
6613     case Cm_r_save_record:
6614       {
6615         recordParts -> storeCommands (*command_line);
6616         break;
6617       }
6618     case Cm_df_save_record:
6619       {
6620         recordParts -> storeCommands (*command_line);
6621         break;
6622       }
6623     case CY_record:
6624       {
6625         recordParts -> storeCommands (*command_line);
6626         break;
6627       }
6628     case CYfadaI_record:
6629       {
6630         recordParts -> storeCommands (*command_line);
6631         break;
6632       }
6633     case CYfbetadrI_record:
6634       {
6635         recordParts -> storeCommands (*command_line);
6636         break;
6637       }
6638     case CYfabetafI_record:
6639       {
6640         recordParts -> storeCommands (*command_line);
6641         break;
6642       }
6643     case CYfadafI_record:
6644       {
6645         recordParts -> storeCommands (*command_line);
6646         break;
6647       }
6648     case CYfadrfI_record:
6649       {
6650         recordParts -> storeCommands (*command_line);
6651         break;
6652       }
6653     case CYfapfI_record:
6654       {
6655         recordParts -> storeCommands (*command_line);
6656         break;
6657       }
6658     case CYfarfI_record:
6659       {
6660         recordParts -> storeCommands (*command_line);
6661         break;
6662       }
6663     case CYo_save_record:
6664       {
6665         recordParts -> storeCommands (*command_line);
6666         break;
6667       }
6668     case CY_beta_save_record:
6669       {
6670         recordParts -> storeCommands (*command_line);
6671         break;
6672       }
6673     case CY_p_save_record:
6674       {
6675         recordParts -> storeCommands (*command_line);
6676         break;
6677       }
6678     case CY_r_save_record:
6679       {
6680         recordParts -> storeCommands (*command_line);
6681         break;
6682       }
6683     case CY_da_save_record:
6684       {
6685         recordParts -> storeCommands (*command_line);
6686         break;
6687       }
6688     case CY_dr_save_record:
6689       {
6690         recordParts -> storeCommands (*command_line);
6691         break;
6692       }
6693     case CY_dra_save_record:
6694       {
6695         recordParts -> storeCommands (*command_line);
6696         break;
6697       }
6698     case CY_bdot_save_record:
6699       {
6700         recordParts -> storeCommands (*command_line);
6701         break;
6702       }
6703     case Cl_record:
6704       {
6705         recordParts -> storeCommands (*command_line);
6706         break;
6707       }
6708     case ClfadaI_record:
6709       {
6710         recordParts -> storeCommands (*command_line);
6711         break;
6712       }
6713     case ClfbetadrI_record:
6714       {
6715         recordParts -> storeCommands (*command_line);
6716         break;
6717       }
6718     case ClfabetafI_record:
6719       {
6720         recordParts -> storeCommands (*command_line);
6721         break;
6722       }
6723     case ClfadafI_record:
6724       {
6725         recordParts -> storeCommands (*command_line);
6726         break;
6727       }
6728     case ClfadrfI_record:
6729       {
6730         recordParts -> storeCommands (*command_line);
6731         break;
6732       }
6733     case ClfapfI_record:
6734       {
6735         recordParts -> storeCommands (*command_line);
6736         break;
6737       }
6738     case ClfarfI_record:
6739       {
6740         recordParts -> storeCommands (*command_line);
6741         break;
6742       }
6743     case Clo_save_record:
6744       {
6745         recordParts -> storeCommands (*command_line);
6746         break;
6747       }
6748     case Cl_beta_save_record:
6749       {
6750         recordParts -> storeCommands (*command_line);
6751         break;
6752       }
6753     case Cl_p_save_record:
6754       {
6755         recordParts -> storeCommands (*command_line);
6756         break;
6757       }
6758     case Cl_r_save_record:
6759       {
6760         recordParts -> storeCommands (*command_line);
6761         break;
6762       }
6763     case Cl_da_save_record:
6764       {
6765         recordParts -> storeCommands (*command_line);
6766         break;
6767       }
6768     case Cl_dr_save_record:
6769       {
6770         recordParts -> storeCommands (*command_line);
6771         break;
6772       }
6773     case Cl_daa_save_record:
6774       {
6775         recordParts -> storeCommands (*command_line);
6776         break;
6777       }
6778     case Cn_record:
6779       {
6780         recordParts -> storeCommands (*command_line);
6781         break;
6782       }
6783     case CnfadaI_record:
6784       {
6785         recordParts -> storeCommands (*command_line);
6786         break;
6787       }
6788     case CnfbetadrI_record:
6789       {
6790         recordParts -> storeCommands (*command_line);
6791         break;
6792       }
6793     case CnfabetafI_record:
6794       {
6795         recordParts -> storeCommands (*command_line);
6796         break;
6797       }
6798     case CnfadafI_record:
6799       {
6800         recordParts -> storeCommands (*command_line);
6801         break;
6802       }
6803     case CnfadrfI_record:
6804       {
6805         recordParts -> storeCommands (*command_line);
6806         break;
6807       }
6808     case CnfapfI_record:
6809       {
6810         recordParts -> storeCommands (*command_line);
6811         break;
6812       }
6813     case CnfarfI_record:
6814       {
6815         recordParts -> storeCommands (*command_line);
6816         break;
6817       }
6818     case Cno_save_record:
6819       {
6820         recordParts -> storeCommands (*command_line);
6821         break;
6822       }
6823     case Cn_beta_save_record:
6824       {
6825         recordParts -> storeCommands (*command_line);
6826         break;
6827       }
6828     case Cn_p_save_record:
6829       {
6830         recordParts -> storeCommands (*command_line);
6831         break;
6832       }
6833     case Cn_r_save_record:
6834       {
6835         recordParts -> storeCommands (*command_line);
6836         break;
6837       }
6838     case Cn_da_save_record:
6839       {
6840         recordParts -> storeCommands (*command_line);
6841         break;
6842       }
6843     case Cn_dr_save_record:
6844       {
6845         recordParts -> storeCommands (*command_line);
6846         break;
6847       }
6848     case Cn_q_save_record:
6849       {
6850         recordParts -> storeCommands (*command_line);
6851         break;
6852       }
6853     case Cn_b3_save_record:
6854       {
6855         recordParts -> storeCommands (*command_line);
6856         break;
6857       }
6858
6859       /******************** Ice Detection ********************/
6860     case CL_clean_record:
6861       {
6862         recordParts -> storeCommands (*command_line);
6863         break;
6864       }
6865     case CL_iced_record:
6866       {
6867         recordParts -> storeCommands (*command_line);
6868         break;
6869       }
6870     case CD_clean_record:
6871       {
6872         recordParts -> storeCommands (*command_line);
6873         break;
6874       }
6875     case CD_iced_record:
6876       {
6877         recordParts -> storeCommands (*command_line);
6878         break;
6879       }
6880     case Cm_clean_record:
6881       {
6882         recordParts -> storeCommands (*command_line);
6883         break;
6884       }
6885     case Cm_iced_record:
6886       {
6887         recordParts -> storeCommands (*command_line);
6888         break;
6889       }
6890     case Ch_clean_record:
6891       {
6892         recordParts -> storeCommands (*command_line);
6893         break;
6894       }
6895     case Ch_iced_record:
6896       {
6897         recordParts -> storeCommands (*command_line);
6898         break;
6899       }
6900     case Cl_clean_record:
6901       {
6902         recordParts -> storeCommands (*command_line);
6903         break;
6904       }
6905     case Cl_iced_record:
6906       {
6907         recordParts -> storeCommands (*command_line);
6908         break;
6909       }
6910     case CLclean_wing_record:
6911       {
6912         recordParts -> storeCommands (*command_line);
6913         break;
6914       }
6915     case CLiced_wing_record:
6916       {
6917         recordParts -> storeCommands (*command_line);
6918         break;
6919       }
6920     case CLclean_tail_record:
6921       {
6922         recordParts -> storeCommands (*command_line);
6923         break;
6924       }
6925     case CLiced_tail_record:
6926       {
6927         recordParts -> storeCommands (*command_line);
6928         break;
6929       }
6930     case Lift_clean_wing_record:
6931       {
6932         recordParts -> storeCommands (*command_line);
6933         break;
6934       }
6935     case Lift_iced_wing_record:
6936       {
6937         recordParts -> storeCommands (*command_line);
6938         break;
6939       }
6940     case Lift_clean_tail_record:
6941       {
6942         recordParts -> storeCommands (*command_line);
6943         break;
6944       }
6945     case Lift_iced_tail_record:
6946       {
6947         recordParts -> storeCommands (*command_line);
6948         break;
6949       }
6950     case Gamma_clean_wing_record:
6951       {
6952         recordParts -> storeCommands (*command_line);
6953         break;
6954       }
6955     case Gamma_iced_wing_record:
6956       {
6957         recordParts -> storeCommands (*command_line);
6958         break;
6959       }
6960     case Gamma_clean_tail_record:
6961       {
6962         recordParts -> storeCommands (*command_line);
6963         break;
6964       }
6965     case Gamma_iced_tail_record:
6966       {
6967         recordParts -> storeCommands (*command_line);
6968         break;
6969       }
6970     case w_clean_wing_record:
6971       {
6972         recordParts -> storeCommands (*command_line);
6973         break;
6974       }
6975     case w_iced_wing_record:
6976       {
6977         recordParts -> storeCommands (*command_line);
6978         break;
6979       }
6980     case w_clean_tail_record:
6981       {
6982         recordParts -> storeCommands (*command_line);
6983         break;
6984       }
6985     case w_iced_tail_record:
6986       {
6987         recordParts -> storeCommands (*command_line);
6988         break;
6989       }
6990     case V_total_clean_wing_record:
6991       {
6992         recordParts -> storeCommands (*command_line);
6993         break;
6994       }
6995     case V_total_iced_wing_record:
6996       {
6997         recordParts -> storeCommands (*command_line);
6998         break;
6999       }
7000     case V_total_clean_tail_record:
7001       {
7002         recordParts -> storeCommands (*command_line);
7003         break;
7004       }
7005     case V_total_iced_tail_record:
7006       {
7007         recordParts -> storeCommands (*command_line);
7008         break;
7009       }
7010     case beta_flow_clean_wing_record:
7011       {
7012         recordParts -> storeCommands (*command_line);
7013         break;
7014       }
7015     case beta_flow_clean_wing_deg_record:
7016       {
7017         recordParts -> storeCommands (*command_line);
7018         break;
7019       }
7020     case beta_flow_iced_wing_record:
7021       {
7022         recordParts -> storeCommands (*command_line);
7023         break;
7024       }
7025     case beta_flow_iced_wing_deg_record:
7026       {
7027         recordParts -> storeCommands (*command_line);
7028         break;
7029       }
7030     case beta_flow_clean_tail_record:
7031       {
7032         recordParts -> storeCommands (*command_line);
7033         break;
7034       }
7035     case beta_flow_clean_tail_deg_record:
7036       {
7037         recordParts -> storeCommands (*command_line);
7038         break;
7039       }
7040     case beta_flow_iced_tail_record:
7041       {
7042         recordParts -> storeCommands (*command_line);
7043         break;
7044       }
7045     case beta_flow_iced_tail_deg_record:
7046       {
7047         recordParts -> storeCommands (*command_line);
7048         break;
7049       }
7050     case Dbeta_flow_wing_record:
7051       {
7052         recordParts -> storeCommands (*command_line);
7053         break;
7054       }
7055     case Dbeta_flow_wing_deg_record:
7056       {
7057         recordParts -> storeCommands (*command_line);
7058         break;
7059       }
7060     case Dbeta_flow_tail_record:
7061       {
7062         recordParts -> storeCommands (*command_line);
7063         break;
7064       }
7065     case Dbeta_flow_tail_deg_record:
7066       {
7067         recordParts -> storeCommands (*command_line);
7068         break;
7069       }
7070     case pct_beta_flow_wing_record:
7071       {
7072         recordParts -> storeCommands (*command_line);
7073         break;
7074       }
7075     case pct_beta_flow_tail_record:
7076       {
7077         recordParts -> storeCommands (*command_line);
7078         break;
7079       }
7080     case eta_ice_record:
7081       {
7082         recordParts -> storeCommands (*command_line);
7083         break;
7084       }
7085     case eta_wing_left_record:
7086       {
7087         recordParts -> storeCommands (*command_line);
7088         break;
7089       }
7090     case eta_wing_right_record:
7091       {
7092         recordParts -> storeCommands (*command_line);
7093         break;
7094       }
7095     case eta_tail_record:
7096       {
7097         recordParts -> storeCommands (*command_line);
7098         break;
7099       }
7100     case delta_CL_record:
7101       {
7102         recordParts -> storeCommands (*command_line);
7103         break;
7104       }
7105     case delta_CD_record:
7106       {
7107         recordParts -> storeCommands (*command_line);
7108         break;
7109       }
7110     case delta_Cm_record:
7111       {
7112         recordParts -> storeCommands (*command_line);
7113         break;
7114       }
7115     case delta_Cl_record:
7116       {
7117         recordParts -> storeCommands (*command_line);
7118         break;
7119       }
7120     case boot_cycle_tail_record:
7121       {
7122         recordParts -> storeCommands (*command_line);
7123         break;
7124       }
7125     case boot_cycle_wing_left_record:
7126       {
7127         recordParts -> storeCommands (*command_line);
7128         break;
7129       }
7130     case boot_cycle_wing_right_record:
7131       {
7132         recordParts -> storeCommands (*command_line);
7133         break;
7134       }
7135     case autoIPS_tail_record:
7136       {
7137         recordParts -> storeCommands (*command_line);
7138         break;
7139       }
7140     case autoIPS_wing_left_record:
7141       {
7142         recordParts -> storeCommands (*command_line);
7143         break;
7144       }
7145     case autoIPS_wing_right_record:
7146       {
7147         recordParts -> storeCommands (*command_line);
7148         break;
7149       }
7150     case eps_pitch_input_record:
7151       {
7152         recordParts -> storeCommands (*command_line);
7153         break;
7154       }
7155     case eps_alpha_max_record:
7156       {
7157         recordParts -> storeCommands (*command_line);
7158         break;
7159       }
7160     case eps_pitch_max_record:
7161       {
7162         recordParts -> storeCommands (*command_line);
7163         break;
7164       }
7165     case eps_pitch_min_record:
7166       {
7167         recordParts -> storeCommands (*command_line);
7168         break;
7169       }
7170     case eps_roll_max_record:
7171       {
7172         recordParts -> storeCommands (*command_line);
7173         break;
7174       }
7175     case eps_thrust_min_record:
7176        {
7177         recordParts -> storeCommands (*command_line);
7178         break;
7179       }
7180     case eps_flap_max_record:
7181       {
7182         recordParts -> storeCommands (*command_line);
7183         break;
7184       }
7185     case eps_airspeed_max_record:
7186       {
7187         recordParts -> storeCommands (*command_line);
7188         break;
7189       }
7190     case eps_airspeed_min_record:
7191       {
7192         recordParts -> storeCommands (*command_line);
7193         break;
7194       }
7195
7196       /*********************Auto Pilot************************/
7197     case ap_Theta_ref_deg_record:
7198       {
7199         recordParts -> storeCommands (*command_line);
7200         break;
7201       }
7202     case ap_pah_on_record:
7203       {
7204         recordParts -> storeCommands (*command_line);
7205         break;
7206       }
7207
7208       /************************ Forces ***********************/
7209     case F_X_wind_record:
7210       {
7211         recordParts -> storeCommands (*command_line);
7212         break;
7213       }
7214     case F_Y_wind_record:
7215       {
7216         recordParts -> storeCommands (*command_line);
7217         break;
7218       }
7219     case F_Z_wind_record:
7220       {
7221         recordParts -> storeCommands (*command_line);
7222         break;
7223       }
7224     case F_X_aero_record:
7225       {
7226         recordParts -> storeCommands (*command_line);
7227         break;
7228       }
7229     case F_Y_aero_record:
7230       {
7231         recordParts -> storeCommands (*command_line);
7232         break;
7233       }
7234     case F_Z_aero_record:
7235       {
7236         recordParts -> storeCommands (*command_line);
7237         break;
7238       }
7239     case F_X_engine_record:
7240       {
7241         recordParts -> storeCommands (*command_line);
7242         break;
7243       }
7244     case F_Y_engine_record:
7245       {
7246         recordParts -> storeCommands (*command_line);
7247         break;
7248       }
7249     case F_Z_engine_record:
7250       {
7251         recordParts -> storeCommands (*command_line);
7252         break;
7253       }
7254     case F_X_gear_record:
7255       {
7256         recordParts -> storeCommands (*command_line);
7257         break;
7258       }
7259     case F_Y_gear_record:
7260       {
7261         recordParts -> storeCommands (*command_line);
7262         break;
7263       }
7264     case F_Z_gear_record:
7265       {
7266         recordParts -> storeCommands (*command_line);
7267         break;
7268       }
7269     case F_X_record:
7270       {
7271         recordParts -> storeCommands (*command_line);
7272         break;
7273       }
7274     case F_Y_record:
7275       {
7276         recordParts -> storeCommands (*command_line);
7277         break;
7278       }
7279     case F_Z_record:
7280       {
7281         recordParts -> storeCommands (*command_line);
7282         break;
7283       }
7284     case F_north_record:
7285       {
7286         recordParts -> storeCommands (*command_line);
7287         break;
7288       }
7289     case F_east_record:
7290       {
7291         recordParts -> storeCommands (*command_line);
7292         break;
7293       }
7294     case F_down_record:
7295       {
7296         recordParts -> storeCommands (*command_line);
7297         break;
7298       }
7299
7300       /*********************** Moments ***********************/
7301     case M_l_aero_record:
7302       {
7303         recordParts -> storeCommands (*command_line);
7304         break;
7305       }
7306     case M_m_aero_record:
7307       {
7308         recordParts -> storeCommands (*command_line);
7309         break;
7310       }
7311     case M_n_aero_record:
7312       {
7313         recordParts -> storeCommands (*command_line);
7314         break;
7315       }
7316     case M_l_engine_record:
7317       {
7318         recordParts -> storeCommands (*command_line);
7319         break;
7320       }
7321     case M_m_engine_record:
7322       {
7323         recordParts -> storeCommands (*command_line);
7324         break;
7325       }
7326     case M_n_engine_record:
7327       {
7328         recordParts -> storeCommands (*command_line);
7329         break;
7330       }
7331     case M_l_gear_record:
7332       {
7333         recordParts -> storeCommands (*command_line);
7334         break;
7335       }
7336     case M_m_gear_record:
7337       {
7338         recordParts -> storeCommands (*command_line);
7339         break;
7340       }
7341     case M_n_gear_record:
7342       {
7343         recordParts -> storeCommands (*command_line);
7344         break;
7345       }
7346     case M_l_rp_record:
7347       {
7348         recordParts -> storeCommands (*command_line);
7349         break;
7350       }
7351     case M_m_rp_record:
7352       {
7353         recordParts -> storeCommands (*command_line);
7354         break;
7355       }
7356     case M_n_rp_record:
7357       {
7358         recordParts -> storeCommands (*command_line);
7359         break;
7360       }
7361       /****************** Flapper Data ***********************/
7362     case flapper_freq_record:
7363       {
7364         recordParts -> storeCommands (*command_line);
7365         break;
7366       }
7367     case flapper_phi_record:
7368       {
7369         recordParts -> storeCommands (*command_line);
7370         break;
7371       }
7372     case flapper_phi_deg_record:
7373       {
7374         recordParts -> storeCommands (*command_line);
7375         break;
7376       }
7377     case flapper_Lift_record:
7378       {
7379         recordParts -> storeCommands (*command_line);
7380         break;
7381       }
7382     case flapper_Thrust_record:
7383       {
7384         recordParts -> storeCommands (*command_line);
7385         break;
7386       }
7387     case flapper_Inertia_record:
7388       {
7389         recordParts -> storeCommands (*command_line);
7390         break;
7391       }
7392     case flapper_Moment_record:
7393       {
7394         recordParts -> storeCommands (*command_line);
7395         break;
7396       }
7397       /****************** Flapper Data ***********************/
7398     case debug1_record:
7399       {
7400         recordParts -> storeCommands (*command_line);
7401         break;
7402       }
7403     case debug2_record:
7404       {
7405         recordParts -> storeCommands (*command_line);
7406         break;
7407       }
7408     case debug3_record:
7409       {
7410         recordParts -> storeCommands (*command_line);
7411         break;
7412       }
7413     case tactilefadefI_record:
7414       {
7415         recordParts -> storeCommands (*command_line);
7416         break;
7417       }
7418     default:
7419       {
7420         if (dont_ignore)
7421           uiuc_warnings_errors(2, *command_line);
7422         break;
7423       }
7424     };
7425 }
7426
7427
7428 void parse_misc( const string& linetoken2, const string& linetoken3,
7429                  const string& aircraft_directory, LIST command_line ) {
7430   double token_value;
7431   istrstream token3(linetoken3.c_str());
7432
7433   switch(misc_map[linetoken2])
7434     {
7435     case simpleHingeMomentCoef_flag:
7436       {
7437         if (check_float(linetoken3))
7438           token3 >> token_value;
7439         else
7440           uiuc_warnings_errors(1, *command_line);
7441
7442         simpleHingeMomentCoef = token_value;
7443         break;
7444       }
7445     case dfTimefdf_flag:
7446       {
7447         dfTimefdf = linetoken3;
7448         /* call 1D File Reader with file name (dfTimefdf);
7449            function returns array of dfs (dfArray) and
7450            corresponding time values (TimeArray) and max
7451            number of terms in arrays (ndf) */
7452         uiuc_1DdataFileReader(dfTimefdf,
7453                               dfTimefdf_dfArray,
7454                               dfTimefdf_TimeArray,
7455                               dfTimefdf_ndf);
7456         break;
7457       }
7458     //case flapper_flag:
7459     //  {
7460         //string flap_file;
7461         //
7462         //flap_file = aircraft_directory + "flap.dat";
7463         //flapper_model = true;
7464         //flapper_data = new FlapData(flap_file.c_str());
7465         //break;
7466     //  }
7467     //case flapper_phi_init_flag:
7468     //  {
7469         //if (check_float(linetoken3))
7470         //  token3 >> token_value;
7471         //else
7472         //  uiuc_warnings_errors(1, *command_line);
7473         //
7474         //flapper_phi_init = token_value*DEG_TO_RAD;
7475         //break;
7476     //  }
7477     default:
7478       {
7479         if (dont_ignore)
7480           uiuc_warnings_errors(2, *command_line);
7481         break;
7482       }
7483     };
7484 }
7485
7486
7487 void uiuc_menu( string aircraft_name )
7488 {
7489   string aircraft_directory;
7490   stack command_list;
7491   double token_value;
7492   int token_value_recordRate;
7493   int token_value_convert1, token_value_convert2, token_value_convert3;
7494
7495   string linetoken1;
7496   string linetoken2;
7497   string linetoken3;
7498   string linetoken4;
7499   string linetoken5;
7500   string linetoken6;
7501   string linetoken7;
7502   string linetoken8;
7503   string linetoken9;
7504
7505   double datafile_xArray[100][100], datafile_yArray[100];
7506   double datafile_zArray[100][100];
7507   int datafile_nxArray[100], datafile_ny;
7508
7509   bool CXfabetaf_first = true;
7510   bool CXfadef_first = true;
7511   bool CXfaqf_first = true;
7512   bool CZfabetaf_first = true;
7513   bool CZfadef_first = true;
7514   bool CZfaqf_first = true;
7515   bool Cmfabetaf_first = true;
7516   bool Cmfadef_first = true;
7517   bool Cmfaqf_first = true;
7518   bool CYfabetaf_first = true;
7519   bool CYfadaf_first = true;
7520   bool CYfadrf_first = true;
7521   bool CYfapf_first = true;
7522   bool CYfarf_first = true;
7523   bool Clfabetaf_first = true;
7524   bool Clfadaf_first = true;
7525   bool Clfadrf_first = true;
7526   bool Clfapf_first = true;
7527   bool Clfarf_first = true;
7528   bool Cnfabetaf_first = true;
7529   bool Cnfadaf_first = true;
7530   bool Cnfadrf_first = true;
7531   bool Cnfapf_first = true;
7532   bool Cnfarf_first = true;
7533
7534   bool tactilefadef_first = true;
7535
7536   /* the following default setting should eventually be moved to a default or uiuc_init routine */
7537
7538   recordRate = 1;       /* record every time step, default */
7539   recordStartTime = 0;  /* record from beginning of simulation */
7540
7541 /* set speed at which dynamic pressure terms will be accounted for,
7542    since if velocity is too small, coefficients will go to infinity */
7543   dyn_on_speed      = 33;    /* 20 kts (33 ft/sec), default */
7544   dyn_on_speed_zero = 0.5 * dyn_on_speed;    /* only used if use_dyn_on_speed_curve1 is used */
7545   bootindex = 0;  // the index for the bootTime
7546
7547   dont_ignore = true;
7548
7549   /* Read the file and get the list of commands */
7550   airplane = new ParseFile(aircraft_name); /* struct that includes all lines of the input file */
7551   command_list = airplane -> getCommands();
7552   /* structs to include all parts included in the input file for specific keyword groups */
7553   initParts          = new ParseFile();
7554   geometryParts      = new ParseFile();
7555   massParts          = new ParseFile();
7556   engineParts        = new ParseFile();
7557   aeroDragParts      = new ParseFile();
7558   aeroLiftParts      = new ParseFile();
7559   aeroPitchParts     = new ParseFile();
7560   aeroSideforceParts = new ParseFile();
7561   aeroRollParts      = new ParseFile();
7562   aeroYawParts       = new ParseFile();
7563   gearParts          = new ParseFile();
7564   recordParts        = new ParseFile();
7565
7566   if (command_list.begin() == command_list.end())
7567   {
7568     cerr << "UIUC ERROR: File " << aircraft_name <<" does not exist" << endl;
7569     exit(-1);
7570   }
7571
7572   //construct aircraft-directory
7573   aircraft_directory = aircraft_name;
7574   int index_aircraft_dat = aircraft_directory.find("aircraft.dat");
7575   aircraft_directory.erase(index_aircraft_dat,12);
7576
7577   for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
7578     {
7579       cout << *command_line << endl;
7580
7581       linetoken1 = airplane -> getToken (*command_line, 1);
7582       linetoken2 = airplane -> getToken (*command_line, 2);
7583       linetoken3 = airplane -> getToken (*command_line, 3);
7584       linetoken4 = airplane -> getToken (*command_line, 4);
7585       linetoken5 = airplane -> getToken (*command_line, 5);
7586       linetoken6 = airplane -> getToken (*command_line, 6);
7587       linetoken7 = airplane -> getToken (*command_line, 7);
7588       linetoken8 = airplane -> getToken (*command_line, 8);
7589       linetoken9 = airplane -> getToken (*command_line, 9);
7590
7591       istrstream token3(linetoken3.c_str());
7592       istrstream token4(linetoken4.c_str());
7593       istrstream token5(linetoken5.c_str());
7594       istrstream token6(linetoken6.c_str());
7595       istrstream token7(linetoken7.c_str());
7596       istrstream token8(linetoken8.c_str());
7597       istrstream token9(linetoken9.c_str());
7598
7599       switch (Keyword_map[linetoken1])
7600         {
7601         case init_flag:
7602           {
7603             parse_init( linetoken2, linetoken3, linetoken4, command_line );
7604             break;
7605           } // end init map
7606
7607
7608         case geometry_flag:
7609           {
7610             parse_geometry( linetoken2, linetoken3, command_line );
7611             break;
7612           } // end geometry map
7613
7614
7615         case controlSurface_flag:
7616           {
7617             parse_controlSurface( linetoken2, linetoken3, linetoken4,
7618                                   linetoken5, linetoken6, aircraft_directory,
7619                                   command_line );
7620             break;
7621           } // end controlSurface map
7622
7623
7624         case mass_flag:
7625           {
7626             parse_mass( linetoken2, linetoken3, command_line );
7627             break;
7628           } // end mass map
7629
7630
7631         case engine_flag:
7632           {
7633             parse_engine( linetoken2, linetoken3, linetoken4,
7634                           linetoken5, linetoken6, aircraft_directory,
7635                           command_line );
7636             break;
7637           } // end engine map
7638
7639
7640         case CD_flag:
7641           {
7642             parse_CD( linetoken2, linetoken3, linetoken4,
7643                       linetoken5, linetoken6, linetoken7,
7644                       linetoken8, linetoken9, aircraft_directory,
7645                       CXfabetaf_first, CXfadef_first,
7646                       CXfaqf_first, command_line );
7647             break;
7648           } // end CD map
7649
7650
7651         case CL_flag:
7652           {
7653             parse_CL( linetoken2, linetoken3, linetoken4,
7654                       linetoken5, linetoken6, linetoken7,
7655                       linetoken8, linetoken9, aircraft_directory,
7656                       CZfabetaf_first, CZfadef_first,
7657                       CZfaqf_first, command_line );
7658             break;
7659           } // end CL map
7660
7661
7662         case Cm_flag:
7663           {
7664             parse_Cm( linetoken2, linetoken3, linetoken4,
7665                       linetoken5, linetoken6, linetoken7,
7666                       linetoken8, linetoken9, aircraft_directory,
7667                       Cmfabetaf_first, Cmfadef_first,
7668                       Cmfaqf_first, command_line );
7669             break;
7670           } // end Cm map
7671
7672
7673         case CY_flag:
7674           {
7675             parse_CY( linetoken2, linetoken3, linetoken4,
7676                       linetoken5, linetoken6, linetoken7,
7677                       linetoken8, linetoken9, aircraft_directory,
7678                       CYfabetaf_first, CYfadaf_first,
7679                       CYfadrf_first, CYfapf_first, CYfarf_first,
7680                       command_line );
7681             break;
7682           } // end CY map
7683
7684
7685         case Cl_flag:
7686           {
7687             parse_Cl( linetoken2, linetoken3, linetoken4,
7688                       linetoken5, linetoken6, linetoken7,
7689                       linetoken8, linetoken9, aircraft_directory,
7690                       Clfabetaf_first, Clfadaf_first,
7691                       Clfadrf_first, Clfapf_first, Clfarf_first,
7692                       command_line );
7693             break;
7694           } // end Cl map
7695
7696
7697         case Cn_flag:
7698           {
7699             parse_Cn( linetoken2, linetoken3, linetoken4,
7700                       linetoken5, linetoken6, linetoken7,
7701                       linetoken8, linetoken9, aircraft_directory,
7702                       Cnfabetaf_first, Cnfadaf_first,
7703                       Cnfadrf_first, Cnfapf_first, Cnfarf_first,
7704                       command_line );
7705             break;
7706           } // end Cn map
7707
7708
7709         case gear_flag:
7710           {
7711             int index;
7712             token3 >> index;
7713             if (index < 0 || index >= 16)
7714               uiuc_warnings_errors(1, *command_line);
7715             parse_gear( linetoken2, linetoken3, linetoken4,
7716                         index, command_line );
7717             break;
7718           } // end gear map
7719
7720
7721         case ice_flag:
7722           {
7723             parse_ice( linetoken2, linetoken3, linetoken4,
7724                        linetoken5, linetoken6, linetoken7,
7725                        linetoken8, linetoken9, aircraft_directory,
7726                        tactilefadef_first, command_line );
7727             break;
7728           } // end ice map
7729
7730
7731         case fog_flag:
7732           {
7733             parse_fog( linetoken2, linetoken3, linetoken4,
7734                        command_line );
7735             break;
7736           } // end fog map
7737
7738
7739         case record_flag:
7740           {
7741             static int fout_flag=0;
7742             if (fout_flag==0)
7743             {
7744               fout_flag=-1;
7745               fout.open("uiuc_record.dat");
7746             }
7747             parse_record( linetoken2, command_line );
7748             break;
7749           } // end record map
7750
7751
7752         case misc_flag:
7753           {
7754             parse_misc( linetoken2, linetoken3, aircraft_directory,
7755                         command_line );
7756             break;
7757           } // end misc map
7758
7759
7760         default:
7761           {
7762             if (linetoken1=="*")
7763                 return;
7764             if (dont_ignore)
7765               uiuc_warnings_errors(2, *command_line);
7766             break;
7767           }
7768         };
7769     } // end keyword map
7770
7771   delete airplane;
7772 }
7773
7774 // end menu.cpp