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