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
  60 ----------------------------------------------------------------------
  61
  62  AUTHOR(S):    Bipin Sehgal       <bsehgal@uiuc.edu>
  63                Jeff Scott         <jscott@mail.com>
  64                Robert Deters      <rdeters@uiuc.edu>
  65                Michael Selig      <m-selig@uiuc.edu>
  66                David Megginson    <david@megginson.com>
  67
  68 ----------------------------------------------------------------------
  69
  70  VARIABLES:
  71
  72 ----------------------------------------------------------------------
  73
  74  INPUTS:       n/a
  75
  76 ----------------------------------------------------------------------
  77
  78  OUTPUTS:      n/a
  79
  80 ----------------------------------------------------------------------
  81
  82  CALLED BY:    uiuc_wrapper.cpp
  83
  84 ----------------------------------------------------------------------
  85
  86  CALLS TO:     aircraft.dat
  87                tabulated data files (if needed)
  88
  89 ----------------------------------------------------------------------
  90
  91  COPYRIGHT:    (C) 2000 by Michael Selig
  92
  93  This program is free software; you can redistribute it and/or
  94  modify it under the terms of the GNU General Public License
  95  as published by the Free Software Foundation.
  96
  97  This program is distributed in the hope that it will be useful,
  98  but WITHOUT ANY WARRANTY; without even the implied warranty of
  99  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 100  GNU General Public License for more details.
 101
 102  You should have received a copy of the GNU General Public License
 103  along with this program; if not, write to the Free Software
 104  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 105  USA or view http://www.gnu.org/copyleft/gpl.html.
 106
 107 **********************************************************************/
 108
 109 #include <simgear/compiler.h>
 110
 111 #if defined( __MWERKS__ )
 112 // -dw- optimizer chokes (big-time) trying to optimize humongous
 113 // loop/switch statements
 114 #pragma optimization_level 0
 115 #endif
 116
 117 #include <stdlib.h>
 118 #include STL_IOSTREAM
 119
 120 #include "uiuc_menu.h"
 121
 122 #if !defined (SG_HAVE_NATIVE_SGI_COMPILERS)
 123 SG_USING_STD(cerr);
 124 SG_USING_STD(cout);
 125 SG_USING_STD(endl);
 126
 127 #  ifndef _MSC_VER
 128 SG_USING_STD(exit);
 129 #  endif
 130 #endif
 131
 132 bool check_float(string  &token)
 133 {
 134   float value;
 135   istrstream stream(token.c_str());
 136   return (stream >> value);
 137 }
 138
 139
 140 void uiuc_menu( string aircraft_name )
 141 {
 142   stack command_list;
 143   double token_value;
 144   int token_value_recordRate;
 145   int token_value_convert1, token_value_convert2, token_value_convert3;
 146
 147   string linetoken1;
 148   string linetoken2;
 149   string linetoken3;
 150   string linetoken4;
 151   string linetoken5;
 152   string linetoken6;
 153
 154
 155   /* the following default setting should eventually be moved to a default or uiuc_init routine */
 156
 157   recordRate = 1;       /* record every time step, default */
 158   recordStartTime = 0;  /* record from beginning of simulation */
 159
 160 /* set speed at which dynamic pressure terms will be accounted for,
 161    since if velocity is too small, coefficients will go to infinity */
 162   dyn_on_speed = 33;    /* 20 kts, default */
 163
 164
 165
 166   /* Read the file and get the list of commands */
 167   airplane = new ParseFile(aircraft_name); /* struct that includes all lines of the input file */
 168   command_list = airplane -> getCommands();
 169   /* structs to include all parts included in the input file for specific keyword groups */
 170   initParts          = new ParseFile();
 171   geometryParts      = new ParseFile();
 172   massParts          = new ParseFile();
 173   engineParts        = new ParseFile();
 174   aeroDragParts      = new ParseFile();
 175   aeroLiftParts      = new ParseFile();
 176   aeroPitchParts     = new ParseFile();
 177   aeroSideforceParts = new ParseFile();
 178   aeroRollParts      = new ParseFile();
 179   aeroYawParts       = new ParseFile();
 180   gearParts          = new ParseFile();
 181   recordParts        = new ParseFile();
 182
 183   if (command_list.begin() == command_list.end())
 184   {
 185     cerr << "UIUC ERROR: File " << aircraft_name <<" does not exist" << endl;
 186     exit(-1);
 187   }
 188
 189   for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
 190     {
 191       cout << *command_line << endl;
 192
 193       linetoken1 = airplane -> getToken (*command_line, 1);
 194       linetoken2 = airplane -> getToken (*command_line, 2);
 195       linetoken3 = airplane -> getToken (*command_line, 3);
 196       linetoken4 = airplane -> getToken (*command_line, 4);
 197       linetoken5 = airplane -> getToken (*command_line, 5);
 198       linetoken6 = airplane -> getToken (*command_line, 6);
 199
 200       istrstream token3(linetoken3.c_str());
 201       istrstream token4(linetoken4.c_str());
 202       istrstream token5(linetoken5.c_str());
 203       istrstream token6(linetoken6.c_str());
 204
 205       switch (Keyword_map[linetoken1])
 206         {
 207         case init_flag:
 208           {
 209             switch(init_map[linetoken2])
 210               {
 211               case Dx_pilot_flag:
 212                 {
 213                   if (check_float(linetoken3))
 214                     token3 >> token_value;
 215                   else
 216                     uiuc_warnings_errors(1, *command_line);
 217
 218                   Dx_pilot = token_value;
 219                   initParts -> storeCommands (*command_line);
 220                   break;
 221                 }
 222               case Dy_pilot_flag:
 223                 {
 224                   if (check_float(linetoken3))
 225                     token3 >> token_value;
 226                   else
 227                     uiuc_warnings_errors(1, *command_line);
 228
 229                   Dy_pilot = token_value;
 230                   initParts -> storeCommands (*command_line);
 231                   break;
 232                 }
 233               case Dz_pilot_flag:
 234                 {
 235                   if (check_float(linetoken3))
 236                     token3 >> token_value;
 237                   else
 238                     uiuc_warnings_errors(1, *command_line);
 239
 240                   Dz_pilot = token_value;
 241                   initParts -> storeCommands (*command_line);
 242                   break;
 243                 }
 244               case Dx_cg_flag:
 245                 {
 246                   if (check_float(linetoken3))
 247                     token3 >> token_value;
 248                   else
 249                     uiuc_warnings_errors(1, *command_line);
 250
 251                   Dx_cg = token_value;
 252                   initParts -> storeCommands (*command_line);
 253                   break;
 254                 }
 255               case Dy_cg_flag:
 256                 {
 257                   if (check_float(linetoken3))
 258                     token3 >> token_value;
 259                   else
 260                     uiuc_warnings_errors(1, *command_line);
 261
 262                   Dy_cg = token_value;
 263                   initParts -> storeCommands (*command_line);
 264                   break;
 265                 }
 266               case Dz_cg_flag:
 267                 {
 268                   if (check_float(linetoken3))
 269                     token3 >> token_value;
 270                   else
 271                     uiuc_warnings_errors(1, *command_line);
 272
 273                   Dz_cg = token_value;
 274                   initParts -> storeCommands (*command_line);
 275                   break;
 276                 }
 277               case Altitude_flag:
 278                 {
 279                   if (check_float(linetoken3))
 280                     token3 >> token_value;
 281                   else
 282                     uiuc_warnings_errors(1, *command_line);
 283
 284                   Altitude = token_value;
 285                   initParts -> storeCommands (*command_line);
 286                   break;
 287                 }
 288               case V_north_flag:
 289                 {
 290                   if (check_float(linetoken3))
 291                     token3 >> token_value;
 292                   else
 293                     uiuc_warnings_errors(1, *command_line);
 294
 295                   V_north = token_value;
 296                   initParts -> storeCommands (*command_line);
 297                   break;
 298                 }
 299               case V_east_flag:
 300                 {
 301                   initParts -> storeCommands (*command_line);
 302                   if (check_float(linetoken3))
 303                     token3 >> token_value;
 304                   else
 305                     uiuc_warnings_errors(1, *command_line);
 306
 307                   V_east = token_value;
 308                   break;
 309                 }
 310               case V_down_flag:
 311                 {
 312                   if (check_float(linetoken3))
 313                     token3 >> token_value;
 314                   else
 315                     uiuc_warnings_errors(1, *command_line);
 316
 317                   V_down = token_value;
 318                   initParts -> storeCommands (*command_line);
 319                   break;
 320                 }
 321               case P_body_flag:
 322                 {
 323                   if (check_float(linetoken3))
 324                     token3 >> token_value;
 325                   else
 326                     uiuc_warnings_errors(1, *command_line);
 327
 328                   P_body_init_true = true;
 329                   P_body_init = token_value;
 330                   initParts -> storeCommands (*command_line);
 331                   break;
 332                 }
 333               case Q_body_flag:
 334                 {
 335                   if (check_float(linetoken3))
 336                     token3 >> token_value;
 337                   else
 338                     uiuc_warnings_errors(1, *command_line);
 339
 340                   Q_body_init_true = true;
 341                   Q_body_init = token_value;
 342                   initParts -> storeCommands (*command_line);
 343                   break;
 344                 }
 345               case R_body_flag:
 346                 {
 347                   if (check_float(linetoken3))
 348                     token3 >> token_value;
 349                   else
 350                     uiuc_warnings_errors(1, *command_line);
 351
 352                   R_body_init_true = true;
 353                   R_body_init = token_value;
 354                   initParts -> storeCommands (*command_line);
 355                   break;
 356                 }
 357               case Phi_flag:
 358                 {
 359                   if (check_float(linetoken3))
 360                     token3 >> token_value;
 361                   else
 362                     uiuc_warnings_errors(1, *command_line);
 363
 364                   Phi_init_true = true;
 365                   Phi_init = token_value;
 366                   initParts -> storeCommands (*command_line);
 367                   break;
 368                 }
 369               case Theta_flag:
 370                 {
 371                   if (check_float(linetoken3))
 372                     token3 >> token_value;
 373                   else
 374                     uiuc_warnings_errors(1, *command_line);
 375
 376                   Theta_init_true = true;
 377                   Theta_init = token_value;
 378                   initParts -> storeCommands (*command_line);
 379                   break;
 380                 }
 381               case Psi_flag:
 382                 {
 383                   if (check_float(linetoken3))
 384                     token3 >> token_value;
 385                   else
 386                     uiuc_warnings_errors(1, *command_line);
 387
 388                   Psi_init_true = true;
 389                   Psi_init = token_value;
 390                   initParts -> storeCommands (*command_line);
 391                   break;
 392                 }
 393               case Long_trim_flag:
 394                 {
 395                   if (check_float(linetoken3))
 396                     token3 >> token_value;
 397                   else
 398                     uiuc_warnings_errors(1, *command_line);
 399
 400                   Long_trim = token_value;
 401                   initParts -> storeCommands (*command_line);
 402                   break;
 403                 }
 404               case recordRate_flag:
 405                 {
 406                   //can't use check_float since variable is integer
 407                   token3 >> token_value_recordRate;
 408                   recordRate = 120 / token_value_recordRate;
 409                   break;
 410                 }
 411               case recordStartTime_flag:
 412                 {
 413                   if (check_float(linetoken3))
 414                     token3 >> token_value;
 415                   else
 416                     uiuc_warnings_errors(1, *command_line);
 417
 418                   recordStartTime = token_value;
 419                   break;
 420                 }
 421               case nondim_rate_V_rel_wind_flag:
 422                 {
 423                   nondim_rate_V_rel_wind = true;
 424                   break;
 425                 }
 426               case dyn_on_speed_flag:
 427                 {
 428                   if (check_float(linetoken3))
 429                     token3 >> token_value;
 430                   else
 431                     uiuc_warnings_errors(1, *command_line);
 432
 433                   dyn_on_speed = token_value;
 434                   break;
 435                 }
 436               case Alpha_flag:
 437                 {
 438                   if (check_float(linetoken3))
 439                     token3 >> token_value;
 440                   else
 441                     uiuc_warnings_errors(1, *command_line);
 442
 443                   Alpha_init_true = true;
 444                   Alpha_init = token_value * DEG_TO_RAD;
 445                   break;
 446                 }
 447               case Beta_flag:
 448                 {
 449                   if (check_float(linetoken3))
 450                     token3 >> token_value;
 451                   else
 452                     uiuc_warnings_errors(1, *command_line);
 453
 454                   Beta_init_true = true;
 455                   Beta_init = token_value * DEG_TO_RAD;
 456                   break;
 457                 }
 458               case U_body_flag:
 459                 {
 460                   if (check_float(linetoken3))
 461                     token3 >> token_value;
 462                   else
 463                     uiuc_warnings_errors(1, *command_line);
 464
 465                   U_body_init_true = true;
 466                   U_body_init = token_value;
 467                   break;
 468                 }
 469               case V_body_flag:
 470                 {
 471                   if (check_float(linetoken3))
 472                     token3 >> token_value;
 473                   else
 474                     uiuc_warnings_errors(1, *command_line);
 475
 476                   V_body_init_true = true;
 477                   V_body_init = token_value;
 478                   break;
 479                 }
 480               case W_body_flag:
 481                 {
 482                   if (check_float(linetoken3))
 483                     token3 >> token_value;
 484                   else
 485                     uiuc_warnings_errors(1, *command_line);
 486
 487                   W_body_init_true = true;
 488                   W_body_init = token_value;
 489                   break;
 490                 }
 491               default:
 492                 {
 493                   uiuc_warnings_errors(2, *command_line);
 494                   break;
 495                 }
 496               };
 497             break;
 498           } // end init map
 499
 500
 501         case geometry_flag:
 502           {
 503             switch(geometry_map[linetoken2])
 504               {
 505               case bw_flag:
 506                 {
 507                   if (check_float(linetoken3))
 508                     token3 >> token_value;
 509                   else
 510                     uiuc_warnings_errors(1, *command_line);
 511
 512                   bw = token_value;
 513                   geometryParts -> storeCommands (*command_line);
 514                   break;
 515                 }
 516               case cbar_flag:
 517                 {
 518                   if (check_float(linetoken3))
 519                     token3 >> token_value;
 520                   else
 521                     uiuc_warnings_errors(1, *command_line);
 522
 523                   cbar = token_value;
 524                   geometryParts -> storeCommands (*command_line);
 525                   break;
 526                 }
 527               case Sw_flag:
 528                 {
 529                   if (check_float(linetoken3))
 530                     token3 >> token_value;
 531                   else
 532                     uiuc_warnings_errors(1, *command_line);
 533
 534                   Sw = token_value;
 535                   geometryParts -> storeCommands (*command_line);
 536                   break;
 537                 }
 538               case ih_flag:
 539                 {
 540                   if (check_float(linetoken3))
 541                     token3 >> token_value;
 542                   else
 543                     uiuc_warnings_errors(1, *command_line);
 544
 545                   ih = token_value;
 546                   geometryParts -> storeCommands (*command_line);
 547                   break;
 548                 }
 549               case bh_flag:
 550                 {
 551                   if (check_float(linetoken3))
 552                     token3 >> token_value;
 553                   else
 554                     uiuc_warnings_errors(1, *command_line);
 555
 556                   bh = token_value;
 557                   geometryParts -> storeCommands (*command_line);
 558                   break;
 559                 }
 560               case ch_flag:
 561                 {
 562                   if (check_float(linetoken3))
 563                     token3 >> token_value;
 564                   else
 565                     uiuc_warnings_errors(1, *command_line);
 566
 567                   ch = token_value;
 568                   geometryParts -> storeCommands (*command_line);
 569                   break;
 570                 }
 571               case Sh_flag:
 572                 {
 573                   if (check_float(linetoken3))
 574                     token3 >> token_value;
 575                   else
 576                     uiuc_warnings_errors(1, *command_line);
 577
 578                   Sh = token_value;
 579                   geometryParts -> storeCommands (*command_line);
 580                   break;
 581                 }
 582               default:
 583                 {
 584                   uiuc_warnings_errors(2, *command_line);
 585                   break;
 586                 }
 587               };
 588             break;
 589           } // end geometry map
 590
 591
 592         case controlSurface_flag:
 593           {
 594             switch(controlSurface_map[linetoken2])
 595               {
 596               case de_flag:
 597                 {
 598                   if (check_float(linetoken3))
 599                     token3 >> token_value;
 600                   else
 601                     uiuc_warnings_errors(1, *command_line);
 602
 603                   demax = token_value;
 604
 605                   if (check_float(linetoken4))
 606                     token4 >> token_value;
 607                   else
 608                     uiuc_warnings_errors(1, *command_line);
 609
 610                   demin = token_value;
 611                   break;
 612                 }
 613               case da_flag:
 614                 {
 615                   if (check_float(linetoken3))
 616                     token3 >> token_value;
 617                   else
 618                     uiuc_warnings_errors(1, *command_line);
 619
 620                   damax = token_value;
 621
 622                   if (check_float(linetoken4))
 623                     token4 >> token_value;
 624                   else
 625                     uiuc_warnings_errors(1, *command_line);
 626
 627                   damin = token_value;
 628                   break;
 629                 }
 630               case dr_flag:
 631                 {
 632                   if (check_float(linetoken3))
 633                     token3 >> token_value;
 634                   else
 635                     uiuc_warnings_errors(1, *command_line);
 636
 637                   drmax = token_value;
 638
 639                   if (check_float(linetoken4))
 640                     token4 >> token_value;
 641                   else
 642                     uiuc_warnings_errors(1, *command_line);
 643
 644                   drmin = token_value;
 645                   break;
 646                 }
 647               case set_Long_trim_flag:
 648                 {
 649                   if (check_float(linetoken3))
 650                     token3 >> token_value;
 651                   else
 652                     uiuc_warnings_errors(1, *command_line);
 653
 654                   set_Long_trim = true;
 655                   elevator_tab = token_value;
 656                   break;
 657                 }
 658               case set_Long_trim_deg_flag:
 659                 {
 660                   if (check_float(linetoken3))
 661                     token3 >> token_value;
 662                   else
 663                     uiuc_warnings_errors(1, *command_line);
 664
 665                   set_Long_trim = true;
 666                   elevator_tab = token_value * DEG_TO_RAD;
 667                   break;
 668                 }
 669               case zero_Long_trim_flag:
 670                 {
 671                   zero_Long_trim = true;
 672                   break;
 673                 }
 674               case elevator_step_flag:
 675                 {
 676                   // set step input flag
 677                   elevator_step = true;
 678
 679                   // read in step angle in degrees and convert
 680                   if (check_float(linetoken3))
 681                     token3 >> token_value;
 682                   else
 683                     uiuc_warnings_errors(1, *command_line);
 684
 685                   elevator_step_angle = token_value * DEG_TO_RAD;
 686
 687                   // read in step start time
 688                   if (check_float(linetoken4))
 689                     token4 >> token_value;
 690                   else
 691                     uiuc_warnings_errors(1, *command_line);
 692
 693                   elevator_step_startTime = token_value;
 694                   break;
 695                 }
 696               case elevator_singlet_flag:
 697                 {
 698                   // set singlet input flag
 699                   elevator_singlet = true;
 700
 701                   // read in singlet angle in degrees and convert
 702                   if (check_float(linetoken3))
 703                     token3 >> token_value;
 704                   else
 705                     uiuc_warnings_errors(1, *command_line);
 706
 707                   elevator_singlet_angle = token_value * DEG_TO_RAD;
 708
 709                   // read in singlet start time
 710                   if (check_float(linetoken4))
 711                     token4 >> token_value;
 712                   else
 713                     uiuc_warnings_errors(1, *command_line);
 714
 715                   elevator_singlet_startTime = token_value;
 716
 717                   // read in singlet duration
 718                   if (check_float(linetoken5))
 719                     token5 >> token_value;
 720                   else
 721                     uiuc_warnings_errors(1, *command_line);
 722
 723                   elevator_singlet_duration = token_value;
 724                   break;
 725                 }
 726               case elevator_doublet_flag:
 727                 {
 728                   // set doublet input flag
 729                   elevator_doublet = true;
 730
 731                   // read in doublet angle in degrees and convert
 732                   if (check_float(linetoken3))
 733                     token3 >> token_value;
 734                   else
 735                     uiuc_warnings_errors(1, *command_line);
 736
 737                   elevator_doublet_angle = token_value * DEG_TO_RAD;
 738
 739                   // read in doublet start time
 740                   if (check_float(linetoken4))
 741                     token4 >> token_value;
 742                   else
 743                     uiuc_warnings_errors(1, *command_line);
 744
 745                   elevator_doublet_startTime = token_value;
 746
 747                   // read in doublet duration
 748                   if (check_float(linetoken5))
 749                     token5 >> token_value;
 750                   else
 751                     uiuc_warnings_errors(1, *command_line);
 752
 753                   elevator_doublet_duration = token_value;
 754                   break;
 755                 }
 756               case elevator_input_flag:
 757                 {
 758                   elevator_input = true;
 759                   elevator_input_file = linetoken3;
 760                   token4 >> token_value_convert1;
 761                   token5 >> token_value_convert2;
 762                   convert_y = uiuc_convert(token_value_convert1);
 763                   convert_x = uiuc_convert(token_value_convert2);
 764                   uiuc_1DdataFileReader(elevator_input_file,
 765                                         elevator_input_timeArray,
 766                                         elevator_input_deArray,
 767                                         elevator_input_ntime);
 768                   token6 >> token_value;
 769                   elevator_input_startTime = token_value;
 770                   break;
 771                 }
 772               case aileron_input_flag:
 773                 {
 774                   aileron_input = true;
 775                   aileron_input_file = linetoken3;
 776                   token4 >> token_value_convert1;
 777                   token5 >> token_value_convert2;
 778                   convert_y = uiuc_convert(token_value_convert1);
 779                   convert_x = uiuc_convert(token_value_convert2);
 780                   uiuc_1DdataFileReader(aileron_input_file,
 781                                         aileron_input_timeArray,
 782                                         aileron_input_daArray,
 783                                         aileron_input_ntime);
 784                   token6 >> token_value;
 785                   aileron_input_startTime = token_value;
 786                   break;
 787                 }
 788               case rudder_input_flag:
 789                 {
 790                   rudder_input = true;
 791                   rudder_input_file = linetoken3;
 792                   token4 >> token_value_convert1;
 793                   token5 >> token_value_convert2;
 794                   convert_y = uiuc_convert(token_value_convert1);
 795                   convert_x = uiuc_convert(token_value_convert2);
 796                   uiuc_1DdataFileReader(rudder_input_file,
 797                                         rudder_input_timeArray,
 798                                         rudder_input_drArray,
 799                                         rudder_input_ntime);
 800                   token6 >> token_value;
 801                   rudder_input_startTime = token_value;
 802                   break;
 803                 }
 804               case pilot_elev_no_flag:
 805                 {
 806                   pilot_elev_no_check = true;
 807                   break;
 808                 }
 809               case pilot_ail_no_flag:
 810                 {
 811                   pilot_ail_no_check = true;
 812                   break;
 813                 }
 814               case pilot_rud_no_flag:
 815                 {
 816                   pilot_rud_no_check = true;
 817                   break;
 818                 }
 819               default:
 820                 {
 821                   uiuc_warnings_errors(2, *command_line);
 822                   break;
 823                 }
 824               };
 825             break;
 826           } // end controlSurface map
 827
 828
 829         case mass_flag:
 830           {
 831             switch(mass_map[linetoken2])
 832               {
 833               case Weight_flag:
 834                 {
 835                   if (check_float(linetoken3))
 836                     token3 >> token_value;
 837                   else
 838                     uiuc_warnings_errors(1, *command_line);
 839
 840                   Weight = token_value;
 841                   Mass = Weight * INVG;
 842                   massParts -> storeCommands (*command_line);
 843                   break;
 844                 }
 845               case Mass_flag:
 846                 {
 847                   if (check_float(linetoken3))
 848                     token3 >> token_value;
 849                   else
 850                     uiuc_warnings_errors(1, *command_line);
 851
 852                   Mass = token_value;
 853                   massParts -> storeCommands (*command_line);
 854                   break;
 855                 }
 856               case I_xx_flag:
 857                 {
 858                   if (check_float(linetoken3))
 859                     token3 >> token_value;
 860                   else
 861                     uiuc_warnings_errors(1, *command_line);
 862
 863                   I_xx = token_value;
 864                   massParts -> storeCommands (*command_line);
 865                   break;
 866                 }
 867               case I_yy_flag:
 868                 {
 869                   if (check_float(linetoken3))
 870                     token3 >> token_value;
 871                   else
 872                     uiuc_warnings_errors(1, *command_line);
 873
 874                   I_yy = token_value;
 875                   massParts -> storeCommands (*command_line);
 876                   break;
 877                 }
 878               case I_zz_flag:
 879                 {
 880                   if (check_float(linetoken3))
 881                     token3 >> token_value;
 882                   else
 883                     uiuc_warnings_errors(1, *command_line);
 884
 885                   I_zz = token_value;
 886                   massParts -> storeCommands (*command_line);
 887                   break;
 888                 }
 889               case I_xz_flag:
 890                 {
 891                   if (check_float(linetoken3))
 892                     token3 >> token_value;
 893                   else
 894                     uiuc_warnings_errors(1, *command_line);
 895
 896                   I_xz = token_value;
 897                   massParts -> storeCommands (*command_line);
 898                   break;
 899                 }
 900               default:
 901                 {
 902                   uiuc_warnings_errors(2, *command_line);
 903                   break;
 904                 }
 905               };
 906             break;
 907           } // end mass map
 908
 909
 910         case engine_flag:
 911           {
 912             switch(engine_map[linetoken2])
 913               {
 914               case simpleSingle_flag:
 915                 {
 916                   if (check_float(linetoken3))
 917                     token3 >> token_value;
 918                   else
 919                     uiuc_warnings_errors(1, *command_line);
 920
 921                   simpleSingleMaxThrust = token_value;
 922                   engineParts -> storeCommands (*command_line);
 923                   break;
 924                 }
 925               case c172_flag:
 926                 {
 927                   engineParts -> storeCommands (*command_line);
 928                   break;
 929                 }
 930               case cherokee_flag:
 931                 {
 932                   engineParts -> storeCommands (*command_line);
 933                   break;
 934                 }
 935               case Throttle_pct_input_flag:
 936                 {
 937                   Throttle_pct_input = true;
 938                   Throttle_pct_input_file = linetoken3;
 939                   token4 >> token_value_convert1;
 940                   token5 >> token_value_convert2;
 941                   convert_y = uiuc_convert(token_value_convert1);
 942                   convert_x = uiuc_convert(token_value_convert2);
 943                   uiuc_1DdataFileReader(Throttle_pct_input_file,
 944                                         Throttle_pct_input_timeArray,
 945                                         Throttle_pct_input_dTArray,
 946                                         Throttle_pct_input_ntime);
 947                   token6 >> token_value;
 948                   Throttle_pct_input_startTime = token_value;
 949                   break;
 950                 }
 951               default:
 952                 {
 953                   uiuc_warnings_errors(2, *command_line);
 954                   break;
 955                 }
 956               };
 957             break;
 958           } // end engine map
 959
 960
 961         case CD_flag:
 962           {
 963             switch(CD_map[linetoken2])
 964               {
 965               case CDo_flag:
 966                 {
 967                   if (check_float(linetoken3))
 968                     token3 >> token_value;
 969                   else
 970                     uiuc_warnings_errors(1, *command_line);
 971
 972                   CDo = token_value;
 973                   CDo_clean = CDo;
 974                   aeroDragParts -> storeCommands (*command_line);
 975                   break;
 976                 }
 977               case CDK_flag:
 978                 {
 979                   if (check_float(linetoken3))
 980                     token3 >> token_value;
 981                   else
 982                     uiuc_warnings_errors(1, *command_line);
 983
 984                   CDK = token_value;
 985                   CDK_clean = CDK;
 986                   aeroDragParts -> storeCommands (*command_line);
 987                   break;
 988                 }
 989               case CD_a_flag:
 990                 {
 991                   if (check_float(linetoken3))
 992                     token3 >> token_value;
 993                   else
 994                     uiuc_warnings_errors(1, *command_line);
 995
 996                   CD_a = token_value;
 997                   CD_a_clean = CD_a;
 998                   aeroDragParts -> storeCommands (*command_line);
 999                   break;
1000                 }
1001               case CD_adot_flag:
1002                 {
1003                   if (check_float(linetoken3))
1004                     token3 >> token_value;
1005                   else
1006                     uiuc_warnings_errors(1, *command_line);
1007
1008                   CD_adot = token_value;
1009                   CD_adot_clean = CD_adot;
1010                   aeroDragParts -> storeCommands (*command_line);
1011                   break;
1012                 }
1013               case CD_q_flag:
1014                 {
1015                   if (check_float(linetoken3))
1016                     token3 >> token_value;
1017                   else
1018                     uiuc_warnings_errors(1, *command_line);
1019
1020                   CD_q = token_value;
1021                   CD_q_clean = CD_q;
1022                   aeroDragParts -> storeCommands (*command_line);
1023                   break;
1024                 }
1025               case CD_ih_flag:
1026                 {
1027                   if (check_float(linetoken3))
1028                     token3 >> token_value;
1029                   else
1030                     uiuc_warnings_errors(1, *command_line);
1031
1032                   CD_ih = token_value;
1033                   aeroDragParts -> storeCommands (*command_line);
1034                   break;
1035                 }
1036               case CD_de_flag:
1037                 {
1038                   if (check_float(linetoken3))
1039                     token3 >> token_value;
1040                   else
1041                     uiuc_warnings_errors(1, *command_line);
1042
1043                   CD_de = token_value;
1044                   CD_de_clean = CD_de;
1045                   aeroDragParts -> storeCommands (*command_line);
1046                   break;
1047                 }
1048               case CDfa_flag:
1049                 {
1050                   CDfa = linetoken3;
1051                   token4 >> token_value_convert1;
1052                   token5 >> token_value_convert2;
1053                   convert_y = uiuc_convert(token_value_convert1);
1054                   convert_x = uiuc_convert(token_value_convert2);
1055                   /* call 1D File Reader with file name (CDfa) and conversion
1056                      factors; function returns array of alphas (aArray) and
1057                      corresponding CD values (CDArray) and max number of
1058                      terms in arrays (nAlpha) */
1059                   uiuc_1DdataFileReader(CDfa,
1060                                         CDfa_aArray,
1061                                         CDfa_CDArray,
1062                                         CDfa_nAlpha);
1063                   aeroDragParts -> storeCommands (*command_line);
1064                   break;
1065                 }
1066               case CDfCL_flag:
1067                 {
1068                   CDfCL = linetoken3;
1069                   token4 >> token_value_convert1;
1070                   token5 >> token_value_convert2;
1071                   convert_y = uiuc_convert(token_value_convert1);
1072                   convert_x = uiuc_convert(token_value_convert2);
1073                   /* call 1D File Reader with file name (CDfCL) and conversion
1074                      factors; function returns array of CLs (CLArray) and
1075                      corresponding CD values (CDArray) and max number of
1076                      terms in arrays (nCL) */
1077                   uiuc_1DdataFileReader(CDfCL,
1078                                         CDfCL_CLArray,
1079                                         CDfCL_CDArray,
1080                                         CDfCL_nCL);
1081                   aeroDragParts -> storeCommands (*command_line);
1082                   break;
1083                 }
1084               case CDfade_flag:
1085                 {
1086                   CDfade = linetoken3;
1087                   token4 >> token_value_convert1;
1088                   token5 >> token_value_convert2;
1089                   token6 >> token_value_convert3;
1090                   convert_z = uiuc_convert(token_value_convert1);
1091                   convert_x = uiuc_convert(token_value_convert2);
1092                   convert_y = uiuc_convert(token_value_convert3);
1093                   /* call 2D File Reader with file name (CDfade) and
1094                      conversion factors; function returns array of
1095                      elevator deflections (deArray) and corresponding
1096                      alpha (aArray) and delta CD (CDArray) values and
1097                      max number of terms in alpha arrays (nAlphaArray)
1098                      and deflection array (nde) */
1099                   uiuc_2DdataFileReader(CDfade,
1100                                         CDfade_aArray,
1101                                         CDfade_deArray,
1102                                         CDfade_CDArray,
1103                                         CDfade_nAlphaArray,
1104                                         CDfade_nde);
1105                   aeroDragParts -> storeCommands (*command_line);
1106                   break;
1107                 }
1108               case CDfdf_flag:
1109                 {
1110                   CDfdf = linetoken3;
1111                   token4 >> token_value_convert1;
1112                   token5 >> token_value_convert2;
1113                   convert_y = uiuc_convert(token_value_convert1);
1114                   convert_x = uiuc_convert(token_value_convert2);
1115                   /* call 1D File Reader with file name (CDfdf) and conversion
1116                      factors; function returns array of dfs (dfArray) and
1117                      corresponding CD values (CDArray) and max number of
1118                      terms in arrays (ndf) */
1119                   uiuc_1DdataFileReader(CDfdf,
1120                                         CDfdf_dfArray,
1121                                         CDfdf_CDArray,
1122                                         CDfdf_ndf);
1123                   aeroDragParts -> storeCommands (*command_line);
1124                   break;
1125                 }
1126               case CDfadf_flag:
1127                 {
1128                   CDfadf = linetoken3;
1129                   token4 >> token_value_convert1;
1130                   token5 >> token_value_convert2;
1131                   token6 >> token_value_convert3;
1132                   convert_z = uiuc_convert(token_value_convert1);
1133                   convert_x = uiuc_convert(token_value_convert2);
1134                   convert_y = uiuc_convert(token_value_convert3);
1135                   /* call 2D File Reader with file name (CDfadf) and
1136                      conversion factors; function returns array of
1137                      flap deflections (dfArray) and corresponding
1138                      alpha (aArray) and delta CD (CDArray) values and
1139                      max number of terms in alpha arrays (nAlphaArray)
1140                      and deflection array (ndf) */
1141                   uiuc_2DdataFileReader(CDfadf,
1142                                         CDfadf_aArray,
1143                                         CDfadf_dfArray,
1144                                         CDfadf_CDArray,
1145                                         CDfadf_nAlphaArray,
1146                                         CDfadf_ndf);
1147                   aeroDragParts -> storeCommands (*command_line);
1148                   break;
1149                 }
1150               case CXo_flag:
1151                 {
1152                   if (check_float(linetoken3))
1153                     token3 >> token_value;
1154                   else
1155                     uiuc_warnings_errors(1, *command_line);
1156
1157                   CXo = token_value;
1158                   CXo_clean = CXo;
1159                   aeroDragParts -> storeCommands (*command_line);
1160                   break;
1161                 }
1162               case CXK_flag:
1163                 {
1164                   if (check_float(linetoken3))
1165                     token3 >> token_value;
1166                   else
1167                     uiuc_warnings_errors(1, *command_line);
1168
1169                   CXK = token_value;
1170                   CXK_clean = CXK;
1171                   aeroDragParts -> storeCommands (*command_line);
1172                   break;
1173                 }
1174               case CX_a_flag:
1175                 {
1176                   if (check_float(linetoken3))
1177                     token3 >> token_value;
1178                   else
1179                     uiuc_warnings_errors(1, *command_line);
1180
1181                   CX_a = token_value;
1182                   CX_a_clean = CX_a;
1183                   aeroDragParts -> storeCommands (*command_line);
1184                   break;
1185                 }
1186               case CX_a2_flag:
1187                 {
1188                   if (check_float(linetoken3))
1189                     token3 >> token_value;
1190                   else
1191                     uiuc_warnings_errors(1, *command_line);
1192
1193                   CX_a2 = token_value;
1194                   CX_a2_clean = CX_a2;
1195                   aeroDragParts -> storeCommands (*command_line);
1196                   break;
1197                 }
1198               case CX_a3_flag:
1199                 {
1200                   if (check_float(linetoken3))
1201                     token3 >> token_value;
1202                   else
1203                     uiuc_warnings_errors(1, *command_line);
1204
1205                   CX_a3 = token_value;
1206                   CX_a3_clean = CX_a3;
1207                   aeroDragParts -> storeCommands (*command_line);
1208                   break;
1209                 }
1210               case CX_adot_flag:
1211                 {
1212                   if (check_float(linetoken3))
1213                     token3 >> token_value;
1214                   else
1215                     uiuc_warnings_errors(1, *command_line);
1216
1217                   CX_adot = token_value;
1218                   CX_adot_clean = CX_adot;
1219                   aeroDragParts -> storeCommands (*command_line);
1220                   break;
1221                 }
1222               case CX_q_flag:
1223                 {
1224                   if (check_float(linetoken3))
1225                     token3 >> token_value;
1226                   else
1227                     uiuc_warnings_errors(1, *command_line);
1228
1229                   CX_q = token_value;
1230                   CX_q_clean = CX_q;
1231                   aeroDragParts -> storeCommands (*command_line);
1232                   break;
1233                 }
1234               case CX_de_flag:
1235                 {
1236                   if (check_float(linetoken3))
1237                     token3 >> token_value;
1238                   else
1239                     uiuc_warnings_errors(1, *command_line);
1240
1241                   CX_de = token_value;
1242                   CX_de_clean = CX_de;
1243                   aeroDragParts -> storeCommands (*command_line);
1244                   break;
1245                 }
1246               case CX_dr_flag:
1247                 {
1248                   if (check_float(linetoken3))
1249                     token3 >> token_value;
1250                   else
1251                     uiuc_warnings_errors(1, *command_line);
1252
1253                   CX_dr = token_value;
1254                   CX_dr_clean = CX_dr;
1255                   aeroDragParts -> storeCommands (*command_line);
1256                   break;
1257                 }
1258               case CX_df_flag:
1259                 {
1260                   if (check_float(linetoken3))
1261                     token3 >> token_value;
1262                   else
1263                     uiuc_warnings_errors(1, *command_line);
1264
1265                   CX_df = token_value;
1266                   CX_df_clean = CX_df;
1267                   aeroDragParts -> storeCommands (*command_line);
1268                   break;
1269                 }
1270               case CX_adf_flag:
1271                 {
1272                   if (check_float(linetoken3))
1273                     token3 >> token_value;
1274                   else
1275                     uiuc_warnings_errors(1, *command_line);
1276
1277                   CX_adf = token_value;
1278                   CX_adf_clean = CX_adf;
1279                   aeroDragParts -> storeCommands (*command_line);
1280                   break;
1281                 }
1282               default:
1283                 {
1284                   uiuc_warnings_errors(2, *command_line);
1285                   break;
1286                 }
1287               };
1288             break;
1289           } // end CD map
1290
1291
1292         case CL_flag:
1293           {
1294             switch(CL_map[linetoken2])
1295               {
1296               case CLo_flag:
1297                 {
1298                   if (check_float(linetoken3))
1299                     token3 >> token_value;
1300                   else
1301                     uiuc_warnings_errors(1, *command_line);
1302
1303                   CLo = token_value;
1304                   CLo_clean = CLo;
1305                   aeroLiftParts -> storeCommands (*command_line);
1306                   break;
1307                 }
1308               case CL_a_flag:
1309                 {
1310                   if (check_float(linetoken3))
1311                     token3 >> token_value;
1312                   else
1313                     uiuc_warnings_errors(1, *command_line);
1314
1315                   CL_a = token_value;
1316                   CL_a_clean = CL_a;
1317                   aeroLiftParts -> storeCommands (*command_line);
1318                   break;
1319                 }
1320               case CL_adot_flag:
1321                 {
1322                   if (check_float(linetoken3))
1323                     token3 >> token_value;
1324                   else
1325                     uiuc_warnings_errors(1, *command_line);
1326
1327                   CL_adot = token_value;
1328                   CL_adot_clean = CL_adot;
1329                   aeroLiftParts -> storeCommands (*command_line);
1330                   break;
1331                 }
1332               case CL_q_flag:
1333                 {
1334                   if (check_float(linetoken3))
1335                     token3 >> token_value;
1336                   else
1337                     uiuc_warnings_errors(1, *command_line);
1338
1339                   CL_q = token_value;
1340                   CL_q_clean = CL_q;
1341                   aeroLiftParts -> storeCommands (*command_line);
1342                   break;
1343                 }
1344               case CL_ih_flag:
1345                 {
1346                   if (check_float(linetoken3))
1347                     token3 >> token_value;
1348                   else
1349                     uiuc_warnings_errors(1, *command_line);
1350
1351                   CL_ih = token_value;
1352                   aeroLiftParts -> storeCommands (*command_line);
1353                   break;
1354                 }
1355               case CL_de_flag:
1356                 {
1357                   if (check_float(linetoken3))
1358                     token3 >> token_value;
1359                   else
1360                     uiuc_warnings_errors(1, *command_line);
1361
1362                   CL_de = token_value;
1363                   CL_de_clean = CL_de;
1364                   aeroLiftParts -> storeCommands (*command_line);
1365                   break;
1366                 }
1367               case CLfa_flag:
1368                 {
1369                   CLfa = linetoken3;
1370                   token4 >> token_value_convert1;
1371                   token5 >> token_value_convert2;
1372                   convert_y = uiuc_convert(token_value_convert1);
1373                   convert_x = uiuc_convert(token_value_convert2);
1374                   /* call 1D File Reader with file name (CLfa) and conversion
1375                      factors; function returns array of alphas (aArray) and
1376                      corresponding CL values (CLArray) and max number of
1377                      terms in arrays (nAlpha) */
1378                   uiuc_1DdataFileReader(CLfa,
1379                                         CLfa_aArray,
1380                                         CLfa_CLArray,
1381                                         CLfa_nAlpha);
1382                   aeroLiftParts -> storeCommands (*command_line);
1383                   break;
1384                 }
1385               case CLfade_flag:
1386                 {
1387                   CLfade = linetoken3;
1388                   token4 >> token_value_convert1;
1389                   token5 >> token_value_convert2;
1390                   token6 >> token_value_convert3;
1391                   convert_z = uiuc_convert(token_value_convert1);
1392                   convert_x = uiuc_convert(token_value_convert2);
1393                   convert_y = uiuc_convert(token_value_convert3);
1394                   /* call 2D File Reader with file name (CLfade) and
1395                      conversion factors; function returns array of
1396                      elevator deflections (deArray) and corresponding
1397                      alpha (aArray) and delta CL (CLArray) values and
1398                      max number of terms in alpha arrays (nAlphaArray)
1399                      and deflection array (nde) */
1400                   uiuc_2DdataFileReader(CLfade,
1401                                         CLfade_aArray,
1402                                         CLfade_deArray,
1403                                         CLfade_CLArray,
1404                                         CLfade_nAlphaArray,
1405                                         CLfade_nde);
1406                   aeroLiftParts -> storeCommands (*command_line);
1407                   break;
1408                 }
1409               case CLfdf_flag:
1410                 {
1411                   CLfdf = linetoken3;
1412                   token4 >> token_value_convert1;
1413                   token5 >> token_value_convert2;
1414                   convert_y = uiuc_convert(token_value_convert1);
1415                   convert_x = uiuc_convert(token_value_convert2);
1416                   /* call 1D File Reader with file name (CLfdf) and conversion
1417                      factors; function returns array of dfs (dfArray) and
1418                      corresponding CL values (CLArray) and max number of
1419                      terms in arrays (ndf) */
1420                   uiuc_1DdataFileReader(CLfdf,
1421                                         CLfdf_dfArray,
1422                                         CLfdf_CLArray,
1423                                         CLfdf_ndf);
1424                   aeroLiftParts -> storeCommands (*command_line);
1425
1426                   // additional variables to streamline flap routine in aerodeflections
1427                   ndf = CLfdf_ndf;
1428                   int temp_counter = 1;
1429                   while (temp_counter <= ndf)
1430                     {
1431                       dfArray[temp_counter] = CLfdf_dfArray[temp_counter];
1432                       TimeArray[temp_counter] = dfTimefdf_TimeArray[temp_counter];
1433                       temp_counter++;
1434                     }
1435                   break;
1436                 }
1437               case CLfadf_flag:
1438                 {
1439                   CLfadf = linetoken3;
1440                   token4 >> token_value_convert1;
1441                   token5 >> token_value_convert2;
1442                   token6 >> token_value_convert3;
1443                   convert_z = uiuc_convert(token_value_convert1);
1444                   convert_x = uiuc_convert(token_value_convert2);
1445                   convert_y = uiuc_convert(token_value_convert3);
1446                   /* call 2D File Reader with file name (CLfadf) and
1447                      conversion factors; function returns array of
1448                      flap deflections (dfArray) and corresponding
1449                      alpha (aArray) and delta CL (CLArray) values and
1450                      max number of terms in alpha arrays (nAlphaArray)
1451                      and deflection array (ndf) */
1452                   uiuc_2DdataFileReader(CLfadf,
1453                                         CLfadf_aArray,
1454                                         CLfadf_dfArray,
1455                                         CLfadf_CLArray,
1456                                         CLfadf_nAlphaArray,
1457                                         CLfadf_ndf);
1458                   aeroLiftParts -> storeCommands (*command_line);
1459                   break;
1460                 }
1461               case CZo_flag:
1462                 {
1463                   if (check_float(linetoken3))
1464                     token3 >> token_value;
1465                   else
1466                     uiuc_warnings_errors(1, *command_line);
1467
1468                   CZo = token_value;
1469                   CZo_clean = CZo;
1470                   aeroLiftParts -> storeCommands (*command_line);
1471                   break;
1472                 }
1473               case CZ_a_flag:
1474                 {
1475                   if (check_float(linetoken3))
1476                     token3 >> token_value;
1477                   else
1478                     uiuc_warnings_errors(1, *command_line);
1479
1480                   CZ_a = token_value;
1481                   CZ_a_clean = CZ_a;
1482                   aeroLiftParts -> storeCommands (*command_line);
1483                   break;
1484                 }
1485               case CZ_a2_flag:
1486                 {
1487                   if (check_float(linetoken3))
1488                     token3 >> token_value;
1489                   else
1490                     uiuc_warnings_errors(1, *command_line);
1491
1492                   CZ_a2 = token_value;
1493                   CZ_a2_clean = CZ_a2;
1494                   aeroLiftParts -> storeCommands (*command_line);
1495                   break;
1496                 }
1497               case CZ_a3_flag:
1498                 {
1499                   if (check_float(linetoken3))
1500                     token3 >> token_value;
1501                   else
1502                     uiuc_warnings_errors(1, *command_line);
1503
1504                   CZ_a3 = token_value;
1505                   CZ_a3_clean = CZ_a3;
1506                   aeroLiftParts -> storeCommands (*command_line);
1507                   break;
1508                 }
1509               case CZ_adot_flag:
1510                 {
1511                   if (check_float(linetoken3))
1512                     token3 >> token_value;
1513                   else
1514                     uiuc_warnings_errors(1, *command_line);
1515
1516                   CZ_adot = token_value;
1517                   CZ_adot_clean = CZ_adot;
1518                   aeroLiftParts -> storeCommands (*command_line);
1519                   break;
1520                 }
1521               case CZ_q_flag:
1522                 {
1523                   if (check_float(linetoken3))
1524                     token3 >> token_value;
1525                   else
1526                     uiuc_warnings_errors(1, *command_line);
1527
1528                   CZ_q = token_value;
1529                   CZ_q_clean = CZ_q;
1530                   aeroLiftParts -> storeCommands (*command_line);
1531                   break;
1532                 }
1533               case CZ_de_flag:
1534                 {
1535                   if (check_float(linetoken3))
1536                     token3 >> token_value;
1537                   else
1538                     uiuc_warnings_errors(1, *command_line);
1539
1540                   CZ_de = token_value;
1541                   CZ_de_clean = CZ_de;
1542                   aeroLiftParts -> storeCommands (*command_line);
1543                   break;
1544                 }
1545               case CZ_deb2_flag:
1546                 {
1547                   if (check_float(linetoken3))
1548                     token3 >> token_value;
1549                   else
1550                     uiuc_warnings_errors(1, *command_line);
1551
1552                   CZ_deb2 = token_value;
1553                   CZ_deb2_clean = CZ_deb2;
1554                   aeroLiftParts -> storeCommands (*command_line);
1555                   break;
1556                 }
1557               case CZ_df_flag:
1558                 {
1559                   if (check_float(linetoken3))
1560                     token3 >> token_value;
1561                   else
1562                     uiuc_warnings_errors(1, *command_line);
1563
1564                   CZ_df = token_value;
1565                   CZ_df_clean = CZ_df;
1566                   aeroLiftParts -> storeCommands (*command_line);
1567                   break;
1568                 }
1569               case CZ_adf_flag:
1570                 {
1571                   if (check_float(linetoken3))
1572                     token3 >> token_value;
1573                   else
1574                     uiuc_warnings_errors(1, *command_line);
1575
1576                   CZ_adf = token_value;
1577                   CZ_adf_clean = CZ_adf;
1578                   aeroLiftParts -> storeCommands (*command_line);
1579                   break;
1580                 }
1581               case CZfa_flag:
1582                 {
1583                   CZfa = linetoken3;
1584                   token4 >> token_value_convert1;
1585                   token5 >> token_value_convert2;
1586                   convert_y = uiuc_convert(token_value_convert1);
1587                   convert_x = uiuc_convert(token_value_convert2);
1588                   /* call 1D File Reader with file name (CZfa) and conversion
1589                      factors; function returns array of alphas (aArray) and
1590                      corresponding CZ values (CZArray) and max number of
1591                      terms in arrays (nAlpha) */
1592                   uiuc_1DdataFileReader(CZfa,
1593                                         CZfa_aArray,
1594                                         CZfa_CZArray,
1595                                         CZfa_nAlpha);
1596                   aeroLiftParts -> storeCommands (*command_line);
1597                   break;
1598                 }
1599               default:
1600                 {
1601                   uiuc_warnings_errors(2, *command_line);
1602                   break;
1603                 }
1604               };
1605             break;
1606           } // end CL map
1607
1608
1609         case Cm_flag:
1610           {
1611             switch(Cm_map[linetoken2])
1612               {
1613               case Cmo_flag:
1614                 {
1615                   if (check_float(linetoken3))
1616                     token3 >> token_value;
1617                   else
1618                     uiuc_warnings_errors(1, *command_line);
1619
1620                   Cmo = token_value;
1621                   Cmo_clean = Cmo;
1622                   aeroPitchParts -> storeCommands (*command_line);
1623                   break;
1624                 }
1625               case Cm_a_flag:
1626                 {
1627                   if (check_float(linetoken3))
1628                     token3 >> token_value;
1629                   else
1630                     uiuc_warnings_errors(1, *command_line);
1631
1632                   Cm_a = token_value;
1633                   Cm_a_clean = Cm_a;
1634                   aeroPitchParts -> storeCommands (*command_line);
1635                   break;
1636                 }
1637               case Cm_a2_flag:
1638                 {
1639                   if (check_float(linetoken3))
1640                     token3 >> token_value;
1641                   else
1642                     uiuc_warnings_errors(1, *command_line);
1643
1644                   Cm_a2 = token_value;
1645                   Cm_a2_clean = Cm_a2;
1646                   aeroPitchParts -> storeCommands (*command_line);
1647                   break;
1648                 }
1649               case Cm_adot_flag:
1650                 {
1651                   if (check_float(linetoken3))
1652                     token3 >> token_value;
1653                   else
1654                     uiuc_warnings_errors(1, *command_line);
1655
1656                   Cm_adot = token_value;
1657                   Cm_adot_clean = Cm_adot;
1658                   aeroPitchParts -> storeCommands (*command_line);
1659                   break;
1660                 }
1661               case Cm_q_flag:
1662                 {
1663                   if (check_float(linetoken3))
1664                     token3 >> token_value;
1665                   else
1666                     uiuc_warnings_errors(1, *command_line);
1667
1668                   Cm_q = token_value;
1669                   Cm_q_clean = Cm_q;
1670                   aeroPitchParts -> storeCommands (*command_line);
1671                   break;
1672                 }
1673               case Cm_ih_flag:
1674                 {
1675                   if (check_float(linetoken3))
1676                     token3 >> token_value;
1677                   else
1678                     uiuc_warnings_errors(1, *command_line);
1679
1680                   Cm_ih = token_value;
1681                   aeroPitchParts -> storeCommands (*command_line);
1682                   break;
1683                 }
1684               case Cm_de_flag:
1685                 {
1686                   if (check_float(linetoken3))
1687                     token3 >> token_value;
1688                   else
1689                     uiuc_warnings_errors(1, *command_line);
1690
1691                   Cm_de = token_value;
1692                   Cm_de_clean = Cm_de;
1693                   aeroPitchParts -> storeCommands (*command_line);
1694                   break;
1695                 }
1696               case Cm_b2_flag:
1697                 {
1698                   if (check_float(linetoken3))
1699                     token3 >> token_value;
1700                   else
1701                     uiuc_warnings_errors(1, *command_line);
1702
1703                   Cm_b2 = token_value;
1704                   Cm_b2_clean = Cm_b2;
1705                   aeroPitchParts -> storeCommands (*command_line);
1706                   break;
1707                 }
1708               case Cm_r_flag:
1709                 {
1710                   if (check_float(linetoken3))
1711                     token3 >> token_value;
1712                   else
1713                     uiuc_warnings_errors(1, *command_line);
1714
1715                   Cm_r = token_value;
1716                   Cm_r_clean = Cm_r;
1717                   aeroPitchParts -> storeCommands (*command_line);
1718                   break;
1719                 }
1720               case Cm_df_flag:
1721                 {
1722                   if (check_float(linetoken3))
1723                     token3 >> token_value;
1724                   else
1725                     uiuc_warnings_errors(1, *command_line);
1726
1727                   Cm_df = token_value;
1728                   Cm_df_clean = Cm_df;
1729                   aeroPitchParts -> storeCommands (*command_line);
1730                   break;
1731                 }
1732               case Cmfa_flag:
1733                 {
1734                   Cmfa = linetoken3;
1735                   token4 >> token_value_convert1;
1736                   token5 >> token_value_convert2;
1737                   convert_y = uiuc_convert(token_value_convert1);
1738                   convert_x = uiuc_convert(token_value_convert2);
1739                   /* call 1D File Reader with file name (Cmfa) and conversion
1740                      factors; function returns array of alphas (aArray) and
1741                      corresponding Cm values (CmArray) and max number of
1742                      terms in arrays (nAlpha) */
1743                   uiuc_1DdataFileReader(Cmfa,
1744                                         Cmfa_aArray,
1745                                         Cmfa_CmArray,
1746                                         Cmfa_nAlpha);
1747                   aeroPitchParts -> storeCommands (*command_line);
1748                   break;
1749                 }
1750               case Cmfade_flag:
1751                 {
1752                   Cmfade = linetoken3;
1753                   token4 >> token_value_convert1;
1754                   token5 >> token_value_convert2;
1755                   token6 >> token_value_convert3;
1756                   convert_z = uiuc_convert(token_value_convert1);
1757                   convert_x = uiuc_convert(token_value_convert2);
1758                   convert_y = uiuc_convert(token_value_convert3);
1759                   /* call 2D File Reader with file name (Cmfade) and
1760                      conversion factors; function returns array of
1761                      elevator deflections (deArray) and corresponding
1762                      alpha (aArray) and delta Cm (CmArray) values and
1763                      max number of terms in alpha arrays (nAlphaArray)
1764                      and deflection array (nde) */
1765                   uiuc_2DdataFileReader(Cmfade,
1766                                         Cmfade_aArray,
1767                                         Cmfade_deArray,
1768                                         Cmfade_CmArray,
1769                                         Cmfade_nAlphaArray,
1770                                         Cmfade_nde);
1771                   aeroPitchParts -> storeCommands (*command_line);
1772                   break;
1773                 }
1774               case Cmfdf_flag:
1775                 {
1776                   Cmfdf = linetoken3;
1777                   token4 >> token_value_convert1;
1778                   token5 >> token_value_convert2;
1779                   convert_y = uiuc_convert(token_value_convert1);
1780                   convert_x = uiuc_convert(token_value_convert2);
1781                   /* call 1D File Reader with file name (Cmfdf) and conversion
1782                      factors; function returns array of dfs (dfArray) and
1783                      corresponding Cm values (CmArray) and max number of
1784                      terms in arrays (ndf) */
1785                   uiuc_1DdataFileReader(Cmfdf,
1786                                         Cmfdf_dfArray,
1787                                         Cmfdf_CmArray,
1788                                         Cmfdf_ndf);
1789                   aeroPitchParts -> storeCommands (*command_line);
1790                   break;
1791                 }
1792               case Cmfadf_flag:
1793                 {
1794                   Cmfadf = linetoken3;
1795                   token4 >> token_value_convert1;
1796                   token5 >> token_value_convert2;
1797                   token6 >> token_value_convert3;
1798                   convert_z = uiuc_convert(token_value_convert1);
1799                   convert_x = uiuc_convert(token_value_convert2);
1800                   convert_y = uiuc_convert(token_value_convert3);
1801                   /* call 2D File Reader with file name (Cmfadf) and
1802                      conversion factors; function returns array of
1803                      flap deflections (dfArray) and corresponding
1804                      alpha (aArray) and delta Cm (CmArray) values and
1805                      max number of terms in alpha arrays (nAlphaArray)
1806                      and deflection array (ndf) */
1807                   uiuc_2DdataFileReader(Cmfadf,
1808                                         Cmfadf_aArray,
1809                                         Cmfadf_dfArray,
1810                                         Cmfadf_CmArray,
1811                                         Cmfadf_nAlphaArray,
1812                                         Cmfadf_ndf);
1813                   aeroPitchParts -> storeCommands (*command_line);
1814                   break;
1815                 }
1816               default:
1817                 {
1818                   uiuc_warnings_errors(2, *command_line);
1819                   break;
1820                 }
1821               };
1822             break;
1823           } // end Cm map
1824
1825
1826         case CY_flag:
1827           {
1828             switch(CY_map[linetoken2])
1829               {
1830               case CYo_flag:
1831                 {
1832                   if (check_float(linetoken3))
1833                     token3 >> token_value;
1834                   else
1835                     uiuc_warnings_errors(1, *command_line);
1836
1837                   CYo = token_value;
1838                   CYo_clean = CYo;
1839                   aeroSideforceParts -> storeCommands (*command_line);
1840                   break;
1841                 }
1842               case CY_beta_flag:
1843                 {
1844                   if (check_float(linetoken3))
1845                     token3 >> token_value;
1846                   else
1847                     uiuc_warnings_errors(1, *command_line);
1848
1849                   CY_beta = token_value;
1850                   CY_beta_clean = CY_beta;
1851                   aeroSideforceParts -> storeCommands (*command_line);
1852                   break;
1853                 }
1854               case CY_p_flag:
1855                 {
1856                   if (check_float(linetoken3))
1857                     token3 >> token_value;
1858                   else
1859                     uiuc_warnings_errors(1, *command_line);
1860
1861                   CY_p = token_value;
1862                   CY_p_clean = CY_p;
1863                   aeroSideforceParts -> storeCommands (*command_line);
1864                   break;
1865                 }
1866               case CY_r_flag:
1867                 {
1868                   if (check_float(linetoken3))
1869                     token3 >> token_value;
1870                   else
1871                     uiuc_warnings_errors(1, *command_line);
1872
1873                   CY_r = token_value;
1874                   CY_r_clean = CY_r;
1875                   aeroSideforceParts -> storeCommands (*command_line);
1876                   break;
1877                 }
1878               case CY_da_flag:
1879                 {
1880                   if (check_float(linetoken3))
1881                     token3 >> token_value;
1882                   else
1883                     uiuc_warnings_errors(1, *command_line);
1884
1885                   CY_da = token_value;
1886                   CY_da_clean = CY_da;
1887                   aeroSideforceParts -> storeCommands (*command_line);
1888                   break;
1889                 }
1890               case CY_dr_flag:
1891                 {
1892                   if (check_float(linetoken3))
1893                     token3 >> token_value;
1894                   else
1895                     uiuc_warnings_errors(2, *command_line);
1896
1897                   CY_dr = token_value;
1898                   CY_dr_clean = CY_dr;
1899                   aeroSideforceParts -> storeCommands (*command_line);
1900                   break;
1901                 }
1902               case CY_dra_flag:
1903                 {
1904                   if (check_float(linetoken3))
1905                     token3 >> token_value;
1906                   else
1907                     uiuc_warnings_errors(2, *command_line);
1908
1909                   CY_dra = token_value;
1910                   CY_dra_clean = CY_dra;
1911                   aeroSideforceParts -> storeCommands (*command_line);
1912                   break;
1913                 }
1914               case CY_bdot_flag:
1915                 {
1916                   if (check_float(linetoken3))
1917                     token3 >> token_value;
1918                   else
1919                     uiuc_warnings_errors(2, *command_line);
1920
1921                   CY_bdot = token_value;
1922                   CY_bdot_clean = CY_bdot;
1923                   aeroSideforceParts -> storeCommands (*command_line);
1924                   break;
1925                 }
1926               case CYfada_flag:
1927                 {
1928                   CYfada = linetoken3;
1929                   token4 >> token_value_convert1;
1930                   token5 >> token_value_convert2;
1931                   token6 >> token_value_convert3;
1932                   convert_z = uiuc_convert(token_value_convert1);
1933                   convert_x = uiuc_convert(token_value_convert2);
1934                   convert_y = uiuc_convert(token_value_convert3);
1935                   /* call 2D File Reader with file name (CYfada) and
1936                      conversion factors; function returns array of
1937                      aileron deflections (daArray) and corresponding
1938                      alpha (aArray) and delta CY (CYArray) values and
1939                      max number of terms in alpha arrays (nAlphaArray)
1940                      and deflection array (nda) */
1941                   uiuc_2DdataFileReader(CYfada,
1942                                         CYfada_aArray,
1943                                         CYfada_daArray,
1944                                         CYfada_CYArray,
1945                                         CYfada_nAlphaArray,
1946                                         CYfada_nda);
1947                   aeroSideforceParts -> storeCommands (*command_line);
1948                   break;
1949                 }
1950               case CYfbetadr_flag:
1951                 {
1952                   CYfbetadr = linetoken3;
1953                   token4 >> token_value_convert1;
1954                   token5 >> token_value_convert2;
1955                   token6 >> token_value_convert3;
1956                   convert_z = uiuc_convert(token_value_convert1);
1957                   convert_x = uiuc_convert(token_value_convert2);
1958                   convert_y = uiuc_convert(token_value_convert3);
1959                   /* call 2D File Reader with file name (CYfbetadr) and
1960                      conversion factors; function returns array of
1961                      rudder deflections (drArray) and corresponding
1962                      beta (betaArray) and delta CY (CYArray) values and
1963                      max number of terms in beta arrays (nBetaArray)
1964                      and deflection array (ndr) */
1965                   uiuc_2DdataFileReader(CYfbetadr,
1966                                         CYfbetadr_betaArray,
1967                                         CYfbetadr_drArray,
1968                                         CYfbetadr_CYArray,
1969                                         CYfbetadr_nBetaArray,
1970                                         CYfbetadr_ndr);
1971                   aeroSideforceParts -> storeCommands (*command_line);
1972                   break;
1973                 }
1974               default:
1975                 {
1976                   uiuc_warnings_errors(2, *command_line);
1977                   break;
1978                 }
1979               };
1980             break;
1981           } // end CY map
1982
1983
1984         case Cl_flag:
1985           {
1986             switch(Cl_map[linetoken2])
1987               {
1988               case Clo_flag:
1989                 {
1990                   if (check_float(linetoken3))
1991                     token3 >> token_value;
1992                   else
1993                     uiuc_warnings_errors(1, *command_line);
1994
1995                   Clo = token_value;
1996                   Clo_clean = Clo;
1997                   aeroRollParts -> storeCommands (*command_line);
1998                   break;
1999                 }
2000               case Cl_beta_flag:
2001                 {
2002                   if (check_float(linetoken3))
2003                     token3 >> token_value;
2004                   else
2005                     uiuc_warnings_errors(1, *command_line);
2006
2007                   Cl_beta = token_value;
2008                   Cl_beta_clean = Cl_beta;
2009                   aeroRollParts -> storeCommands (*command_line);
2010                   break;
2011                 }
2012               case Cl_p_flag:
2013                 {
2014                   if (check_float(linetoken3))
2015                     token3 >> token_value;
2016                   else
2017                     uiuc_warnings_errors(1, *command_line);
2018
2019                   Cl_p = token_value;
2020                   Cl_p_clean = Cl_p;
2021                   aeroRollParts -> storeCommands (*command_line);
2022                   break;
2023                 }
2024               case Cl_r_flag:
2025                 {
2026                   if (check_float(linetoken3))
2027                     token3 >> token_value;
2028                   else
2029                     uiuc_warnings_errors(1, *command_line);
2030
2031                   Cl_r = token_value;
2032                   Cl_r_clean = Cl_r;
2033                   aeroRollParts -> storeCommands (*command_line);
2034                   break;
2035                 }
2036               case Cl_da_flag:
2037                 {
2038                   if (check_float(linetoken3))
2039                     token3 >> token_value;
2040                   else
2041                     uiuc_warnings_errors(1, *command_line);
2042
2043                   Cl_da = token_value;
2044                   Cl_da_clean = Cl_da;
2045                   aeroRollParts -> storeCommands (*command_line);
2046                   break;
2047                 }
2048               case Cl_dr_flag:
2049                 {
2050                   if (check_float(linetoken3))
2051                     token3 >> token_value;
2052                   else
2053                     uiuc_warnings_errors(1, *command_line);
2054
2055                   Cl_dr = token_value;
2056                   Cl_dr_clean = Cl_dr;
2057                   aeroRollParts -> storeCommands (*command_line);
2058                   break;
2059                 }
2060               case Cl_daa_flag:
2061                 {
2062                   if (check_float(linetoken3))
2063                     token3 >> token_value;
2064                   else
2065                     uiuc_warnings_errors(1, *command_line);
2066
2067                   Cl_daa = token_value;
2068                   Cl_daa_clean = Cl_daa;
2069                   aeroRollParts -> storeCommands (*command_line);
2070                   break;
2071                 }
2072               case Clfada_flag:
2073                 {
2074                   Clfada = linetoken3;
2075                   token4 >> token_value_convert1;
2076                   token5 >> token_value_convert2;
2077                   token6 >> token_value_convert3;
2078                   convert_z = uiuc_convert(token_value_convert1);
2079                   convert_x = uiuc_convert(token_value_convert2);
2080                   convert_y = uiuc_convert(token_value_convert3);
2081                   /* call 2D File Reader with file name (Clfada) and
2082                      conversion factors; function returns array of
2083                      aileron deflections (daArray) and corresponding
2084                      alpha (aArray) and delta Cl (ClArray) values and
2085                      max number of terms in alpha arrays (nAlphaArray)
2086                      and deflection array (nda) */
2087                   uiuc_2DdataFileReader(Clfada,
2088                                         Clfada_aArray,
2089                                         Clfada_daArray,
2090                                         Clfada_ClArray,
2091                                         Clfada_nAlphaArray,
2092                                         Clfada_nda);
2093                   aeroRollParts -> storeCommands (*command_line);
2094                   break;
2095                 }
2096               case Clfbetadr_flag:
2097                 {
2098                   Clfbetadr = linetoken3;
2099                   token4 >> token_value_convert1;
2100                   token5 >> token_value_convert2;
2101                   token6 >> token_value_convert3;
2102                   convert_z = uiuc_convert(token_value_convert1);
2103                   convert_x = uiuc_convert(token_value_convert2);
2104                   convert_y = uiuc_convert(token_value_convert3);
2105                   /* call 2D File Reader with file name (Clfbetadr) and
2106                      conversion factors; function returns array of
2107                      rudder deflections (drArray) and corresponding
2108                      beta (betaArray) and delta Cl (ClArray) values and
2109                      max number of terms in beta arrays (nBetaArray)
2110                      and deflection array (ndr) */
2111                   uiuc_2DdataFileReader(Clfbetadr,
2112                                         Clfbetadr_betaArray,
2113                                         Clfbetadr_drArray,
2114                                         Clfbetadr_ClArray,
2115                                         Clfbetadr_nBetaArray,
2116                                         Clfbetadr_ndr);
2117                   aeroRollParts -> storeCommands (*command_line);
2118                   break;
2119                 }
2120               default:
2121                 {
2122                   uiuc_warnings_errors(2, *command_line);
2123           break;
2124                 }
2125               };
2126             break;
2127           } // end Cl map
2128
2129
2130         case Cn_flag:
2131           {
2132             switch(Cn_map[linetoken2])
2133               {
2134               case Cno_flag:
2135                 {
2136                   if (check_float(linetoken3))
2137                     token3 >> token_value;
2138                   else
2139                     uiuc_warnings_errors(1, *command_line);
2140
2141                   Cno = token_value;
2142                   Cno_clean = Cno;
2143                   aeroYawParts -> storeCommands (*command_line);
2144                   break;
2145                 }
2146               case Cn_beta_flag:
2147                 {
2148                   if (check_float(linetoken3))
2149                     token3 >> token_value;
2150                   else
2151                     uiuc_warnings_errors(1, *command_line);
2152
2153                   Cn_beta = token_value;
2154                   Cn_beta_clean = Cn_beta;
2155                   aeroYawParts -> storeCommands (*command_line);
2156                   break;
2157                 }
2158               case Cn_p_flag:
2159                 {
2160                   if (check_float(linetoken3))
2161                     token3 >> token_value;
2162                   else
2163                     uiuc_warnings_errors(1, *command_line);
2164
2165                   Cn_p = token_value;
2166                   Cn_p_clean = Cn_p;
2167                   aeroYawParts -> storeCommands (*command_line);
2168                   break;
2169                 }
2170               case Cn_r_flag:
2171                 {
2172                   if (check_float(linetoken3))
2173                     token3 >> token_value;
2174                   else
2175                     uiuc_warnings_errors(1, *command_line);
2176
2177                   Cn_r = token_value;
2178                   Cn_r_clean = Cn_r;
2179                   aeroYawParts -> storeCommands (*command_line);
2180                   break;
2181                 }
2182               case Cn_da_flag:
2183                 {
2184                   if (check_float(linetoken3))
2185                     token3 >> token_value;
2186                   else
2187                     uiuc_warnings_errors(1, *command_line);
2188
2189                   Cn_da = token_value;
2190                   Cn_da_clean = Cn_da;
2191                   aeroYawParts -> storeCommands (*command_line);
2192                   break;
2193                 }
2194               case Cn_dr_flag:
2195                 {
2196                   if (check_float(linetoken3))
2197                     token3 >> token_value;
2198                   else
2199                     uiuc_warnings_errors(1, *command_line);
2200
2201                   Cn_dr = token_value;
2202                   Cn_dr_clean = Cn_dr;
2203                   aeroYawParts -> storeCommands (*command_line);
2204                   break;
2205                 }
2206               case Cn_q_flag:
2207                 {
2208                   if (check_float(linetoken3))
2209                     token3 >> token_value;
2210                   else
2211                     uiuc_warnings_errors(1, *command_line);
2212
2213                   Cn_q = token_value;
2214                   Cn_q_clean = Cn_q;
2215                   aeroYawParts -> storeCommands (*command_line);
2216                   break;
2217                 }
2218               case Cn_b3_flag:
2219                 {
2220                   if (check_float(linetoken3))
2221                     token3 >> token_value;
2222                   else
2223                     uiuc_warnings_errors(1, *command_line);
2224
2225                   Cn_b3 = token_value;
2226                   Cn_b3_clean = Cn_b3;
2227                   aeroYawParts -> storeCommands (*command_line);
2228                   break;
2229                 }
2230               case Cnfada_flag:
2231                 {
2232                   Cnfada = linetoken3;
2233                   token4 >> token_value_convert1;
2234                   token5 >> token_value_convert2;
2235                   token6 >> token_value_convert3;
2236                   convert_z = uiuc_convert(token_value_convert1);
2237                   convert_x = uiuc_convert(token_value_convert2);
2238                   convert_y = uiuc_convert(token_value_convert3);
2239                   /* call 2D File Reader with file name (Cnfada) and
2240                      conversion factors; function returns array of
2241                      aileron deflections (daArray) and corresponding
2242                      alpha (aArray) and delta Cn (CnArray) values and
2243                      max number of terms in alpha arrays (nAlphaArray)
2244                      and deflection array (nda) */
2245                   uiuc_2DdataFileReader(Cnfada,
2246                                         Cnfada_aArray,
2247                                         Cnfada_daArray,
2248                                         Cnfada_CnArray,
2249                                         Cnfada_nAlphaArray,
2250                                         Cnfada_nda);
2251                   aeroYawParts -> storeCommands (*command_line);
2252                   break;
2253                 }
2254               case Cnfbetadr_flag:
2255                 {
2256                   Cnfbetadr = linetoken3;
2257                   token4 >> token_value_convert1;
2258                   token5 >> token_value_convert2;
2259                   token6 >> token_value_convert3;
2260                   convert_z = uiuc_convert(token_value_convert1);
2261                   convert_x = uiuc_convert(token_value_convert2);
2262                   convert_y = uiuc_convert(token_value_convert3);
2263                   /* call 2D File Reader with file name (Cnfbetadr) and
2264                      conversion factors; function returns array of
2265                      rudder deflections (drArray) and corresponding
2266                      beta (betaArray) and delta Cn (CnArray) values and
2267                      max number of terms in beta arrays (nBetaArray)
2268                      and deflection array (ndr) */
2269                   uiuc_2DdataFileReader(Cnfbetadr,
2270                                         Cnfbetadr_betaArray,
2271                                         Cnfbetadr_drArray,
2272                                         Cnfbetadr_CnArray,
2273                                         Cnfbetadr_nBetaArray,
2274                                         Cnfbetadr_ndr);
2275                   aeroYawParts -> storeCommands (*command_line);
2276                   break;
2277                 }
2278               default:
2279                 {
2280                   uiuc_warnings_errors(2, *command_line);
2281                   break;
2282                 }
2283               };
2284             break;
2285           } // end Cn map
2286
2287
2288         case gear_flag:
2289           {
2290             int index;
2291             token3 >> index;
2292             if (index < 0 || index >= 16)
2293               uiuc_warnings_errors(1, *command_line);
2294             switch(gear_map[linetoken2])
2295               {
2296               case Dx_gear_flag:
2297                 {
2298                   if (check_float(linetoken3))
2299                     token4 >> token_value;
2300                   else
2301                     uiuc_warnings_errors(1, *command_line);
2302                   D_gear_v[index][0] = token_value;
2303                   gear_model[index] = true;
2304                   break;
2305                 }
2306               case Dy_gear_flag:
2307                 {
2308                   if (check_float(linetoken3))
2309                     token4 >> token_value;
2310                   else
2311                     uiuc_warnings_errors(1, *command_line);
2312                   D_gear_v[index][1] = token_value;
2313                   gear_model[index] = true;
2314                   break;
2315                 }
2316               case Dz_gear_flag:
2317                 {
2318                   if (check_float(linetoken3))
2319                     token4 >> token_value;
2320                   else
2321                     uiuc_warnings_errors(1, *command_line);
2322                   D_gear_v[index][2] = token_value;
2323                   gear_model[index] = true;
2324                   break;
2325                 }
2326               case cgear_flag:
2327                 {
2328                   if (check_float(linetoken3))
2329                     token4 >> token_value;
2330                   else
2331                     uiuc_warnings_errors(1, *command_line);
2332                   cgear[index] = token_value;
2333                   gear_model[index] = true;
2334                   break;
2335                 }
2336               case kgear_flag:
2337                 {
2338                   if (check_float(linetoken3))
2339                     token4 >> token_value;
2340                   else
2341                     uiuc_warnings_errors(1, *command_line);
2342                   kgear[index] = token_value;
2343                   gear_model[index] = true;
2344                   break;
2345                 }
2346               case muGear_flag:
2347                 {
2348                   if (check_float(linetoken3))
2349                     token4 >> token_value;
2350                   else
2351                     uiuc_warnings_errors(1, *command_line);
2352                   muGear[index] = token_value;
2353                   gear_model[index] = true;
2354                   break;
2355                 }
2356               case strutLength_flag:
2357                 {
2358                   if (check_float(linetoken3))
2359                     token4 >> token_value;
2360                   else
2361                     uiuc_warnings_errors(1, *command_line);
2362                   strutLength[index] = token_value;
2363                   gear_model[index] = true;
2364                   break;
2365                 }
2366               default:
2367                 {
2368                   uiuc_warnings_errors(2, *command_line);
2369                   break;
2370                 }
2371               };
2372             break;
2373           } // end gear map
2374
2375
2376         case ice_flag:
2377           {
2378             switch(ice_map[linetoken2])
2379               {
2380               case iceTime_flag:
2381                 {
2382                   if (check_float(linetoken3))
2383                     token3 >> token_value;
2384
2385                   else
2386                     uiuc_warnings_errors(1, *command_line);
2387
2388                   ice_model = true;
2389                   iceTime = token_value;
2390                   break;
2391                 }
2392               case transientTime_flag:
2393                 {
2394                   if (check_float(linetoken3))
2395                     token3 >> token_value;
2396                   else
2397                     uiuc_warnings_errors(1, *command_line);
2398
2399                   transientTime = token_value;
2400                   break;
2401                 }
2402               case eta_ice_final_flag:
2403                 {
2404                   if (check_float(linetoken3))
2405                     token3 >> token_value;
2406                   else
2407                     uiuc_warnings_errors(1, *command_line);
2408
2409                   eta_ice_final = token_value;
2410                   break;
2411                 }
2412               case beta_probe_wing_flag:
2413                 {
2414                   if (check_float(linetoken3))
2415                     token3 >> token_value;
2416                   else
2417                     uiuc_warnings_errors(1, *command_line);
2418
2419                   beta_model = true;
2420                   x_probe_wing = token_value;
2421                   break;
2422                 }
2423               case beta_probe_tail_flag:
2424                 {
2425                   if (check_float(linetoken3))
2426                     token3 >> token_value;
2427                   else
2428                     uiuc_warnings_errors(1, *command_line);
2429
2430                   beta_model = true;
2431                   x_probe_tail = token_value;
2432                   break;
2433                 }
2434               case kCDo_flag:
2435                 {
2436                   if (check_float(linetoken3))
2437                     token3 >> token_value;
2438                   else
2439                     uiuc_warnings_errors(1, *command_line);
2440
2441                   kCDo = token_value;
2442                   break;
2443                 }
2444               case kCDK_flag:
2445                 {
2446                   if (check_float(linetoken3))
2447                     token3 >> token_value;
2448                   else
2449                     uiuc_warnings_errors(1, *command_line);
2450
2451                   kCDK = token_value;
2452                   break;
2453                 }
2454               case kCD_a_flag:
2455                 {
2456                   if (check_float(linetoken3))
2457                     token3 >> token_value;
2458                   else
2459                     uiuc_warnings_errors(1, *command_line);
2460
2461                   kCD_a = token_value;
2462                   break;
2463                 }
2464               case kCD_adot_flag:
2465                 {
2466                   if (check_float(linetoken3))
2467                     token3 >> token_value;
2468                   else
2469                     uiuc_warnings_errors(1, *command_line);
2470
2471                   kCD_adot = token_value;
2472                   break;
2473                 }
2474               case kCD_q_flag:
2475                 {
2476                   if (check_float(linetoken3))
2477                     token3 >> token_value;
2478                   else
2479                     uiuc_warnings_errors(1, *command_line);
2480
2481                   kCD_q = token_value;
2482                   break;
2483                 }
2484               case kCD_de_flag:
2485                 {
2486                   if (check_float(linetoken3))
2487                     token3 >> token_value;
2488                   else
2489                     uiuc_warnings_errors(1, *command_line);
2490
2491                   kCD_de = token_value;
2492                   break;
2493                 }
2494               case kCXo_flag:
2495                 {
2496                   if (check_float(linetoken3))
2497                     token3 >> token_value;
2498                   else
2499                     uiuc_warnings_errors(1, *command_line);
2500
2501                   kCXo = token_value;
2502                   break;
2503                 }
2504               case kCXK_flag:
2505                 {
2506                   if (check_float(linetoken3))
2507                     token3 >> token_value;
2508                   else
2509                     uiuc_warnings_errors(1, *command_line);
2510
2511                   kCXK = token_value;
2512                   break;
2513                 }
2514               case kCX_a_flag:
2515                 {
2516                   if (check_float(linetoken3))
2517                     token3 >> token_value;
2518                   else
2519                     uiuc_warnings_errors(1, *command_line);
2520
2521                   kCX_a = token_value;
2522                   break;
2523                 }
2524               case kCX_a2_flag:
2525                 {
2526                   if (check_float(linetoken3))
2527                     token3 >> token_value;
2528                   else
2529                     uiuc_warnings_errors(1, *command_line);
2530
2531                   kCX_a2 = token_value;
2532                   break;
2533                 }
2534               case kCX_a3_flag:
2535                 {
2536                   if (check_float(linetoken3))
2537                     token3 >> token_value;
2538                   else
2539                     uiuc_warnings_errors(1, *command_line);
2540
2541                   kCX_a3 = token_value;
2542                   break;
2543                 }
2544               case kCX_adot_flag:
2545                 {
2546                   if (check_float(linetoken3))
2547                     token3 >> token_value;
2548                   else
2549                     uiuc_warnings_errors(1, *command_line);
2550
2551                   kCX_adot = token_value;
2552                   break;
2553                 }
2554               case kCX_q_flag:
2555                 {
2556                   if (check_float(linetoken3))
2557                     token3 >> token_value;
2558                   else
2559                     uiuc_warnings_errors(1, *command_line);
2560
2561                   kCX_q = token_value;
2562                   break;
2563                 }
2564               case kCX_de_flag:
2565                 {
2566                   if (check_float(linetoken3))
2567                     token3 >> token_value;
2568                   else
2569                     uiuc_warnings_errors(1, *command_line);
2570
2571                   kCX_de = token_value;
2572                   break;
2573                 }
2574               case kCX_dr_flag:
2575                 {
2576                   if (check_float(linetoken3))
2577                     token3 >> token_value;
2578                   else
2579                     uiuc_warnings_errors(1, *command_line);
2580
2581                   kCX_dr = token_value;
2582                   break;
2583                 }
2584               case kCX_df_flag:
2585                 {
2586                   if (check_float(linetoken3))
2587                     token3 >> token_value;
2588                   else
2589                     uiuc_warnings_errors(1, *command_line);
2590
2591                   kCX_df = token_value;
2592                   break;
2593                 }
2594               case kCX_adf_flag:
2595                 {
2596                   if (check_float(linetoken3))
2597                     token3 >> token_value;
2598                   else
2599                     uiuc_warnings_errors(1, *command_line);
2600
2601                   kCX_adf = token_value;
2602                   break;
2603                 }
2604               case kCLo_flag:
2605                 {
2606                   if (check_float(linetoken3))
2607                     token3 >> token_value;
2608                   else
2609                     uiuc_warnings_errors(1, *command_line);
2610
2611                   kCLo = token_value;
2612                   break;
2613                 }
2614               case kCL_a_flag:
2615                 {
2616                   if (check_float(linetoken3))
2617                     token3 >> token_value;
2618                   else
2619                     uiuc_warnings_errors(1, *command_line);
2620
2621                   kCL_a = token_value;
2622                   break;
2623                 }
2624               case kCL_adot_flag:
2625                 {
2626                   if (check_float(linetoken3))
2627                     token3 >> token_value;
2628                   else
2629                     uiuc_warnings_errors(1, *command_line);
2630
2631                   kCL_adot = token_value;
2632                   break;
2633                 }
2634               case kCL_q_flag:
2635                 {
2636                   if (check_float(linetoken3))
2637                     token3 >> token_value;
2638                   else
2639                     uiuc_warnings_errors(1, *command_line);
2640
2641                   kCL_q = token_value;
2642                   break;
2643                 }
2644               case kCL_de_flag:
2645                 {
2646                   if (check_float(linetoken3))
2647                     token3 >> token_value;
2648                   else
2649                     uiuc_warnings_errors(1, *command_line);
2650
2651                   kCL_de = token_value;
2652                   break;
2653                 }
2654               case kCZo_flag:
2655                 {
2656                   if (check_float(linetoken3))
2657                     token3 >> token_value;
2658                   else
2659                     uiuc_warnings_errors(1, *command_line);
2660
2661                   kCZo = token_value;
2662                   break;
2663                 }
2664               case kCZ_a_flag:
2665                 {
2666                   if (check_float(linetoken3))
2667                     token3 >> token_value;
2668                   else
2669                     uiuc_warnings_errors(1, *command_line);
2670
2671                   kCZ_a = token_value;
2672                   break;
2673                 }
2674               case kCZ_a2_flag:
2675                 {
2676                   if (check_float(linetoken3))
2677                     token3 >> token_value;
2678                   else
2679                     uiuc_warnings_errors(1, *command_line);
2680
2681                   kCZ_a2 = token_value;
2682                   break;
2683                 }
2684               case kCZ_a3_flag:
2685                 {
2686                   if (check_float(linetoken3))
2687                     token3 >> token_value;
2688                   else
2689                     uiuc_warnings_errors(1, *command_line);
2690
2691                   kCZ_a3 = token_value;
2692                   break;
2693                 }
2694               case kCZ_adot_flag:
2695                 {
2696                   if (check_float(linetoken3))
2697                     token3 >> token_value;
2698                   else
2699                     uiuc_warnings_errors(1, *command_line);
2700
2701                   kCZ_adot = token_value;
2702                   break;
2703                 }
2704               case kCZ_q_flag:
2705                 {
2706                   if (check_float(linetoken3))
2707                     token3 >> token_value;
2708                   else
2709                     uiuc_warnings_errors(1, *command_line);
2710
2711                   kCZ_q = token_value;
2712                   break;
2713                 }
2714               case kCZ_de_flag:
2715                 {
2716                   if (check_float(linetoken3))
2717                     token3 >> token_value;
2718                   else
2719                     uiuc_warnings_errors(1, *command_line);
2720
2721                   kCZ_de = token_value;
2722                   break;
2723                 }
2724               case kCZ_deb2_flag:
2725                 {
2726                   if (check_float(linetoken3))
2727                     token3 >> token_value;
2728                   else
2729                     uiuc_warnings_errors(1, *command_line);
2730
2731                   kCZ_deb2 = token_value;
2732                   break;
2733                 }
2734               case kCZ_df_flag:
2735                 {
2736                   if (check_float(linetoken3))
2737                     token3 >> token_value;
2738                   else
2739                     uiuc_warnings_errors(1, *command_line);
2740
2741                   kCZ_df = token_value;
2742                   break;
2743                 }
2744               case kCZ_adf_flag:
2745                 {
2746                   if (check_float(linetoken3))
2747                     token3 >> token_value;
2748                   else
2749                     uiuc_warnings_errors(1, *command_line);
2750
2751                   kCZ_adf = token_value;
2752                   break;
2753                 }
2754               case kCmo_flag:
2755                 {
2756                   if (check_float(linetoken3))
2757                     token3 >> token_value;
2758                   else
2759                     uiuc_warnings_errors(1, *command_line);
2760
2761                   kCmo = token_value;
2762                   break;
2763                 }
2764               case kCm_a_flag:
2765                 {
2766                   if (check_float(linetoken3))
2767                     token3 >> token_value;
2768                   else
2769                     uiuc_warnings_errors(1, *command_line);
2770
2771                   kCm_a = token_value;
2772                   break;
2773                 }
2774               case kCm_a2_flag:
2775                 {
2776                   if (check_float(linetoken3))
2777                     token3 >> token_value;
2778                   else
2779                     uiuc_warnings_errors(1, *command_line);
2780
2781                   kCm_a2 = token_value;
2782                   break;
2783                 }
2784               case kCm_adot_flag:
2785                 {
2786                   if (check_float(linetoken3))
2787                     token3 >> token_value;
2788                   else
2789                     uiuc_warnings_errors(1, *command_line);
2790
2791                   kCm_adot = token_value;
2792                   break;
2793                 }
2794               case kCm_q_flag:
2795                 {
2796                   if (check_float(linetoken3))
2797                     token3 >> token_value;
2798                   else
2799                     uiuc_warnings_errors(1, *command_line);
2800
2801                   kCm_q = token_value;
2802                   break;
2803                 }
2804               case kCm_de_flag:
2805                 {
2806                   if (check_float(linetoken3))
2807                     token3 >> token_value;
2808                   else
2809                     uiuc_warnings_errors(1, *command_line);
2810
2811                   kCm_de = token_value;
2812                   break;
2813                 }
2814               case kCm_b2_flag:
2815                 {
2816                   if (check_float(linetoken3))
2817                     token3 >> token_value;
2818                   else
2819                     uiuc_warnings_errors(1, *command_line);
2820
2821                   kCm_b2 = token_value;
2822                   break;
2823                 }
2824               case kCm_r_flag:
2825                 {
2826                   if (check_float(linetoken3))
2827                     token3 >> token_value;
2828                   else
2829                     uiuc_warnings_errors(1, *command_line);
2830
2831                   kCm_r = token_value;
2832                   break;
2833                 }
2834               case kCm_df_flag:
2835                 {
2836                   if (check_float(linetoken3))
2837                     token3 >> token_value;
2838                   else
2839                     uiuc_warnings_errors(1, *command_line);
2840
2841                   kCm_df = token_value;
2842                   break;
2843                 }
2844               case kCYo_flag:
2845                 {
2846                   if (check_float(linetoken3))
2847                     token3 >> token_value;
2848                   else
2849                     uiuc_warnings_errors(1, *command_line);
2850
2851                   kCYo = token_value;
2852                   break;
2853                 }
2854               case kCY_beta_flag:
2855                 {
2856                   if (check_float(linetoken3))
2857                     token3 >> token_value;
2858                   else
2859                     uiuc_warnings_errors(1, *command_line);
2860
2861                   kCY_beta = token_value;
2862                   break;
2863                 }
2864               case kCY_p_flag:
2865                 {
2866                   if (check_float(linetoken3))
2867                     token3 >> token_value;
2868                   else
2869                     uiuc_warnings_errors(1, *command_line);
2870
2871                   kCY_p = token_value;
2872                   break;
2873                 }
2874               case kCY_r_flag:
2875                 {
2876                   if (check_float(linetoken3))
2877                     token3 >> token_value;
2878                   else
2879                     uiuc_warnings_errors(1, *command_line);
2880
2881                   kCY_r = token_value;
2882                   break;
2883                 }
2884               case kCY_da_flag:
2885                 {
2886                   if (check_float(linetoken3))
2887                     token3 >> token_value;
2888                   else
2889                     uiuc_warnings_errors(1, *command_line);
2890
2891                   kCY_da = token_value;
2892                   break;
2893                 }
2894               case kCY_dr_flag:
2895                 {
2896                   if (check_float(linetoken3))
2897                     token3 >> token_value;
2898                   else
2899                     uiuc_warnings_errors(1, *command_line);
2900
2901                   kCY_dr = token_value;
2902                   break;
2903                 }
2904               case kCY_dra_flag:
2905                 {
2906                   if (check_float(linetoken3))
2907                     token3 >> token_value;
2908                   else
2909                     uiuc_warnings_errors(1, *command_line);
2910
2911                   kCY_dra = token_value;
2912                   break;
2913                 }
2914               case kCY_bdot_flag:
2915                 {
2916                   if (check_float(linetoken3))
2917                     token3 >> token_value;
2918                   else
2919                     uiuc_warnings_errors(1, *command_line);
2920
2921                   kCY_bdot = token_value;
2922                   break;
2923                 }
2924               case kClo_flag:
2925                 {
2926                   if (check_float(linetoken3))
2927                     token3 >> token_value;
2928                   else
2929                     uiuc_warnings_errors(1, *command_line);
2930
2931                   kClo = token_value;
2932                   break;
2933                 }
2934               case kCl_beta_flag:
2935                 {
2936                   if (check_float(linetoken3))
2937                     token3 >> token_value;
2938                   else
2939                     uiuc_warnings_errors(1, *command_line);
2940
2941                   kCl_beta = token_value;
2942                   break;
2943                 }
2944               case kCl_p_flag:
2945                 {
2946                   if (check_float(linetoken3))
2947                     token3 >> token_value;
2948                   else
2949                     uiuc_warnings_errors(1, *command_line);
2950
2951                   kCl_p = token_value;
2952                   break;
2953                 }
2954               case kCl_r_flag:
2955                 {
2956                   if (check_float(linetoken3))
2957                     token3 >> token_value;
2958                   else
2959                     uiuc_warnings_errors(1, *command_line);
2960
2961                   kCl_r = token_value;
2962                   break;
2963                 }
2964               case kCl_da_flag:
2965                 {
2966                   if (check_float(linetoken3))
2967                     token3 >> token_value;
2968                   else
2969                     uiuc_warnings_errors(1, *command_line);
2970
2971                   kCl_da = token_value;
2972                   break;
2973                 }
2974               case kCl_dr_flag:
2975                 {
2976                   if (check_float(linetoken3))
2977                     token3 >> token_value;
2978                   else
2979                     uiuc_warnings_errors(1, *command_line);
2980
2981                   kCl_dr = token_value;
2982                   break;
2983                 }
2984               case kCl_daa_flag:
2985                 {
2986                   if (check_float(linetoken3))
2987                     token3 >> token_value;
2988                   else
2989                     uiuc_warnings_errors(1, *command_line);
2990
2991                   kCl_daa = token_value;
2992                   break;
2993                 }
2994               case kCno_flag:
2995                 {
2996                   if (check_float(linetoken3))
2997                     token3 >> token_value;
2998                   else
2999                     uiuc_warnings_errors(1, *command_line);
3000
3001                   kCno = token_value;
3002                   break;
3003                 }
3004               case kCn_beta_flag:
3005                 {
3006                   if (check_float(linetoken3))
3007                     token3 >> token_value;
3008                   else
3009                     uiuc_warnings_errors(1, *command_line);
3010
3011                   kCn_beta = token_value;
3012                   break;
3013                 }
3014               case kCn_p_flag:
3015                 {
3016                   if (check_float(linetoken3))
3017                     token3 >> token_value;
3018                   else
3019                     uiuc_warnings_errors(1, *command_line);
3020
3021                   kCn_p = token_value;
3022                   break;
3023                 }
3024               case kCn_r_flag:
3025                 {
3026                   if (check_float(linetoken3))
3027                     token3 >> token_value;
3028                   else
3029                     uiuc_warnings_errors(1, *command_line);
3030
3031                   kCn_r = token_value;
3032                   break;
3033                 }
3034               case kCn_da_flag:
3035                 {
3036                   if (check_float(linetoken3))
3037                     token3 >> token_value;
3038                   else
3039                     uiuc_warnings_errors(1, *command_line);
3040
3041                   kCn_da = token_value;
3042                   break;
3043                 }
3044               case kCn_dr_flag:
3045                 {
3046                   if (check_float(linetoken3))
3047                     token3 >> token_value;
3048                   else
3049                     uiuc_warnings_errors(1, *command_line);
3050
3051                   kCn_dr = token_value;
3052                   break;
3053                 }
3054               case kCn_q_flag:
3055                 {
3056                   if (check_float(linetoken3))
3057                     token3 >> token_value;
3058                   else
3059                     uiuc_warnings_errors(1, *command_line);
3060
3061                   kCn_q = token_value;
3062                   break;
3063                 }
3064               case kCn_b3_flag:
3065                 {
3066                   if (check_float(linetoken3))
3067                     token3 >> token_value;
3068                   else
3069                     uiuc_warnings_errors(1, *command_line);
3070
3071                   kCn_b3 = token_value;
3072                   break;
3073                 }
3074               default:
3075                 {
3076                   uiuc_warnings_errors(2, *command_line);
3077                   break;
3078                 }
3079               };
3080             break;
3081           } // end ice map
3082
3083
3084         case fog_flag:
3085           {
3086             switch(fog_map[linetoken2])
3087               {
3088               case fog_segments_flag:
3089                 {
3090                   if (check_float(linetoken3))
3091                     token3 >> token_value_convert1;
3092                   else
3093                     uiuc_warnings_errors(1, *command_line);
3094
3095                   if (token_value_convert1 < 1 || token_value_convert1 > 100)
3096                     uiuc_warnings_errors(1, *command_line);
3097
3098                   fog_field = true;
3099                   fog_point_index = 0;
3100                   delete[] fog_time;
3101                   delete[] fog_value;
3102                   fog_segments = token_value_convert1;
3103                   fog_time = new double[fog_segments+1];
3104                   fog_time[0] = 0.0;
3105                   fog_value = new int[fog_segments+1];
3106                   fog_value[0] = 0;
3107
3108                   break;
3109                 }
3110               case fog_point_flag:
3111                 {
3112                   if (check_float(linetoken3))
3113                     token3 >> token_value;
3114                   else
3115                     uiuc_warnings_errors(1, *command_line);
3116
3117                   if (token_value < 0.1)
3118                     uiuc_warnings_errors(1, *command_line);
3119
3120                   if (check_float(linetoken4))
3121                     token4 >> token_value_convert1;
3122                   else
3123                     uiuc_warnings_errors(1, *command_line);
3124
3125                   if (token_value_convert1 < -1000 || token_value_convert1 > 1000)
3126                     uiuc_warnings_errors(1, *command_line);
3127
3128                   if (fog_point_index == fog_segments || fog_point_index == -1)
3129                     uiuc_warnings_errors(1, *command_line);
3130
3131                   fog_point_index++;
3132                   fog_time[fog_point_index] = token_value;
3133                   fog_value[fog_point_index] = token_value_convert1;
3134
3135                   break;
3136                 }
3137               default:
3138                 {
3139                   uiuc_warnings_errors(2, *command_line);
3140                   break;
3141                 }
3142               };
3143             break;
3144           } // end fog map
3145
3146
3147
3148
3149
3150
3151         case record_flag:
3152           {
3153             static int fout_flag=0;
3154             if (fout_flag==0)
3155             {
3156               fout_flag=-1;
3157               fout.open("uiuc_record.dat");
3158             }
3159             switch(record_map[linetoken2])
3160               {
3161                 /************************* Time ************************/
3162               case Simtime_record:
3163                 {
3164                   recordParts -> storeCommands (*command_line);
3165                   break;
3166                 }
3167               case dt_record:
3168                 {
3169                   recordParts -> storeCommands (*command_line);
3170                   break;
3171                 }
3172
3173                 /************************* Mass ************************/
3174               case Weight_record:
3175                 {
3176                   recordParts -> storeCommands (*command_line);
3177                   break;
3178                 }
3179               case Mass_record:
3180                 {
3181                   recordParts -> storeCommands (*command_line);
3182                   break;
3183                 }
3184               case I_xx_record:
3185                 {
3186                   recordParts -> storeCommands (*command_line);
3187                   break;
3188                 }
3189               case I_yy_record:
3190                 {
3191                   recordParts -> storeCommands (*command_line);
3192                   break;
3193                 }
3194               case I_zz_record:
3195                 {
3196                   recordParts -> storeCommands (*command_line);
3197                   break;
3198                 }
3199               case I_xz_record:
3200                 {
3201                   recordParts -> storeCommands (*command_line);
3202                   break;
3203                 }
3204
3205                 /*********************** Geometry **********************/
3206               case Dx_pilot_record:
3207                 {
3208                   recordParts -> storeCommands (*command_line);
3209                   break;
3210                 }
3211               case Dy_pilot_record:
3212                 {
3213                   recordParts -> storeCommands (*command_line);
3214                   break;
3215                 }
3216               case Dz_pilot_record:
3217                 {
3218                   recordParts -> storeCommands (*command_line);
3219                   break;
3220                 }
3221               case Dx_cg_record:
3222                 {
3223                   recordParts -> storeCommands (*command_line);
3224                   break;
3225                 }
3226               case Dy_cg_record:
3227                 {
3228                   recordParts -> storeCommands (*command_line);
3229                   break;
3230                 }
3231               case Dz_cg_record:
3232                 {
3233                   recordParts -> storeCommands (*command_line);
3234                   break;
3235                 }
3236
3237                 /********************** Positions **********************/
3238               case Lat_geocentric_record:
3239                 {
3240                   recordParts -> storeCommands (*command_line);
3241                   break;
3242                 }
3243               case Lon_geocentric_record:
3244                 {
3245                   recordParts -> storeCommands (*command_line);
3246                   break;
3247                 }
3248               case Radius_to_vehicle_record:
3249                 {
3250                   recordParts -> storeCommands (*command_line);
3251                   break;
3252                 }
3253               case Latitude_record:
3254                 {
3255                   recordParts -> storeCommands (*command_line);
3256                   break;
3257                 }
3258               case Longitude_record:
3259                 {
3260                   recordParts -> storeCommands (*command_line);
3261                   break;
3262                 }
3263               case Altitude_record:
3264                 {
3265                   recordParts -> storeCommands (*command_line);
3266                   break;
3267                 }
3268               case Phi_record:
3269                 {
3270                   recordParts -> storeCommands (*command_line);
3271                   break;
3272                 }
3273               case Theta_record:
3274                 {
3275                   recordParts -> storeCommands (*command_line);
3276                   break;
3277                 }
3278               case Psi_record:
3279                 {
3280                   recordParts -> storeCommands (*command_line);
3281                   break;
3282                 }
3283
3284                 /******************** Accelerations ********************/
3285               case V_dot_north_record:
3286                 {
3287                   recordParts -> storeCommands (*command_line);
3288                   break;
3289                 }
3290               case V_dot_east_record:
3291                 {
3292                   recordParts -> storeCommands (*command_line);
3293                   break;
3294                 }
3295               case V_dot_down_record:
3296                 {
3297                   recordParts -> storeCommands (*command_line);
3298                   break;
3299                 }
3300               case U_dot_body_record:
3301                 {
3302                   recordParts -> storeCommands (*command_line);
3303                   break;
3304                 }
3305               case V_dot_body_record:
3306                 {
3307                   recordParts -> storeCommands (*command_line);
3308                   break;
3309                 }
3310               case W_dot_body_record:
3311                 {
3312                   recordParts -> storeCommands (*command_line);
3313                   break;
3314                 }
3315               case A_X_pilot_record:
3316                 {
3317                   recordParts -> storeCommands (*command_line);
3318                   break;
3319                 }
3320               case A_Y_pilot_record:
3321                 {
3322                   recordParts -> storeCommands (*command_line);
3323                   break;
3324                 }
3325               case A_Z_pilot_record:
3326                 {
3327                   recordParts -> storeCommands (*command_line);
3328                   break;
3329                 }
3330               case A_X_cg_record:
3331                 {
3332                   recordParts -> storeCommands (*command_line);
3333                   break;
3334                 }
3335               case A_Y_cg_record:
3336                 {
3337                   recordParts -> storeCommands (*command_line);
3338                   break;
3339                 }
3340               case A_Z_cg_record:
3341                 {
3342                   recordParts -> storeCommands (*command_line);
3343                   break;
3344                 }
3345               case N_X_pilot_record:
3346                 {
3347                   recordParts -> storeCommands (*command_line);
3348                   break;
3349                 }
3350               case N_Y_pilot_record:
3351                 {
3352                   recordParts -> storeCommands (*command_line);
3353                   break;
3354                 }
3355               case N_Z_pilot_record:
3356                 {
3357                   recordParts -> storeCommands (*command_line);
3358                   break;
3359                 }
3360               case N_X_cg_record:
3361                 {
3362                   recordParts -> storeCommands (*command_line);
3363                   break;
3364                 }
3365               case N_Y_cg_record:
3366                 {
3367                   recordParts -> storeCommands (*command_line);
3368                   break;
3369                 }
3370               case N_Z_cg_record:
3371                 {
3372                   recordParts -> storeCommands (*command_line);
3373                   break;
3374                 }
3375               case P_dot_body_record:
3376                 {
3377                   recordParts -> storeCommands (*command_line);
3378                   break;
3379                 }
3380               case Q_dot_body_record:
3381                 {
3382                   recordParts -> storeCommands (*command_line);
3383                   break;
3384                 }
3385               case R_dot_body_record:
3386                 {
3387                   recordParts -> storeCommands (*command_line);
3388                   break;
3389                 }
3390
3391                 /********************** Velocities *********************/
3392               case V_north_record:
3393                 {
3394                   recordParts -> storeCommands (*command_line);
3395                   break;
3396                 }
3397               case V_east_record:
3398                 {
3399                   recordParts -> storeCommands (*command_line);
3400                   break;
3401                 }
3402               case V_down_record:
3403                 {
3404                   recordParts -> storeCommands (*command_line);
3405                   break;
3406                 }
3407               case V_north_rel_ground_record:
3408                 {
3409                   recordParts -> storeCommands (*command_line);
3410                   break;
3411                 }
3412               case V_east_rel_ground_record:
3413                 {
3414                   recordParts -> storeCommands (*command_line);
3415                   break;
3416                 }
3417               case V_down_rel_ground_record:
3418                 {
3419                   recordParts -> storeCommands (*command_line);
3420                   break;
3421                 }
3422               case V_north_airmass_record:
3423                 {
3424                   recordParts -> storeCommands (*command_line);
3425                   break;
3426                 }
3427               case V_east_airmass_record:
3428                 {
3429                   recordParts -> storeCommands (*command_line);
3430                   break;
3431                 }
3432               case V_down_airmass_record:
3433                 {
3434                   recordParts -> storeCommands (*command_line);
3435                   break;
3436                 }
3437               case V_north_rel_airmass_record:
3438                 {
3439                   recordParts -> storeCommands (*command_line);
3440                   break;
3441                 }
3442               case V_east_rel_airmass_record:
3443                 {
3444                   recordParts -> storeCommands (*command_line);
3445                   break;
3446                 }
3447               case V_down_rel_airmass_record:
3448                 {
3449                   recordParts -> storeCommands (*command_line);
3450                   break;
3451                 }
3452               case U_gust_record:
3453                 {
3454                   recordParts -> storeCommands (*command_line);
3455                   break;
3456                 }
3457               case V_gust_record:
3458                 {
3459                   recordParts -> storeCommands (*command_line);
3460                   break;
3461                 }
3462               case W_gust_record:
3463                 {
3464                   recordParts -> storeCommands (*command_line);
3465                   break;
3466                 }
3467               case U_body_record:
3468                 {
3469                   recordParts -> storeCommands (*command_line);
3470                   break;
3471                 }
3472               case V_body_record:
3473                 {
3474                   recordParts -> storeCommands (*command_line);
3475                   break;
3476                 }
3477               case W_body_record:
3478                 {
3479                   recordParts -> storeCommands (*command_line);
3480                   break;
3481                 }
3482               case V_rel_wind_record:
3483                 {
3484                   recordParts -> storeCommands (*command_line);
3485                   break;
3486                 }
3487               case V_true_kts_record:
3488                 {
3489                   recordParts -> storeCommands (*command_line);
3490                   break;
3491                 }
3492               case V_rel_ground_record:
3493                 {
3494                   recordParts -> storeCommands (*command_line);
3495                   break;
3496                 }
3497               case V_inertial_record:
3498                 {
3499                   recordParts -> storeCommands (*command_line);
3500                   break;
3501                 }
3502               case V_ground_speed_record:
3503                 {
3504                   recordParts -> storeCommands (*command_line);
3505                   break;
3506                 }
3507               case V_equiv_record:
3508                 {
3509                   recordParts -> storeCommands (*command_line);
3510                   break;
3511                 }
3512               case V_equiv_kts_record:
3513                 {
3514                   recordParts -> storeCommands (*command_line);
3515                   break;
3516                 }
3517               case V_calibrated_record:
3518                 {
3519                   recordParts -> storeCommands (*command_line);
3520                   break;
3521                 }
3522               case V_calibrated_kts_record:
3523                 {
3524                   recordParts -> storeCommands (*command_line);
3525                   break;
3526                 }
3527               case P_local_record:
3528                 {
3529                   recordParts -> storeCommands (*command_line);
3530                   break;
3531                 }
3532               case Q_local_record:
3533                 {
3534                   recordParts -> storeCommands (*command_line);
3535                   break;
3536                 }
3537               case R_local_record:
3538                 {
3539                   recordParts -> storeCommands (*command_line);
3540                   break;
3541                 }
3542               case P_body_record:
3543                 {
3544                   recordParts -> storeCommands (*command_line);
3545                   break;
3546                 }
3547               case Q_body_record:
3548                 {
3549                   recordParts -> storeCommands (*command_line);
3550                   break;
3551                 }
3552               case R_body_record:
3553                 {
3554                   recordParts -> storeCommands (*command_line);
3555                   break;
3556                 }
3557               case P_total_record:
3558                 {
3559                   recordParts -> storeCommands (*command_line);
3560                   break;
3561                 }
3562               case Q_total_record:
3563                 {
3564                   recordParts -> storeCommands (*command_line);
3565                   break;
3566                 }
3567               case R_total_record:
3568                 {
3569                   recordParts -> storeCommands (*command_line);
3570                   break;
3571                 }
3572               case Phi_dot_record:
3573                 {
3574                   recordParts -> storeCommands (*command_line);
3575                   break;
3576                 }
3577               case Theta_dot_record:
3578                 {
3579                   recordParts -> storeCommands (*command_line);
3580                   break;
3581                 }
3582               case Psi_dot_record:
3583                 {
3584                   recordParts -> storeCommands (*command_line);
3585                   break;
3586                 }
3587               case Latitude_dot_record:
3588                 {
3589                   recordParts -> storeCommands (*command_line);
3590                   break;
3591                 }
3592               case Longitude_dot_record:
3593                 {
3594                   recordParts -> storeCommands (*command_line);
3595                   break;
3596                 }
3597               case Radius_dot_record:
3598                 {
3599                   recordParts -> storeCommands (*command_line);
3600                   break;
3601                 }
3602
3603                 /************************ Angles ***********************/
3604               case Alpha_record:
3605                 {
3606                   recordParts -> storeCommands (*command_line);
3607                   break;
3608                 }
3609               case Alpha_deg_record:
3610                 {
3611                   recordParts -> storeCommands (*command_line);
3612                   break;
3613                 }
3614               case Alpha_dot_record:
3615                 {
3616                   recordParts -> storeCommands (*command_line);
3617                   break;
3618                 }
3619               case Alpha_dot_deg_record:
3620                 {
3621                   recordParts -> storeCommands (*command_line);
3622                   break;
3623                 }
3624               case Beta_record:
3625                 {
3626                   recordParts -> storeCommands (*command_line);
3627                   break;
3628                 }
3629               case Beta_deg_record:
3630                 {
3631                   recordParts -> storeCommands (*command_line);
3632                   break;
3633                 }
3634               case Beta_dot_record:
3635                 {
3636                   recordParts -> storeCommands (*command_line);
3637                   break;
3638                 }
3639               case Beta_dot_deg_record:
3640                 {
3641                   recordParts -> storeCommands (*command_line);
3642                   break;
3643                 }
3644               case Gamma_vert_record:
3645                 {
3646                   recordParts -> storeCommands (*command_line);
3647                   break;
3648                 }
3649               case Gamma_vert_deg_record:
3650                 {
3651                   recordParts -> storeCommands (*command_line);
3652                   break;
3653                 }
3654               case Gamma_horiz_record:
3655                 {
3656                   recordParts -> storeCommands (*command_line);
3657                   break;
3658                 }
3659               case Gamma_horiz_deg_record:
3660                 {
3661                   recordParts -> storeCommands (*command_line);
3662                   break;
3663                 }
3664
3665                 /**************** Atmospheric Properties ***************/
3666               case Density_record:
3667                 {
3668                   recordParts -> storeCommands (*command_line);
3669                   break;
3670                 }
3671               case V_sound_record:
3672                 {
3673                   recordParts -> storeCommands (*command_line);
3674                   break;
3675                 }
3676               case Mach_number_record:
3677                 {
3678                   recordParts -> storeCommands (*command_line);
3679                   break;
3680                 }
3681               case Static_pressure_record:
3682                 {
3683                   recordParts -> storeCommands (*command_line);
3684                   break;
3685                 }
3686               case Total_pressure_record:
3687                 {
3688                   recordParts -> storeCommands (*command_line);
3689                   break;
3690                 }
3691               case Impact_pressure_record:
3692                 {
3693                   recordParts -> storeCommands (*command_line);
3694                   break;
3695                 }
3696               case Dynamic_pressure_record:
3697                 {
3698                   recordParts -> storeCommands (*command_line);
3699                   break;
3700                 }
3701               case Static_temperature_record:
3702                 {
3703                   recordParts -> storeCommands (*command_line);
3704                   break;
3705                 }
3706               case Total_temperature_record:
3707                 {
3708                   recordParts -> storeCommands (*command_line);
3709                   break;
3710                 }
3711
3712                 /******************** Earth Properties *****************/
3713               case Gravity_record:
3714                 {
3715                   recordParts -> storeCommands (*command_line);
3716                   break;
3717                 }
3718               case Sea_level_radius_record:
3719                 {
3720                   recordParts -> storeCommands (*command_line);
3721                   break;
3722                 }
3723               case Earth_position_angle_record:
3724                 {
3725                   recordParts -> storeCommands (*command_line);
3726                   break;
3727                 }
3728               case Runway_altitude_record:
3729                 {
3730                   recordParts -> storeCommands (*command_line);
3731                   break;
3732                 }
3733               case Runway_latitude_record:
3734                 {
3735                   recordParts -> storeCommands (*command_line);
3736                   break;
3737                 }
3738               case Runway_longitude_record:
3739                 {
3740                   recordParts -> storeCommands (*command_line);
3741                   break;
3742                 }
3743               case Runway_heading_record:
3744                 {
3745                   recordParts -> storeCommands (*command_line);
3746                   break;
3747                 }
3748               case Radius_to_rwy_record:
3749                 {
3750                   recordParts -> storeCommands (*command_line);
3751                   break;
3752                 }
3753               case D_pilot_north_of_rwy_record:
3754                 {
3755                   recordParts -> storeCommands (*command_line);
3756                   break;
3757                 }
3758               case D_pilot_east_of_rwy_record:
3759                 {
3760                   recordParts -> storeCommands (*command_line);
3761                   break;
3762                 }
3763               case D_pilot_above_rwy_record:
3764                 {
3765                   recordParts -> storeCommands (*command_line);
3766                   break;
3767                 }
3768               case X_pilot_rwy_record:
3769                 {
3770                   recordParts -> storeCommands (*command_line);
3771                   break;
3772                 }
3773               case Y_pilot_rwy_record:
3774                 {
3775                   recordParts -> storeCommands (*command_line);
3776                   break;
3777                 }
3778               case H_pilot_rwy_record:
3779                 {
3780                   recordParts -> storeCommands (*command_line);
3781                   break;
3782                 }
3783               case D_cg_north_of_rwy_record:
3784                 {
3785                   recordParts -> storeCommands (*command_line);
3786                   break;
3787                 }
3788               case D_cg_east_of_rwy_record:
3789                 {
3790                   recordParts -> storeCommands (*command_line);
3791                   break;
3792                 }
3793               case D_cg_above_rwy_record:
3794                 {
3795                   recordParts -> storeCommands (*command_line);
3796                   break;
3797                 }
3798               case X_cg_rwy_record:
3799                 {
3800                   recordParts -> storeCommands (*command_line);
3801                   break;
3802                 }
3803               case Y_cg_rwy_record:
3804                 {
3805                   recordParts -> storeCommands (*command_line);
3806                   break;
3807                 }
3808               case H_cg_rwy_record:
3809                 {
3810                   recordParts -> storeCommands (*command_line);
3811                   break;
3812                 }
3813
3814                 /********************* Engine Inputs *******************/
3815               case Throttle_pct_record:
3816                 {
3817                   recordParts -> storeCommands (*command_line);
3818                   break;
3819                 }
3820               case Throttle_3_record:
3821                 {
3822                   recordParts -> storeCommands (*command_line);
3823                   break;
3824                 }
3825
3826                 /******************** Control Inputs *******************/
3827               case Long_control_record:
3828                 {
3829                   recordParts -> storeCommands (*command_line);
3830                   break;
3831                 }
3832               case Long_trim_record:
3833                 {
3834                   recordParts -> storeCommands (*command_line);
3835                   break;
3836                 }
3837               case Long_trim_deg_record:
3838                 {
3839                   recordParts -> storeCommands (*command_line);
3840                   break;
3841                 }
3842               case elevator_record:
3843                 {
3844                   recordParts -> storeCommands (*command_line);
3845                   break;
3846                 }
3847               case elevator_deg_record:
3848                 {
3849                   recordParts -> storeCommands (*command_line);
3850                   break;
3851                 }
3852               case Lat_control_record:
3853                 {
3854                   recordParts -> storeCommands (*command_line);
3855                   break;
3856                 }
3857               case aileron_record:
3858                 {
3859                   recordParts -> storeCommands (*command_line);
3860                   break;
3861                 }
3862               case aileron_deg_record:
3863                 {
3864                   recordParts -> storeCommands (*command_line);
3865                   break;
3866                 }
3867               case Rudder_pedal_record:
3868                 {
3869                   recordParts -> storeCommands (*command_line);
3870                   break;
3871                 }
3872               case rudder_record:
3873                 {
3874                   recordParts -> storeCommands (*command_line);
3875                   break;
3876                 }
3877               case rudder_deg_record:
3878                 {
3879                   recordParts -> storeCommands (*command_line);
3880                   break;
3881                 }
3882               case Flap_handle_record:
3883                 {
3884                   recordParts -> storeCommands (*command_line);
3885                   break;
3886                 }
3887               case flap_record:
3888                 {
3889                   recordParts -> storeCommands (*command_line);
3890                   break;
3891                 }
3892               case flap_deg_record:
3893                 {
3894                   recordParts -> storeCommands (*command_line);
3895                   break;
3896                 }
3897
3898                 /****************** Aero Coefficients ******************/
3899               case CD_record:
3900                 {
3901                   recordParts -> storeCommands (*command_line);
3902                   break;
3903                 }
3904               case CDfaI_record:
3905                 {
3906                   recordParts -> storeCommands (*command_line);
3907                   break;
3908                 }
3909               case CDfadeI_record:
3910                 {
3911                   recordParts -> storeCommands (*command_line);
3912                   break;
3913                 }
3914               case CDfdfI_record:
3915                 {
3916                   recordParts -> storeCommands (*command_line);
3917                   break;
3918                 }
3919               case CDfadfI_record:
3920                 {
3921                   recordParts -> storeCommands (*command_line);
3922                   break;
3923                 }
3924               case CX_record:
3925                 {
3926                   recordParts -> storeCommands (*command_line);
3927                   break;
3928                 }
3929               case CL_record:
3930                 {
3931                   recordParts -> storeCommands (*command_line);
3932                   break;
3933                 }
3934               case CLfaI_record:
3935                 {
3936                   recordParts -> storeCommands (*command_line);
3937                   break;
3938                 }
3939               case CLfadeI_record:
3940                 {
3941                   recordParts -> storeCommands (*command_line);
3942                   break;
3943                 }
3944               case CLfdfI_record:
3945                 {
3946                   recordParts -> storeCommands (*command_line);
3947                   break;
3948                 }
3949               case CLfadfI_record:
3950                 {
3951                   recordParts -> storeCommands (*command_line);
3952                   break;
3953                 }
3954               case CZ_record:
3955                 {
3956                   recordParts -> storeCommands (*command_line);
3957                   break;
3958                 }
3959               case Cm_record:
3960                 {
3961                   recordParts -> storeCommands (*command_line);
3962                   break;
3963                 }
3964               case CmfaI_record:
3965                 {
3966                   recordParts -> storeCommands (*command_line);
3967                   break;
3968                 }
3969               case CmfadeI_record:
3970                 {
3971                   recordParts -> storeCommands (*command_line);
3972                   break;
3973                 }
3974               case CmfdfI_record:
3975                 {
3976                   recordParts -> storeCommands (*command_line);
3977                   break;
3978                 }
3979               case CmfadfI_record:
3980                 {
3981                   recordParts -> storeCommands (*command_line);
3982                   break;
3983                 }
3984               case CY_record:
3985                 {
3986                   recordParts -> storeCommands (*command_line);
3987                   break;
3988                 }
3989               case CYfadaI_record:
3990                 {
3991                   recordParts -> storeCommands (*command_line);
3992                   break;
3993                 }
3994               case CYfbetadrI_record:
3995                 {
3996                   recordParts -> storeCommands (*command_line);
3997                   break;
3998                 }
3999               case Cl_record:
4000                 {
4001                   recordParts -> storeCommands (*command_line);
4002                   break;
4003                 }
4004               case ClfadaI_record:
4005                 {
4006                   recordParts -> storeCommands (*command_line);
4007                   break;
4008                 }
4009               case ClfbetadrI_record:
4010                 {
4011                   recordParts -> storeCommands (*command_line);
4012                   break;
4013                 }
4014               case Cn_record:
4015                 {
4016                   recordParts -> storeCommands (*command_line);
4017                   break;
4018                 }
4019               case CnfadaI_record:
4020                 {
4021                   recordParts -> storeCommands (*command_line);
4022                   break;
4023                 }
4024               case CnfbetadrI_record:
4025                 {
4026                   recordParts -> storeCommands (*command_line);
4027                   break;
4028                 }
4029
4030                 /******************** Ice Detection ********************/
4031               case CLclean_wing_record:
4032                 {
4033                   recordParts -> storeCommands (*command_line);
4034                   break;
4035                 }
4036               case CLiced_wing_record:
4037                 {
4038                   recordParts -> storeCommands (*command_line);
4039                   break;
4040                 }
4041               case CLclean_tail_record:
4042                 {
4043                   recordParts -> storeCommands (*command_line);
4044                   break;
4045                 }
4046               case CLiced_tail_record:
4047                 {
4048                   recordParts -> storeCommands (*command_line);
4049                   break;
4050                 }
4051               case Lift_clean_wing_record:
4052                 {
4053                   recordParts -> storeCommands (*command_line);
4054                   break;
4055                 }
4056               case Lift_iced_wing_record:
4057                 {
4058                   recordParts -> storeCommands (*command_line);
4059                   break;
4060                 }
4061               case Lift_clean_tail_record:
4062                 {
4063                   recordParts -> storeCommands (*command_line);
4064                   break;
4065                 }
4066               case Lift_iced_tail_record:
4067                 {
4068                   recordParts -> storeCommands (*command_line);
4069                   break;
4070                 }
4071               case Gamma_clean_wing_record:
4072                 {
4073                   recordParts -> storeCommands (*command_line);
4074                   break;
4075                 }
4076               case Gamma_iced_wing_record:
4077                 {
4078                   recordParts -> storeCommands (*command_line);
4079                   break;
4080                 }
4081               case Gamma_clean_tail_record:
4082                 {
4083                   recordParts -> storeCommands (*command_line);
4084                   break;
4085                 }
4086               case Gamma_iced_tail_record:
4087                 {
4088                   recordParts -> storeCommands (*command_line);
4089                   break;
4090                 }
4091               case w_clean_wing_record:
4092                 {
4093                   recordParts -> storeCommands (*command_line);
4094                   break;
4095                 }
4096               case w_iced_wing_record:
4097                 {
4098                   recordParts -> storeCommands (*command_line);
4099                   break;
4100                 }
4101               case w_clean_tail_record:
4102                 {
4103                   recordParts -> storeCommands (*command_line);
4104                   break;
4105                 }
4106               case w_iced_tail_record:
4107                 {
4108                   recordParts -> storeCommands (*command_line);
4109                   break;
4110                 }
4111               case V_total_clean_wing_record:
4112                 {
4113                   recordParts -> storeCommands (*command_line);
4114                   break;
4115                 }
4116               case V_total_iced_wing_record:
4117                 {
4118                   recordParts -> storeCommands (*command_line);
4119                   break;
4120                 }
4121               case V_total_clean_tail_record:
4122                 {
4123                   recordParts -> storeCommands (*command_line);
4124                   break;
4125                 }
4126               case V_total_iced_tail_record:
4127                 {
4128                   recordParts -> storeCommands (*command_line);
4129                   break;
4130                 }
4131               case beta_flow_clean_wing_record:
4132                 {
4133                   recordParts -> storeCommands (*command_line);
4134                   break;
4135                 }
4136               case beta_flow_clean_wing_deg_record:
4137                 {
4138                   recordParts -> storeCommands (*command_line);
4139                   break;
4140                 }
4141               case beta_flow_iced_wing_record:
4142                 {
4143                   recordParts -> storeCommands (*command_line);
4144                   break;
4145                 }
4146               case beta_flow_iced_wing_deg_record:
4147                 {
4148                   recordParts -> storeCommands (*command_line);
4149                   break;
4150                 }
4151               case beta_flow_clean_tail_record:
4152                 {
4153                   recordParts -> storeCommands (*command_line);
4154                   break;
4155                 }
4156               case beta_flow_clean_tail_deg_record:
4157                 {
4158                   recordParts -> storeCommands (*command_line);
4159                   break;
4160                 }
4161               case beta_flow_iced_tail_record:
4162                 {
4163                   recordParts -> storeCommands (*command_line);
4164                   break;
4165                 }
4166               case beta_flow_iced_tail_deg_record:
4167                 {
4168                   recordParts -> storeCommands (*command_line);
4169                   break;
4170                 }
4171               case Dbeta_flow_wing_record:
4172                 {
4173                   recordParts -> storeCommands (*command_line);
4174                   break;
4175                 }
4176               case Dbeta_flow_wing_deg_record:
4177                 {
4178                   recordParts -> storeCommands (*command_line);
4179                   break;
4180                 }
4181               case Dbeta_flow_tail_record:
4182                 {
4183                   recordParts -> storeCommands (*command_line);
4184                   break;
4185                 }
4186               case Dbeta_flow_tail_deg_record:
4187                 {
4188                   recordParts -> storeCommands (*command_line);
4189                   break;
4190                 }
4191               case pct_beta_flow_wing_record:
4192                 {
4193                   recordParts -> storeCommands (*command_line);
4194                   break;
4195                 }
4196               case pct_beta_flow_tail_record:
4197                 {
4198                   recordParts -> storeCommands (*command_line);
4199                   break;
4200                 }
4201
4202                 /************************ Forces ***********************/
4203               case F_X_wind_record:
4204                 {
4205                   recordParts -> storeCommands (*command_line);
4206                   break;
4207                 }
4208               case F_Y_wind_record:
4209                 {
4210                   recordParts -> storeCommands (*command_line);
4211                   break;
4212                 }
4213               case F_Z_wind_record:
4214                 {
4215                   recordParts -> storeCommands (*command_line);
4216                   break;
4217                 }
4218               case F_X_aero_record:
4219                 {
4220                   recordParts -> storeCommands (*command_line);
4221                   break;
4222                 }
4223               case F_Y_aero_record:
4224                 {
4225                   recordParts -> storeCommands (*command_line);
4226                   break;
4227                 }
4228               case F_Z_aero_record:
4229                 {
4230                   recordParts -> storeCommands (*command_line);
4231                   break;
4232                 }
4233               case F_X_engine_record:
4234                 {
4235                   recordParts -> storeCommands (*command_line);
4236                   break;
4237                 }
4238               case F_Y_engine_record:
4239                 {
4240                   recordParts -> storeCommands (*command_line);
4241                   break;
4242                 }
4243               case F_Z_engine_record:
4244                 {
4245                   recordParts -> storeCommands (*command_line);
4246                   break;
4247                 }
4248               case F_X_gear_record:
4249                 {
4250                   recordParts -> storeCommands (*command_line);
4251                   break;
4252                 }
4253               case F_Y_gear_record:
4254                 {
4255                   recordParts -> storeCommands (*command_line);
4256                   break;
4257                 }
4258               case F_Z_gear_record:
4259                 {
4260                   recordParts -> storeCommands (*command_line);
4261                   break;
4262                 }
4263               case F_X_record:
4264                 {
4265                   recordParts -> storeCommands (*command_line);
4266                   break;
4267                 }
4268               case F_Y_record:
4269                 {
4270                   recordParts -> storeCommands (*command_line);
4271                   break;
4272                 }
4273               case F_Z_record:
4274                 {
4275                   recordParts -> storeCommands (*command_line);
4276                   break;
4277                 }
4278               case F_north_record:
4279                 {
4280                   recordParts -> storeCommands (*command_line);
4281                   break;
4282                 }
4283               case F_east_record:
4284                 {
4285                   recordParts -> storeCommands (*command_line);
4286                   break;
4287                 }
4288               case F_down_record:
4289                 {
4290                   recordParts -> storeCommands (*command_line);
4291                   break;
4292                 }
4293
4294                 /*********************** Moments ***********************/
4295               case M_l_aero_record:
4296                 {
4297                   recordParts -> storeCommands (*command_line);
4298                   break;
4299                 }
4300               case M_m_aero_record:
4301                 {
4302                   recordParts -> storeCommands (*command_line);
4303                   break;
4304                 }
4305               case M_n_aero_record:
4306                 {
4307                   recordParts -> storeCommands (*command_line);
4308                   break;
4309                 }
4310               case M_l_engine_record:
4311                 {
4312                   recordParts -> storeCommands (*command_line);
4313                   break;
4314                 }
4315               case M_m_engine_record:
4316                 {
4317                   recordParts -> storeCommands (*command_line);
4318                   break;
4319                 }
4320               case M_n_engine_record:
4321                 {
4322                   recordParts -> storeCommands (*command_line);
4323                   break;
4324                 }
4325               case M_l_gear_record:
4326                 {
4327                   recordParts -> storeCommands (*command_line);
4328                   break;
4329                 }
4330               case M_m_gear_record:
4331                 {
4332                   recordParts -> storeCommands (*command_line);
4333                   break;
4334                 }
4335               case M_n_gear_record:
4336                 {
4337                   recordParts -> storeCommands (*command_line);
4338                   break;
4339                 }
4340               case M_l_rp_record:
4341                 {
4342                   recordParts -> storeCommands (*command_line);
4343                   break;
4344                 }
4345               case M_m_rp_record:
4346                 {
4347                   recordParts -> storeCommands (*command_line);
4348                   break;
4349                 }
4350               case M_n_rp_record:
4351                 {
4352                   recordParts -> storeCommands (*command_line);
4353                   break;
4354                 }
4355               default:
4356                 {
4357                   uiuc_warnings_errors(2, *command_line);
4358                   break;
4359                 }
4360               };
4361             break;
4362           } // end record map
4363
4364
4365         case misc_flag:
4366           {
4367             switch(misc_map[linetoken2])
4368               {
4369               case simpleHingeMomentCoef_flag:
4370                 {
4371                   if (check_float(linetoken3))
4372                     token3 >> token_value;
4373                   else
4374                     uiuc_warnings_errors(1, *command_line);
4375
4376                   simpleHingeMomentCoef = token_value;
4377                   break;
4378                 }
4379               case dfTimefdf_flag:
4380                 {
4381                   dfTimefdf = linetoken3;
4382                   /* call 1D File Reader with file name (dfTimefdf);
4383                      function returns array of dfs (dfArray) and
4384                      corresponding time values (TimeArray) and max
4385                      number of terms in arrays (ndf) */
4386                   uiuc_1DdataFileReader(dfTimefdf,
4387                                         dfTimefdf_dfArray,
4388                                         dfTimefdf_TimeArray,
4389                                         dfTimefdf_ndf);
4390                   break;
4391                 }
4392               default:
4393                 {
4394                   uiuc_warnings_errors(2, *command_line);
4395                   break;
4396                 }
4397               };
4398             break;
4399           } // end misc map
4400
4401
4402         default:
4403           {
4404             if (linetoken1=="*")
4405                 return;
4406             uiuc_warnings_errors(2, *command_line);
4407             break;
4408           }
4409         };
4410     } // end keyword map
4411
4412   delete airplane;
4413 }
4414
4415 // end menu.cpp