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