src/FDM/UIUCModel/uiuc_menu.cpp

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