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