src/FDM/UIUCModel/uiuc_menu.cpp

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