src/FDM/UIUCModel/uiuc_menu.cpp

   1 /**********************************************************************
   2
   3  FILENAME:     uiuc_menu.cpp
   4
   5 ----------------------------------------------------------------------
   6
   7  DESCRIPTION:  reads input file for specified aircraft and creates
   8                approporiate data storage space
   9
  10 ----------------------------------------------------------------------
  11
  12  STATUS:       alpha version
  13
  14 ----------------------------------------------------------------------
  15
  16  REFERENCES:   based on "menu reader" format of Michael Selig
  17
  18 ----------------------------------------------------------------------
  19
  20  HISTORY:      01/29/2000   initial release
  21                02/18/2000   (JS) added 1D data file capability for
  22                             CL(a) and CD(a) -- calls
  23                             uiuc_1DdataFileReader
  24                02/22/2000   (JS) added ice map functions
  25                02/29/2000   (JS) added 2D data file capability for
  26                             CL(a,de), CD(a,de), Cm(a,de), CY(a,da),
  27                             CY(beta,dr), Cl(a,da), Cl(beta,dr),
  28                             Cn(a,da), Cn(beta,dr) -- calls
  29                             uiuc_2DdataFileReader
  30                02/02/2000   (JS) added record options for 1D and
  31                             2D interpolated variables
  32                03/28/2000   (JS) streamlined conversion factors for
  33                             file readers -- since they are global
  34                             variables, it is not necessary to put
  35                             them in the function calls
  36                03/29/2000   (JS) added Cmfa and Weight flags;
  37                             added misc map; added Dx_cg (etc) to init
  38                             map
  39                04/01/2000   (JS) added throttle, longitudinal, lateral,
  40                             and rudder inputs to record map
  41                04/05/2000   (JS) added Altitude to init and record
  42                             maps; added zero_Long_trim to
  43                             controlSurface map
  44                03/09/2001   (DPM) added support for gear.
  45                06/18/2001   (RD) Added Alpha, Beta, U_body,
  46                             V_body, and W_body to init map.  Added
  47                             aileron_input, rudder_input, pilot_elev_no,
  48                             pilot_ail_no, and pilot_rud_no to
  49                             controlSurface map.  Added Throttle_pct_input
  50                             to engine map.  Added CZfa to CL map.
  51                07/05/2001   (RD) Changed pilot_elev_no = true to pilot_
  52                             elev_no_check=false.  This is to allow pilot
  53                             to fly aircraft after input files have been
  54                             used.
  55                08/27/2001   (RD) Added xxx_init_true and xxx_init for
  56                             P_body, Q_body, R_body, Phi, Theta, Psi,
  57                             U_body, V_body, and W_body to help in
  58                             starting the A/C at an initial condition.
  59                10/25/2001   (RD) Added new variables needed for the non-
  60                             linear Twin Otter model at zero flaps
  61                             (Cxfxxf0)
  62                11/12/2001   (RD) Added new variables needed for the non-
  63                             linear Twin Otter model with flaps
  64                             (Cxfxxf).  Removed zero flap variables.
  65                             Added minmaxfind() which is needed for non-
  66                             linear variables
  67                02/13/2002   (RD) Added variables so linear aero model
  68                             values can be recorded
  69                02/18/2002   (RD) Added variables necessary to use the
  70                             uiuc_3Dinterp_quick() function.  Takes
  71                             advantage of data in a "nice" form (data
  72                             that are in a rectangular matrix).
  73                03/13/2002   (RD) Added aircraft_directory so full path
  74                             is no longer needed in the aircraft.dat file
  75                04/02/2002   (RD) Removed minmaxfind() since it was no
  76                             longer needed.  Added d_2_to_3(),
  77                             d_1_to_2(), and i_1_to_2() so uiuc_menu()
  78                             will compile with certain compilers.
  79
  80 ----------------------------------------------------------------------
  81
  82  AUTHOR(S):    Bipin Sehgal       <bsehgal@uiuc.edu>
  83                Jeff Scott         <jscott@mail.com>
  84                Robert Deters      <rdeters@uiuc.edu>
  85                Michael Selig      <m-selig@uiuc.edu>
  86                David Megginson    <david@megginson.com>
  87
  88 ----------------------------------------------------------------------
  89
  90  VARIABLES:
  91
  92 ----------------------------------------------------------------------
  93
  94  INPUTS:       n/a
  95
  96 ----------------------------------------------------------------------
  97
  98  OUTPUTS:      n/a
  99
 100 ----------------------------------------------------------------------
 101
 102  CALLED BY:    uiuc_wrapper.cpp
 103
 104 ----------------------------------------------------------------------
 105
 106  CALLS TO:     aircraft.dat
 107                tabulated data files (if needed)
 108
 109 ----------------------------------------------------------------------
 110
 111  COPYRIGHT:    (C) 2000 by Michael Selig
 112
 113  This program is free software; you can redistribute it and/or
 114  modify it under the terms of the GNU General Public License
 115  as published by the Free Software Foundation.
 116
 117  This program is distributed in the hope that it will be useful,
 118  but WITHOUT ANY WARRANTY; without even the implied warranty of
 119  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 120  GNU General Public License for more details.
 121
 122  You should have received a copy of the GNU General Public License
 123  along with this program; if not, write to the Free Software
 124  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 125  USA or view http://www.gnu.org/copyleft/gpl.html.
 126
 127 **********************************************************************/
 128
 129 #include <simgear/compiler.h>
 130
 131 #if defined( __MWERKS__ )
 132 // -dw- optimizer chokes (big-time) trying to optimize humongous
 133 // loop/switch statements
 134 #pragma optimization_level 0
 135 #endif
 136
 137 #include <stdlib.h>
 138 #include <string.h>
 139 #include STL_IOSTREAM
 140
 141 #include "uiuc_menu.h"
 142
 143 #if !defined (SG_HAVE_NATIVE_SGI_COMPILERS)
 144 SG_USING_STD(cerr);
 145 SG_USING_STD(cout);
 146 SG_USING_STD(endl);
 147
 148 #  ifndef _MSC_VER
 149 SG_USING_STD(exit);
 150 #  endif
 151 #endif
 152
 153 bool check_float(string  &token)
 154 {
 155   float value;
 156   istrstream stream(token.c_str());
 157   return (stream >> value);
 158 }
 159
 160 //void minmaxfind( bool tarray[30], int &tmin, int &tmax)
 161 //{
 162 //  int n=0;
 163 //  bool first=true;
 164 //
 165 //  while (n<=30)
 166 //    {
 167 //      if (tarray[n])
 168 //      {
 169 //        if (first)
 170 //          {
 171 //            tmin=n;
 172 //            first=false;
 173 //          }
 174 //        tmax=n;
 175 //      }
 176 //      n++;
 177 //    }
 178 //}
 179
 180 void d_2_to_3( double array2D[100][100], double array3D[][100][100], int index3D)
 181 {
 182   for (register int i=0; i<=99; i++)
 183     {
 184       for (register int j=1; j<=99; j++)
 185         {
 186           array3D[index3D][i][j]=array2D[i][j];
 187         }
 188     }
 189 }
 190
 191 void d_1_to_2( double array1D[100], double array2D[][100], int index2D)
 192 {
 193   for (register int i=0; i<=99; i++)
 194     {
 195       array2D[index2D][i]=array1D[i];
 196     }
 197 }
 198
 199 void d_1_to_1( double array1[100], double array2[100] )
 200 {
 201    memcpy( array2, array1, sizeof(array2) );
 202 }
 203
 204 void i_1_to_2( int array1D[100], int array2D[][100], int index2D)
 205 {
 206   for (register int i=0; i<=99; i++)
 207     {
 208       array2D[index2D][i]=array1D[i];
 209     }
 210 }
 211
 212 void uiuc_menu( string aircraft_name )
 213 {
 214   string aircraft_directory;
 215   stack command_list;
 216   double token_value;
 217   int token_value_recordRate;
 218   int token_value_convert1, token_value_convert2, token_value_convert3;
 219
 220   string linetoken1;
 221   string linetoken2;
 222   string linetoken3;
 223   string linetoken4;
 224   string linetoken5;
 225   string linetoken6;
 226   string linetoken7;
 227   string linetoken8;
 228   string linetoken9;
 229
 230   double datafile_xArray[100][100], datafile_yArray[100];
 231   double datafile_zArray[100][100];
 232   int datafile_nxArray[100], datafile_ny;
 233
 234   bool CXfabetaf_first = true;
 235   bool CXfadef_first = true;
 236   bool CXfaqf_first = true;
 237   bool CZfabetaf_first = true;
 238   bool CZfadef_first = true;
 239   bool CZfaqf_first = true;
 240   bool Cmfabetaf_first = true;
 241   bool Cmfadef_first = true;
 242   bool Cmfaqf_first = true;
 243   bool CYfabetaf_first = true;
 244   bool CYfadaf_first = true;
 245   bool CYfadrf_first = true;
 246   bool CYfapf_first = true;
 247   bool CYfarf_first = true;
 248   bool Clfabetaf_first = true;
 249   bool Clfadaf_first = true;
 250   bool Clfadrf_first = true;
 251   bool Clfapf_first = true;
 252   bool Clfarf_first = true;
 253   bool Cnfabetaf_first = true;
 254   bool Cnfadaf_first = true;
 255   bool Cnfadrf_first = true;
 256   bool Cnfapf_first = true;
 257   bool Cnfarf_first = true;
 258
 259   /* the following default setting should eventually be moved to a default or uiuc_init routine */
 260
 261   recordRate = 1;       /* record every time step, default */
 262   recordStartTime = 0;  /* record from beginning of simulation */
 263
 264 /* set speed at which dynamic pressure terms will be accounted for,
 265    since if velocity is too small, coefficients will go to infinity */
 266   dyn_on_speed = 33;    /* 20 kts, default */
 267
 268
 269
 270   /* Read the file and get the list of commands */
 271   airplane = new ParseFile(aircraft_name); /* struct that includes all lines of the input file */
 272   command_list = airplane -> getCommands();
 273   /* structs to include all parts included in the input file for specific keyword groups */
 274   initParts          = new ParseFile();
 275   geometryParts      = new ParseFile();
 276   massParts          = new ParseFile();
 277   engineParts        = new ParseFile();
 278   aeroDragParts      = new ParseFile();
 279   aeroLiftParts      = new ParseFile();
 280   aeroPitchParts     = new ParseFile();
 281   aeroSideforceParts = new ParseFile();
 282   aeroRollParts      = new ParseFile();
 283   aeroYawParts       = new ParseFile();
 284   gearParts          = new ParseFile();
 285   recordParts        = new ParseFile();
 286
 287   if (command_list.begin() == command_list.end())
 288   {
 289     cerr << "UIUC ERROR: File " << aircraft_name <<" does not exist" << endl;
 290     exit(-1);
 291   }
 292
 293   //construct aircraft-directory
 294   aircraft_directory = aircraft_name;
 295   int index_aircraft_dat = aircraft_directory.find("aircraft.dat");
 296   aircraft_directory.erase(index_aircraft_dat,12);
 297
 298   for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
 299     {
 300       cout << *command_line << endl;
 301
 302       linetoken1 = airplane -> getToken (*command_line, 1);
 303       linetoken2 = airplane -> getToken (*command_line, 2);
 304       linetoken3 = airplane -> getToken (*command_line, 3);
 305       linetoken4 = airplane -> getToken (*command_line, 4);
 306       linetoken5 = airplane -> getToken (*command_line, 5);
 307       linetoken6 = airplane -> getToken (*command_line, 6);
 308       linetoken7 = airplane -> getToken (*command_line, 7);
 309       linetoken8 = airplane -> getToken (*command_line, 8);
 310       linetoken9 = airplane -> getToken (*command_line, 9);
 311
 312       istrstream token3(linetoken3.c_str());
 313       istrstream token4(linetoken4.c_str());
 314       istrstream token5(linetoken5.c_str());
 315       istrstream token6(linetoken6.c_str());
 316       istrstream token7(linetoken7.c_str());
 317       istrstream token8(linetoken8.c_str());
 318       istrstream token9(linetoken9.c_str());
 319
 320       switch (Keyword_map[linetoken1])
 321         {
 322         case init_flag:
 323           {
 324             switch(init_map[linetoken2])
 325               {
 326               case Dx_pilot_flag:
 327                 {
 328                   if (check_float(linetoken3))
 329                     token3 >> token_value;
 330                   else
 331                     uiuc_warnings_errors(1, *command_line);
 332
 333                   Dx_pilot = token_value;
 334                   initParts -> storeCommands (*command_line);
 335                   break;
 336                 }
 337               case Dy_pilot_flag:
 338                 {
 339                   if (check_float(linetoken3))
 340                     token3 >> token_value;
 341                   else
 342                     uiuc_warnings_errors(1, *command_line);
 343
 344                   Dy_pilot = token_value;
 345                   initParts -> storeCommands (*command_line);
 346                   break;
 347                 }
 348               case Dz_pilot_flag:
 349                 {
 350                   if (check_float(linetoken3))
 351                     token3 >> token_value;
 352                   else
 353                     uiuc_warnings_errors(1, *command_line);
 354
 355                   Dz_pilot = token_value;
 356                   initParts -> storeCommands (*command_line);
 357                   break;
 358                 }
 359               case Dx_cg_flag:
 360                 {
 361                   if (check_float(linetoken3))
 362                     token3 >> token_value;
 363                   else
 364                     uiuc_warnings_errors(1, *command_line);
 365
 366                   Dx_cg = token_value;
 367                   initParts -> storeCommands (*command_line);
 368                   break;
 369                 }
 370               case Dy_cg_flag:
 371                 {
 372                   if (check_float(linetoken3))
 373                     token3 >> token_value;
 374                   else
 375                     uiuc_warnings_errors(1, *command_line);
 376
 377                   Dy_cg = token_value;
 378                   initParts -> storeCommands (*command_line);
 379                   break;
 380                 }
 381               case Dz_cg_flag:
 382                 {
 383                   if (check_float(linetoken3))
 384                     token3 >> token_value;
 385                   else
 386                     uiuc_warnings_errors(1, *command_line);
 387
 388                   Dz_cg = token_value;
 389                   initParts -> storeCommands (*command_line);
 390                   break;
 391                 }
 392               case Altitude_flag:
 393                 {
 394                   if (check_float(linetoken3))
 395                     token3 >> token_value;
 396                   else
 397                     uiuc_warnings_errors(1, *command_line);
 398
 399                   Altitude = token_value;
 400                   initParts -> storeCommands (*command_line);
 401                   break;
 402                 }
 403               case V_north_flag:
 404                 {
 405                   if (check_float(linetoken3))
 406                     token3 >> token_value;
 407                   else
 408                     uiuc_warnings_errors(1, *command_line);
 409
 410                   V_north = token_value;
 411                   initParts -> storeCommands (*command_line);
 412                   break;
 413                 }
 414               case V_east_flag:
 415                 {
 416                   initParts -> storeCommands (*command_line);
 417                   if (check_float(linetoken3))
 418                     token3 >> token_value;
 419                   else
 420                     uiuc_warnings_errors(1, *command_line);
 421
 422                   V_east = token_value;
 423                   break;
 424                 }
 425               case V_down_flag:
 426                 {
 427                   if (check_float(linetoken3))
 428                     token3 >> token_value;
 429                   else
 430                     uiuc_warnings_errors(1, *command_line);
 431
 432                   V_down = token_value;
 433                   initParts -> storeCommands (*command_line);
 434                   break;
 435                 }
 436               case P_body_flag:
 437                 {
 438                   if (check_float(linetoken3))
 439                     token3 >> token_value;
 440                   else
 441                     uiuc_warnings_errors(1, *command_line);
 442
 443                   P_body_init_true = true;
 444                   P_body_init = token_value;
 445                   initParts -> storeCommands (*command_line);
 446                   break;
 447                 }
 448               case Q_body_flag:
 449                 {
 450                   if (check_float(linetoken3))
 451                     token3 >> token_value;
 452                   else
 453                     uiuc_warnings_errors(1, *command_line);
 454
 455                   Q_body_init_true = true;
 456                   Q_body_init = token_value;
 457                   initParts -> storeCommands (*command_line);
 458                   break;
 459                 }
 460               case R_body_flag:
 461                 {
 462                   if (check_float(linetoken3))
 463                     token3 >> token_value;
 464                   else
 465                     uiuc_warnings_errors(1, *command_line);
 466
 467                   R_body_init_true = true;
 468                   R_body_init = token_value;
 469                   initParts -> storeCommands (*command_line);
 470                   break;
 471                 }
 472               case Phi_flag:
 473                 {
 474                   if (check_float(linetoken3))
 475                     token3 >> token_value;
 476                   else
 477                     uiuc_warnings_errors(1, *command_line);
 478
 479                   Phi_init_true = true;
 480                   Phi_init = token_value;
 481                   initParts -> storeCommands (*command_line);
 482                   break;
 483                 }
 484               case Theta_flag:
 485                 {
 486                   if (check_float(linetoken3))
 487                     token3 >> token_value;
 488                   else
 489                     uiuc_warnings_errors(1, *command_line);
 490
 491                   Theta_init_true = true;
 492                   Theta_init = token_value;
 493                   initParts -> storeCommands (*command_line);
 494                   break;
 495                 }
 496               case Psi_flag:
 497                 {
 498                   if (check_float(linetoken3))
 499                     token3 >> token_value;
 500                   else
 501                     uiuc_warnings_errors(1, *command_line);
 502
 503                   Psi_init_true = true;
 504                   Psi_init = token_value;
 505                   initParts -> storeCommands (*command_line);
 506                   break;
 507                 }
 508               case Long_trim_flag:
 509                 {
 510                   if (check_float(linetoken3))
 511                     token3 >> token_value;
 512                   else
 513                     uiuc_warnings_errors(1, *command_line);
 514
 515                   Long_trim = token_value;
 516                   initParts -> storeCommands (*command_line);
 517                   break;
 518                 }
 519               case recordRate_flag:
 520                 {
 521                   //can't use check_float since variable is integer
 522                   token3 >> token_value_recordRate;
 523                   recordRate = 120 / token_value_recordRate;
 524                   break;
 525                 }
 526               case recordStartTime_flag:
 527                 {
 528                   if (check_float(linetoken3))
 529                     token3 >> token_value;
 530                   else
 531                     uiuc_warnings_errors(1, *command_line);
 532
 533                   recordStartTime = token_value;
 534                   break;
 535                 }
 536               case nondim_rate_V_rel_wind_flag:
 537                 {
 538                   nondim_rate_V_rel_wind = true;
 539                   break;
 540                 }
 541               case dyn_on_speed_flag:
 542                 {
 543                   if (check_float(linetoken3))
 544                     token3 >> token_value;
 545                   else
 546                     uiuc_warnings_errors(1, *command_line);
 547
 548                   dyn_on_speed = token_value;
 549                   break;
 550                 }
 551               case Alpha_flag:
 552                 {
 553                   if (check_float(linetoken3))
 554                     token3 >> token_value;
 555                   else
 556                     uiuc_warnings_errors(1, *command_line);
 557
 558                   Alpha_init_true = true;
 559                   Alpha_init = token_value * DEG_TO_RAD;
 560                   break;
 561                 }
 562               case Beta_flag:
 563                 {
 564                   if (check_float(linetoken3))
 565                     token3 >> token_value;
 566                   else
 567                     uiuc_warnings_errors(1, *command_line);
 568
 569                   Beta_init_true = true;
 570                   Beta_init = token_value * DEG_TO_RAD;
 571                   break;
 572                 }
 573               case U_body_flag:
 574                 {
 575                   if (check_float(linetoken3))
 576                     token3 >> token_value;
 577                   else
 578                     uiuc_warnings_errors(1, *command_line);
 579
 580                   U_body_init_true = true;
 581                   U_body_init = token_value;
 582                   break;
 583                 }
 584               case V_body_flag:
 585                 {
 586                   if (check_float(linetoken3))
 587                     token3 >> token_value;
 588                   else
 589                     uiuc_warnings_errors(1, *command_line);
 590
 591                   V_body_init_true = true;
 592                   V_body_init = token_value;
 593                   break;
 594                 }
 595               case W_body_flag:
 596                 {
 597                   if (check_float(linetoken3))
 598                     token3 >> token_value;
 599                   else
 600                     uiuc_warnings_errors(1, *command_line);
 601
 602                   W_body_init_true = true;
 603                   W_body_init = token_value;
 604                   break;
 605                 }
 606               default:
 607                 {
 608                   uiuc_warnings_errors(2, *command_line);
 609                   break;
 610                 }
 611               };
 612             break;
 613           } // end init map
 614
 615
 616         case geometry_flag:
 617           {
 618             switch(geometry_map[linetoken2])
 619               {
 620               case bw_flag:
 621                 {
 622                   if (check_float(linetoken3))
 623                     token3 >> token_value;
 624                   else
 625                     uiuc_warnings_errors(1, *command_line);
 626
 627                   bw = token_value;
 628                   geometryParts -> storeCommands (*command_line);
 629                   break;
 630                 }
 631               case cbar_flag:
 632                 {
 633                   if (check_float(linetoken3))
 634                     token3 >> token_value;
 635                   else
 636                     uiuc_warnings_errors(1, *command_line);
 637
 638                   cbar = token_value;
 639                   geometryParts -> storeCommands (*command_line);
 640                   break;
 641                 }
 642               case Sw_flag:
 643                 {
 644                   if (check_float(linetoken3))
 645                     token3 >> token_value;
 646                   else
 647                     uiuc_warnings_errors(1, *command_line);
 648
 649                   Sw = token_value;
 650                   geometryParts -> storeCommands (*command_line);
 651                   break;
 652                 }
 653               case ih_flag:
 654                 {
 655                   if (check_float(linetoken3))
 656                     token3 >> token_value;
 657                   else
 658                     uiuc_warnings_errors(1, *command_line);
 659
 660                   ih = token_value;
 661                   geometryParts -> storeCommands (*command_line);
 662                   break;
 663                 }
 664               case bh_flag:
 665                 {
 666                   if (check_float(linetoken3))
 667                     token3 >> token_value;
 668                   else
 669                     uiuc_warnings_errors(1, *command_line);
 670
 671                   bh = token_value;
 672                   geometryParts -> storeCommands (*command_line);
 673                   break;
 674                 }
 675               case ch_flag:
 676                 {
 677                   if (check_float(linetoken3))
 678                     token3 >> token_value;
 679                   else
 680                     uiuc_warnings_errors(1, *command_line);
 681
 682                   ch = token_value;
 683                   geometryParts -> storeCommands (*command_line);
 684                   break;
 685                 }
 686               case Sh_flag:
 687                 {
 688                   if (check_float(linetoken3))
 689                     token3 >> token_value;
 690                   else
 691                     uiuc_warnings_errors(1, *command_line);
 692
 693                   Sh = token_value;
 694                   geometryParts -> storeCommands (*command_line);
 695                   break;
 696                 }
 697               default:
 698                 {
 699                   uiuc_warnings_errors(2, *command_line);
 700                   break;
 701                 }
 702               };
 703             break;
 704           } // end geometry map
 705
 706
 707         case controlSurface_flag:
 708           {
 709             switch(controlSurface_map[linetoken2])
 710               {
 711               case de_flag:
 712                 {
 713                   if (check_float(linetoken3))
 714                     token3 >> token_value;
 715                   else
 716                     uiuc_warnings_errors(1, *command_line);
 717
 718                   demax = token_value;
 719
 720                   if (check_float(linetoken4))
 721                     token4 >> token_value;
 722                   else
 723                     uiuc_warnings_errors(1, *command_line);
 724
 725                   demin = token_value;
 726                   break;
 727                 }
 728               case da_flag:
 729                 {
 730                   if (check_float(linetoken3))
 731                     token3 >> token_value;
 732                   else
 733                     uiuc_warnings_errors(1, *command_line);
 734
 735                   damax = token_value;
 736
 737                   if (check_float(linetoken4))
 738                     token4 >> token_value;
 739                   else
 740                     uiuc_warnings_errors(1, *command_line);
 741
 742                   damin = token_value;
 743                   break;
 744                 }
 745               case dr_flag:
 746                 {
 747                   if (check_float(linetoken3))
 748                     token3 >> token_value;
 749                   else
 750                     uiuc_warnings_errors(1, *command_line);
 751
 752                   drmax = token_value;
 753
 754                   if (check_float(linetoken4))
 755                     token4 >> token_value;
 756                   else
 757                     uiuc_warnings_errors(1, *command_line);
 758
 759                   drmin = token_value;
 760                   break;
 761                 }
 762               case set_Long_trim_flag:
 763                 {
 764                   if (check_float(linetoken3))
 765                     token3 >> token_value;
 766                   else
 767                     uiuc_warnings_errors(1, *command_line);
 768
 769                   set_Long_trim = true;
 770                   elevator_tab = token_value;
 771                   break;
 772                 }
 773               case set_Long_trim_deg_flag:
 774                 {
 775                   if (check_float(linetoken3))
 776                     token3 >> token_value;
 777                   else
 778                     uiuc_warnings_errors(1, *command_line);
 779
 780                   set_Long_trim = true;
 781                   elevator_tab = token_value * DEG_TO_RAD;
 782                   break;
 783                 }
 784               case zero_Long_trim_flag:
 785                 {
 786                   zero_Long_trim = true;
 787                   break;
 788                 }
 789               case elevator_step_flag:
 790                 {
 791                   // set step input flag
 792                   elevator_step = true;
 793
 794                   // read in step angle in degrees and convert
 795                   if (check_float(linetoken3))
 796                     token3 >> token_value;
 797                   else
 798                     uiuc_warnings_errors(1, *command_line);
 799
 800                   elevator_step_angle = token_value * DEG_TO_RAD;
 801
 802                   // read in step start time
 803                   if (check_float(linetoken4))
 804                     token4 >> token_value;
 805                   else
 806                     uiuc_warnings_errors(1, *command_line);
 807
 808                   elevator_step_startTime = token_value;
 809                   break;
 810                 }
 811               case elevator_singlet_flag:
 812                 {
 813                   // set singlet input flag
 814                   elevator_singlet = true;
 815
 816                   // read in singlet angle in degrees and convert
 817                   if (check_float(linetoken3))
 818                     token3 >> token_value;
 819                   else
 820                     uiuc_warnings_errors(1, *command_line);
 821
 822                   elevator_singlet_angle = token_value * DEG_TO_RAD;
 823
 824                   // read in singlet start time
 825                   if (check_float(linetoken4))
 826                     token4 >> token_value;
 827                   else
 828                     uiuc_warnings_errors(1, *command_line);
 829
 830                   elevator_singlet_startTime = token_value;
 831
 832                   // read in singlet duration
 833                   if (check_float(linetoken5))
 834                     token5 >> token_value;
 835                   else
 836                     uiuc_warnings_errors(1, *command_line);
 837
 838                   elevator_singlet_duration = token_value;
 839                   break;
 840                 }
 841               case elevator_doublet_flag:
 842                 {
 843                   // set doublet input flag
 844                   elevator_doublet = true;
 845
 846                   // read in doublet angle in degrees and convert
 847                   if (check_float(linetoken3))
 848                     token3 >> token_value;
 849                   else
 850                     uiuc_warnings_errors(1, *command_line);
 851
 852                   elevator_doublet_angle = token_value * DEG_TO_RAD;
 853
 854                   // read in doublet start time
 855                   if (check_float(linetoken4))
 856                     token4 >> token_value;
 857                   else
 858                     uiuc_warnings_errors(1, *command_line);
 859
 860                   elevator_doublet_startTime = token_value;
 861
 862                   // read in doublet duration
 863                   if (check_float(linetoken5))
 864                     token5 >> token_value;
 865                   else
 866                     uiuc_warnings_errors(1, *command_line);
 867
 868                   elevator_doublet_duration = token_value;
 869                   break;
 870                 }
 871               case elevator_input_flag:
 872                 {
 873                   elevator_input = true;
 874                   elevator_input_file = aircraft_directory + linetoken3;
 875                   token4 >> token_value_convert1;
 876                   token5 >> token_value_convert2;
 877                   convert_y = uiuc_convert(token_value_convert1);
 878                   convert_x = uiuc_convert(token_value_convert2);
 879                   uiuc_1DdataFileReader(elevator_input_file,
 880                                         elevator_input_timeArray,
 881                                         elevator_input_deArray,
 882                                         elevator_input_ntime);
 883                   token6 >> token_value;
 884                   elevator_input_startTime = token_value;
 885                   break;
 886                 }
 887               case aileron_input_flag:
 888                 {
 889                   aileron_input = true;
 890                   aileron_input_file = aircraft_directory + linetoken3;
 891                   token4 >> token_value_convert1;
 892                   token5 >> token_value_convert2;
 893                   convert_y = uiuc_convert(token_value_convert1);
 894                   convert_x = uiuc_convert(token_value_convert2);
 895                   uiuc_1DdataFileReader(aileron_input_file,
 896                                         aileron_input_timeArray,
 897                                         aileron_input_daArray,
 898                                         aileron_input_ntime);
 899                   token6 >> token_value;
 900                   aileron_input_startTime = token_value;
 901                   break;
 902                 }
 903               case rudder_input_flag:
 904                 {
 905                   rudder_input = true;
 906                   rudder_input_file = aircraft_directory + linetoken3;
 907                   token4 >> token_value_convert1;
 908                   token5 >> token_value_convert2;
 909                   convert_y = uiuc_convert(token_value_convert1);
 910                   convert_x = uiuc_convert(token_value_convert2);
 911                   uiuc_1DdataFileReader(rudder_input_file,
 912                                         rudder_input_timeArray,
 913                                         rudder_input_drArray,
 914                                         rudder_input_ntime);
 915                   token6 >> token_value;
 916                   rudder_input_startTime = token_value;
 917                   break;
 918                 }
 919               case pilot_elev_no_flag:
 920                 {
 921                   pilot_elev_no_check = true;
 922                   break;
 923                 }
 924               case pilot_ail_no_flag:
 925                 {
 926                   pilot_ail_no_check = true;
 927                   break;
 928                 }
 929               case pilot_rud_no_flag:
 930                 {
 931                   pilot_rud_no_check = true;
 932                   break;
 933                 }
 934               case flap_max_flag:
 935                 {
 936                   if (check_float(linetoken3))
 937                     token3 >> token_value;
 938                   else
 939                     uiuc_warnings_errors(1, *command_line);
 940
 941                   flap_max = token_value;
 942                   break;
 943                 }
 944               case flap_rate_flag:
 945                 {
 946                   if (check_float(linetoken3))
 947                     token3 >> token_value;
 948                   else
 949                     uiuc_warnings_errors(1, *command_line);
 950
 951                   flap_rate = token_value;
 952                   break;
 953                 }
 954               default:
 955                 {
 956                   uiuc_warnings_errors(2, *command_line);
 957                   break;
 958                 }
 959               };
 960             break;
 961           } // end controlSurface map
 962
 963
 964         case mass_flag:
 965           {
 966             switch(mass_map[linetoken2])
 967               {
 968               case Weight_flag:
 969                 {
 970                   if (check_float(linetoken3))
 971                     token3 >> token_value;
 972                   else
 973                     uiuc_warnings_errors(1, *command_line);
 974
 975                   Weight = token_value;
 976                   Mass = Weight * INVG;
 977                   massParts -> storeCommands (*command_line);
 978                   break;
 979                 }
 980               case Mass_flag:
 981                 {
 982                   if (check_float(linetoken3))
 983                     token3 >> token_value;
 984                   else
 985                     uiuc_warnings_errors(1, *command_line);
 986
 987                   Mass = token_value;
 988                   massParts -> storeCommands (*command_line);
 989                   break;
 990                 }
 991               case I_xx_flag:
 992                 {
 993                   if (check_float(linetoken3))
 994                     token3 >> token_value;
 995                   else
 996                     uiuc_warnings_errors(1, *command_line);
 997
 998                   I_xx = token_value;
 999                   massParts -> storeCommands (*command_line);
1000                   break;
1001                 }
1002               case I_yy_flag:
1003                 {
1004                   if (check_float(linetoken3))
1005                     token3 >> token_value;
1006                   else
1007                     uiuc_warnings_errors(1, *command_line);
1008
1009                   I_yy = token_value;
1010                   massParts -> storeCommands (*command_line);
1011                   break;
1012                 }
1013               case I_zz_flag:
1014                 {
1015                   if (check_float(linetoken3))
1016                     token3 >> token_value;
1017                   else
1018                     uiuc_warnings_errors(1, *command_line);
1019
1020                   I_zz = token_value;
1021                   massParts -> storeCommands (*command_line);
1022                   break;
1023                 }
1024               case I_xz_flag:
1025                 {
1026                   if (check_float(linetoken3))
1027                     token3 >> token_value;
1028                   else
1029                     uiuc_warnings_errors(1, *command_line);
1030
1031                   I_xz = token_value;
1032                   massParts -> storeCommands (*command_line);
1033                   break;
1034                 }
1035               default:
1036                 {
1037                   uiuc_warnings_errors(2, *command_line);
1038                   break;
1039                 }
1040               };
1041             break;
1042           } // end mass map
1043
1044
1045         case engine_flag:
1046           {
1047             switch(engine_map[linetoken2])
1048               {
1049               case simpleSingle_flag:
1050                 {
1051                   if (check_float(linetoken3))
1052                     token3 >> token_value;
1053                   else
1054                     uiuc_warnings_errors(1, *command_line);
1055
1056                   simpleSingleMaxThrust = token_value;
1057                   engineParts -> storeCommands (*command_line);
1058                   break;
1059                 }
1060               case c172_flag:
1061                 {
1062                   engineParts -> storeCommands (*command_line);
1063                   break;
1064                 }
1065               case cherokee_flag:
1066                 {
1067                   engineParts -> storeCommands (*command_line);
1068                   break;
1069                 }
1070               case Throttle_pct_input_flag:
1071                 {
1072                   Throttle_pct_input = true;
1073                   Throttle_pct_input_file = aircraft_directory + linetoken3;
1074                   token4 >> token_value_convert1;
1075                   token5 >> token_value_convert2;
1076                   convert_y = uiuc_convert(token_value_convert1);
1077                   convert_x = uiuc_convert(token_value_convert2);
1078                   uiuc_1DdataFileReader(Throttle_pct_input_file,
1079                                         Throttle_pct_input_timeArray,
1080                                         Throttle_pct_input_dTArray,
1081                                         Throttle_pct_input_ntime);
1082                   token6 >> token_value;
1083                   Throttle_pct_input_startTime = token_value;
1084                   break;
1085                 }
1086               default:
1087                 {
1088                   uiuc_warnings_errors(2, *command_line);
1089                   break;
1090                 }
1091               };
1092             break;
1093           } // end engine map
1094
1095
1096         case CD_flag:
1097           {
1098             switch(CD_map[linetoken2])
1099               {
1100               case CDo_flag:
1101                 {
1102                   if (check_float(linetoken3))
1103                     token3 >> token_value;
1104                   else
1105                     uiuc_warnings_errors(1, *command_line);
1106
1107                   CDo = token_value;
1108                   CDo_clean = CDo;
1109                   aeroDragParts -> storeCommands (*command_line);
1110                   break;
1111                 }
1112               case CDK_flag:
1113                 {
1114                   if (check_float(linetoken3))
1115                     token3 >> token_value;
1116                   else
1117                     uiuc_warnings_errors(1, *command_line);
1118
1119                   CDK = token_value;
1120                   CDK_clean = CDK;
1121                   aeroDragParts -> storeCommands (*command_line);
1122                   break;
1123                 }
1124               case CD_a_flag:
1125                 {
1126                   if (check_float(linetoken3))
1127                     token3 >> token_value;
1128                   else
1129                     uiuc_warnings_errors(1, *command_line);
1130
1131                   CD_a = token_value;
1132                   CD_a_clean = CD_a;
1133                   aeroDragParts -> storeCommands (*command_line);
1134                   break;
1135                 }
1136               case CD_adot_flag:
1137                 {
1138                   if (check_float(linetoken3))
1139                     token3 >> token_value;
1140                   else
1141                     uiuc_warnings_errors(1, *command_line);
1142
1143                   CD_adot = token_value;
1144                   CD_adot_clean = CD_adot;
1145                   aeroDragParts -> storeCommands (*command_line);
1146                   break;
1147                 }
1148               case CD_q_flag:
1149                 {
1150                   if (check_float(linetoken3))
1151                     token3 >> token_value;
1152                   else
1153                     uiuc_warnings_errors(1, *command_line);
1154
1155                   CD_q = token_value;
1156                   CD_q_clean = CD_q;
1157                   aeroDragParts -> storeCommands (*command_line);
1158                   break;
1159                 }
1160               case CD_ih_flag:
1161                 {
1162                   if (check_float(linetoken3))
1163                     token3 >> token_value;
1164                   else
1165                     uiuc_warnings_errors(1, *command_line);
1166
1167                   CD_ih = token_value;
1168                   aeroDragParts -> storeCommands (*command_line);
1169                   break;
1170                 }
1171               case CD_de_flag:
1172                 {
1173                   if (check_float(linetoken3))
1174                     token3 >> token_value;
1175                   else
1176                     uiuc_warnings_errors(1, *command_line);
1177
1178                   CD_de = token_value;
1179                   CD_de_clean = CD_de;
1180                   aeroDragParts -> storeCommands (*command_line);
1181                   break;
1182                 }
1183               case CDfa_flag:
1184                 {
1185                   CDfa = aircraft_directory + linetoken3;
1186                   token4 >> token_value_convert1;
1187                   token5 >> token_value_convert2;
1188                   convert_y = uiuc_convert(token_value_convert1);
1189                   convert_x = uiuc_convert(token_value_convert2);
1190                   /* call 1D File Reader with file name (CDfa) and conversion
1191                      factors; function returns array of alphas (aArray) and
1192                      corresponding CD values (CDArray) and max number of
1193                      terms in arrays (nAlpha) */
1194                   uiuc_1DdataFileReader(CDfa,
1195                                         CDfa_aArray,
1196                                         CDfa_CDArray,
1197                                         CDfa_nAlpha);
1198                   aeroDragParts -> storeCommands (*command_line);
1199                   break;
1200                 }
1201               case CDfCL_flag:
1202                 {
1203                   CDfCL = aircraft_directory + linetoken3;
1204                   token4 >> token_value_convert1;
1205                   token5 >> token_value_convert2;
1206                   convert_y = uiuc_convert(token_value_convert1);
1207                   convert_x = uiuc_convert(token_value_convert2);
1208                   /* call 1D File Reader with file name (CDfCL) and conversion
1209                      factors; function returns array of CLs (CLArray) and
1210                      corresponding CD values (CDArray) and max number of
1211                      terms in arrays (nCL) */
1212                   uiuc_1DdataFileReader(CDfCL,
1213                                         CDfCL_CLArray,
1214                                         CDfCL_CDArray,
1215                                         CDfCL_nCL);
1216                   aeroDragParts -> storeCommands (*command_line);
1217                   break;
1218                 }
1219               case CDfade_flag:
1220                 {
1221                   CDfade = aircraft_directory + linetoken3;
1222                   token4 >> token_value_convert1;
1223                   token5 >> token_value_convert2;
1224                   token6 >> token_value_convert3;
1225                   convert_z = uiuc_convert(token_value_convert1);
1226                   convert_x = uiuc_convert(token_value_convert2);
1227                   convert_y = uiuc_convert(token_value_convert3);
1228                   /* call 2D File Reader with file name (CDfade) and
1229                      conversion factors; function returns array of
1230                      elevator deflections (deArray) and corresponding
1231                      alpha (aArray) and delta CD (CDArray) values and
1232                      max number of terms in alpha arrays (nAlphaArray)
1233                      and deflection array (nde) */
1234                   uiuc_2DdataFileReader(CDfade,
1235                                         CDfade_aArray,
1236                                         CDfade_deArray,
1237                                         CDfade_CDArray,
1238                                         CDfade_nAlphaArray,
1239                                         CDfade_nde);
1240                   aeroDragParts -> storeCommands (*command_line);
1241                   break;
1242                 }
1243               case CDfdf_flag:
1244                 {
1245                   CDfdf = aircraft_directory + linetoken3;
1246                   token4 >> token_value_convert1;
1247                   token5 >> token_value_convert2;
1248                   convert_y = uiuc_convert(token_value_convert1);
1249                   convert_x = uiuc_convert(token_value_convert2);
1250                   /* call 1D File Reader with file name (CDfdf) and conversion
1251                      factors; function returns array of dfs (dfArray) and
1252                      corresponding CD values (CDArray) and max number of
1253                      terms in arrays (ndf) */
1254                   uiuc_1DdataFileReader(CDfdf,
1255                                         CDfdf_dfArray,
1256                                         CDfdf_CDArray,
1257                                         CDfdf_ndf);
1258                   aeroDragParts -> storeCommands (*command_line);
1259                   break;
1260                 }
1261               case CDfadf_flag:
1262                 {
1263                   CDfadf = aircraft_directory + linetoken3;
1264                   token4 >> token_value_convert1;
1265                   token5 >> token_value_convert2;
1266                   token6 >> token_value_convert3;
1267                   convert_z = uiuc_convert(token_value_convert1);
1268                   convert_x = uiuc_convert(token_value_convert2);
1269                   convert_y = uiuc_convert(token_value_convert3);
1270                   /* call 2D File Reader with file name (CDfadf) and
1271                      conversion factors; function returns array of
1272                      flap deflections (dfArray) and corresponding
1273                      alpha (aArray) and delta CD (CDArray) values and
1274                      max number of terms in alpha arrays (nAlphaArray)
1275                      and deflection array (ndf) */
1276                   uiuc_2DdataFileReader(CDfadf,
1277                                         CDfadf_aArray,
1278                                         CDfadf_dfArray,
1279                                         CDfadf_CDArray,
1280                                         CDfadf_nAlphaArray,
1281                                         CDfadf_ndf);
1282                   aeroDragParts -> storeCommands (*command_line);
1283                   break;
1284                 }
1285               case CXo_flag:
1286                 {
1287                   if (check_float(linetoken3))
1288                     token3 >> token_value;
1289                   else
1290                     uiuc_warnings_errors(1, *command_line);
1291
1292                   CXo = token_value;
1293                   CXo_clean = CXo;
1294                   aeroDragParts -> storeCommands (*command_line);
1295                   break;
1296                 }
1297               case CXK_flag:
1298                 {
1299                   if (check_float(linetoken3))
1300                     token3 >> token_value;
1301                   else
1302                     uiuc_warnings_errors(1, *command_line);
1303
1304                   CXK = token_value;
1305                   CXK_clean = CXK;
1306                   aeroDragParts -> storeCommands (*command_line);
1307                   break;
1308                 }
1309               case CX_a_flag:
1310                 {
1311                   if (check_float(linetoken3))
1312                     token3 >> token_value;
1313                   else
1314                     uiuc_warnings_errors(1, *command_line);
1315
1316                   CX_a = token_value;
1317                   CX_a_clean = CX_a;
1318                   aeroDragParts -> storeCommands (*command_line);
1319                   break;
1320                 }
1321               case CX_a2_flag:
1322                 {
1323                   if (check_float(linetoken3))
1324                     token3 >> token_value;
1325                   else
1326                     uiuc_warnings_errors(1, *command_line);
1327
1328                   CX_a2 = token_value;
1329                   CX_a2_clean = CX_a2;
1330                   aeroDragParts -> storeCommands (*command_line);
1331                   break;
1332                 }
1333               case CX_a3_flag:
1334                 {
1335                   if (check_float(linetoken3))
1336                     token3 >> token_value;
1337                   else
1338                     uiuc_warnings_errors(1, *command_line);
1339
1340                   CX_a3 = token_value;
1341                   CX_a3_clean = CX_a3;
1342                   aeroDragParts -> storeCommands (*command_line);
1343                   break;
1344                 }
1345               case CX_adot_flag:
1346                 {
1347                   if (check_float(linetoken3))
1348                     token3 >> token_value;
1349                   else
1350                     uiuc_warnings_errors(1, *command_line);
1351
1352                   CX_adot = token_value;
1353                   CX_adot_clean = CX_adot;
1354                   aeroDragParts -> storeCommands (*command_line);
1355                   break;
1356                 }
1357               case CX_q_flag:
1358                 {
1359                   if (check_float(linetoken3))
1360                     token3 >> token_value;
1361                   else
1362                     uiuc_warnings_errors(1, *command_line);
1363
1364                   CX_q = token_value;
1365                   CX_q_clean = CX_q;
1366                   aeroDragParts -> storeCommands (*command_line);
1367                   break;
1368                 }
1369               case CX_de_flag:
1370                 {
1371                   if (check_float(linetoken3))
1372                     token3 >> token_value;
1373                   else
1374                     uiuc_warnings_errors(1, *command_line);
1375
1376                   CX_de = token_value;
1377                   CX_de_clean = CX_de;
1378                   aeroDragParts -> storeCommands (*command_line);
1379                   break;
1380                 }
1381               case CX_dr_flag:
1382                 {
1383                   if (check_float(linetoken3))
1384                     token3 >> token_value;
1385                   else
1386                     uiuc_warnings_errors(1, *command_line);
1387
1388                   CX_dr = token_value;
1389                   CX_dr_clean = CX_dr;
1390                   aeroDragParts -> storeCommands (*command_line);
1391                   break;
1392                 }
1393               case CX_df_flag:
1394                 {
1395                   if (check_float(linetoken3))
1396                     token3 >> token_value;
1397                   else
1398                     uiuc_warnings_errors(1, *command_line);
1399
1400                   CX_df = token_value;
1401                   CX_df_clean = CX_df;
1402                   aeroDragParts -> storeCommands (*command_line);
1403                   break;
1404                 }
1405               case CX_adf_flag:
1406                 {
1407                   if (check_float(linetoken3))
1408                     token3 >> token_value;
1409                   else
1410                     uiuc_warnings_errors(1, *command_line);
1411
1412                   CX_adf = token_value;
1413                   CX_adf_clean = CX_adf;
1414                   aeroDragParts -> storeCommands (*command_line);
1415                   break;
1416                 }
1417               case CXfabetaf_flag:
1418                 {
1419                   int CXfabetaf_index, i;
1420                   string CXfabetaf_file;
1421                   double flap_value;
1422                   CXfabetaf_file = aircraft_directory + linetoken3;
1423                   token4 >> CXfabetaf_index;
1424                   if (CXfabetaf_index < 1 || CXfabetaf_index >= 30)
1425                     uiuc_warnings_errors(1, *command_line);
1426                   if (CXfabetaf_index > CXfabetaf_nf)
1427                     CXfabetaf_nf = CXfabetaf_index;
1428                   token5 >> flap_value;
1429                   CXfabetaf_fArray[CXfabetaf_index] = flap_value;
1430                   token6 >> token_value_convert1;
1431                   token7 >> token_value_convert2;
1432                   token8 >> token_value_convert3;
1433                   token9 >> CXfabetaf_nice;
1434                   convert_z = uiuc_convert(token_value_convert1);
1435                   convert_x = uiuc_convert(token_value_convert2);
1436                   convert_y = uiuc_convert(token_value_convert3);
1437                   /* call 2D File Reader with file name (CXfabetaf_file) and
1438                      conversion factors; function returns array of
1439                      elevator deflections (deArray) and corresponding
1440                      alpha (aArray) and delta CZ (CZArray) values and
1441                      max number of terms in alpha arrays (nAlphaArray)
1442                      and delfection array (nde) */
1443                   uiuc_2DdataFileReader(CXfabetaf_file,
1444                                         datafile_xArray,
1445                                         datafile_yArray,
1446                                         datafile_zArray,
1447                                         datafile_nxArray,
1448                                         datafile_ny);
1449                   d_2_to_3(datafile_xArray, CXfabetaf_aArray, CXfabetaf_index);
1450                   d_1_to_2(datafile_yArray, CXfabetaf_betaArray, CXfabetaf_index);
1451                   d_2_to_3(datafile_zArray, CXfabetaf_CXArray, CXfabetaf_index);
1452                   i_1_to_2(datafile_nxArray, CXfabetaf_nAlphaArray, CXfabetaf_index);
1453                   CXfabetaf_nbeta[CXfabetaf_index] = datafile_ny;
1454                   if (CXfabetaf_first==true)
1455                     {
1456                       if (CXfabetaf_nice == 1)
1457                         {
1458                           CXfabetaf_na_nice = datafile_nxArray[1];
1459                           CXfabetaf_nb_nice = datafile_ny;
1460                           d_1_to_1(CXfabetaf_bArray_nice, datafile_yArray);
1461                           for (i=1; i<=CXfabetaf_na_nice; i++)
1462                             CXfabetaf_aArray_nice[i] = datafile_xArray[1][i];
1463                         }
1464                       aeroDragParts -> storeCommands (*command_line);
1465                       CXfabetaf_first=false;
1466                     }
1467                   break;
1468                 }
1469               case CXfadef_flag:
1470                 {
1471                   int CXfadef_index, i;
1472                   string CXfadef_file;
1473                   double flap_value;
1474                   CXfadef_file = aircraft_directory + linetoken3;
1475                   token4 >> CXfadef_index;
1476                   if (CXfadef_index < 0 || CXfadef_index >= 30)
1477                     uiuc_warnings_errors(1, *command_line);
1478                   if (CXfadef_index > CXfadef_nf)
1479                     CXfadef_nf = CXfadef_index;
1480                   token5 >> flap_value;
1481                   CXfadef_fArray[CXfadef_index] = flap_value;
1482                   token6 >> token_value_convert1;
1483                   token7 >> token_value_convert2;
1484                   token8 >> token_value_convert3;
1485                   token9 >> CXfadef_nice;
1486                   convert_z = uiuc_convert(token_value_convert1);
1487                   convert_x = uiuc_convert(token_value_convert2);
1488                   convert_y = uiuc_convert(token_value_convert3);
1489                   /* call 2D File Reader with file name (CXfadef_file) and
1490                      conversion factors; function returns array of
1491                      elevator deflections (deArray) and corresponding
1492                      alpha (aArray) and delta CZ (CZArray) values and
1493                      max number of terms in alpha arrays (nAlphaArray)
1494                      and delfection array (nde) */
1495                   uiuc_2DdataFileReader(CXfadef_file,
1496                                         datafile_xArray,
1497                                         datafile_yArray,
1498                                         datafile_zArray,
1499                                         datafile_nxArray,
1500                                         datafile_ny);
1501                   d_2_to_3(datafile_xArray, CXfadef_aArray, CXfadef_index);
1502                   d_1_to_2(datafile_yArray, CXfadef_deArray, CXfadef_index);
1503                   d_2_to_3(datafile_zArray, CXfadef_CXArray, CXfadef_index);
1504                   i_1_to_2(datafile_nxArray, CXfadef_nAlphaArray, CXfadef_index);
1505                   CXfadef_nde[CXfadef_index] = datafile_ny;
1506                   if (CXfadef_first==true)
1507                     {
1508                       if (CXfadef_nice == 1)
1509                         {
1510                           CXfadef_na_nice = datafile_nxArray[1];
1511                           CXfadef_nde_nice = datafile_ny;
1512                           d_1_to_1(CXfadef_deArray_nice, datafile_yArray);
1513                           for (i=1; i<=CXfadef_na_nice; i++)
1514                             CXfadef_aArray_nice[i] = datafile_xArray[1][i];
1515                         }
1516                       aeroDragParts -> storeCommands (*command_line);
1517                       CXfadef_first=false;
1518                     }
1519                   break;
1520                 }
1521               case CXfaqf_flag:
1522                 {
1523                   int CXfaqf_index, i;
1524                   string CXfaqf_file;
1525                   double flap_value;
1526                   CXfaqf_file = aircraft_directory + linetoken3;
1527                   token4 >> CXfaqf_index;
1528                   if (CXfaqf_index < 0 || CXfaqf_index >= 30)
1529                     uiuc_warnings_errors(1, *command_line);
1530                   if (CXfaqf_index > CXfaqf_nf)
1531                     CXfaqf_nf = CXfaqf_index;
1532                   token5 >> flap_value;
1533                   CXfaqf_fArray[CXfaqf_index] = flap_value;
1534                   token6 >> token_value_convert1;
1535                   token7 >> token_value_convert2;
1536                   token8 >> token_value_convert3;
1537                   token9 >> CXfaqf_nice;
1538                   convert_z = uiuc_convert(token_value_convert1);
1539                   convert_x = uiuc_convert(token_value_convert2);
1540                   convert_y = uiuc_convert(token_value_convert3);
1541                   /* call 2D File Reader with file name (CXfaqf_file) and
1542                      conversion factors; function returns array of
1543                      elevator deflections (deArray) and corresponding
1544                      alpha (aArray) and delta CZ (CZArray) values and
1545                      max number of terms in alpha arrays (nAlphaArray)
1546                      and delfection array (nde) */
1547                   uiuc_2DdataFileReader(CXfaqf_file,
1548                                         datafile_xArray,
1549                                         datafile_yArray,
1550                                         datafile_zArray,
1551                                         datafile_nxArray,
1552                                         datafile_ny);
1553                   d_2_to_3(datafile_xArray, CXfaqf_aArray, CXfaqf_index);
1554                   d_1_to_2(datafile_yArray, CXfaqf_qArray, CXfaqf_index);
1555                   d_2_to_3(datafile_zArray, CXfaqf_CXArray, CXfaqf_index);
1556                   i_1_to_2(datafile_nxArray, CXfaqf_nAlphaArray, CXfaqf_index);
1557                   CXfaqf_nq[CXfaqf_index] = datafile_ny;
1558                   if (CXfaqf_first==true)
1559                     {
1560                       if (CXfaqf_nice == 1)
1561                         {
1562                           CXfaqf_na_nice = datafile_nxArray[1];
1563                           CXfaqf_nq_nice = datafile_ny;
1564                           d_1_to_1(CXfaqf_qArray_nice, datafile_yArray);
1565                           for (i=1; i<=CXfaqf_na_nice; i++)
1566                             CXfaqf_aArray_nice[i] = datafile_xArray[1][i];
1567                         }
1568                       aeroDragParts -> storeCommands (*command_line);
1569                       CXfaqf_first=false;
1570                     }
1571                   break;
1572                 }
1573               default:
1574                 {
1575                   uiuc_warnings_errors(2, *command_line);
1576                   break;
1577                 }
1578               };
1579             break;
1580           } // end CD map
1581
1582
1583         case CL_flag:
1584           {
1585             switch(CL_map[linetoken2])
1586               {
1587               case CLo_flag:
1588                 {
1589                   if (check_float(linetoken3))
1590                     token3 >> token_value;
1591                   else
1592                     uiuc_warnings_errors(1, *command_line);
1593
1594                   CLo = token_value;
1595                   CLo_clean = CLo;
1596                   aeroLiftParts -> storeCommands (*command_line);
1597                   break;
1598                 }
1599               case CL_a_flag:
1600                 {
1601                   if (check_float(linetoken3))
1602                     token3 >> token_value;
1603                   else
1604                     uiuc_warnings_errors(1, *command_line);
1605
1606                   CL_a = token_value;
1607                   CL_a_clean = CL_a;
1608                   aeroLiftParts -> storeCommands (*command_line);
1609                   break;
1610                 }
1611               case CL_adot_flag:
1612                 {
1613                   if (check_float(linetoken3))
1614                     token3 >> token_value;
1615                   else
1616                     uiuc_warnings_errors(1, *command_line);
1617
1618                   CL_adot = token_value;
1619                   CL_adot_clean = CL_adot;
1620                   aeroLiftParts -> storeCommands (*command_line);
1621                   break;
1622                 }
1623               case CL_q_flag:
1624                 {
1625                   if (check_float(linetoken3))
1626                     token3 >> token_value;
1627                   else
1628                     uiuc_warnings_errors(1, *command_line);
1629
1630                   CL_q = token_value;
1631                   CL_q_clean = CL_q;
1632                   aeroLiftParts -> storeCommands (*command_line);
1633                   break;
1634                 }
1635               case CL_ih_flag:
1636                 {
1637                   if (check_float(linetoken3))
1638                     token3 >> token_value;
1639                   else
1640                     uiuc_warnings_errors(1, *command_line);
1641
1642                   CL_ih = token_value;
1643                   aeroLiftParts -> storeCommands (*command_line);
1644                   break;
1645                 }
1646               case CL_de_flag:
1647                 {
1648                   if (check_float(linetoken3))
1649                     token3 >> token_value;
1650                   else
1651                     uiuc_warnings_errors(1, *command_line);
1652
1653                   CL_de = token_value;
1654                   CL_de_clean = CL_de;
1655                   aeroLiftParts -> storeCommands (*command_line);
1656                   break;
1657                 }
1658               case CLfa_flag:
1659                 {
1660                   CLfa = aircraft_directory + linetoken3;
1661                   token4 >> token_value_convert1;
1662                   token5 >> token_value_convert2;
1663                   convert_y = uiuc_convert(token_value_convert1);
1664                   convert_x = uiuc_convert(token_value_convert2);
1665                   /* call 1D File Reader with file name (CLfa) and conversion
1666                      factors; function returns array of alphas (aArray) and
1667                      corresponding CL values (CLArray) and max number of
1668                      terms in arrays (nAlpha) */
1669                   uiuc_1DdataFileReader(CLfa,
1670                                         CLfa_aArray,
1671                                         CLfa_CLArray,
1672                                         CLfa_nAlpha);
1673                   aeroLiftParts -> storeCommands (*command_line);
1674                   break;
1675                 }
1676               case CLfade_flag:
1677                 {
1678                   CLfade = aircraft_directory + linetoken3;
1679                   token4 >> token_value_convert1;
1680                   token5 >> token_value_convert2;
1681                   token6 >> token_value_convert3;
1682                   convert_z = uiuc_convert(token_value_convert1);
1683                   convert_x = uiuc_convert(token_value_convert2);
1684                   convert_y = uiuc_convert(token_value_convert3);
1685                   /* call 2D File Reader with file name (CLfade) and
1686                      conversion factors; function returns array of
1687                      elevator deflections (deArray) and corresponding
1688                      alpha (aArray) and delta CL (CLArray) values and
1689                      max number of terms in alpha arrays (nAlphaArray)
1690                      and deflection array (nde) */
1691                   uiuc_2DdataFileReader(CLfade,
1692                                         CLfade_aArray,
1693                                         CLfade_deArray,
1694                                         CLfade_CLArray,
1695                                         CLfade_nAlphaArray,
1696                                         CLfade_nde);
1697                   aeroLiftParts -> storeCommands (*command_line);
1698                   break;
1699                 }
1700               case CLfdf_flag:
1701                 {
1702                   CLfdf = aircraft_directory + linetoken3;
1703                   token4 >> token_value_convert1;
1704                   token5 >> token_value_convert2;
1705                   convert_y = uiuc_convert(token_value_convert1);
1706                   convert_x = uiuc_convert(token_value_convert2);
1707                   /* call 1D File Reader with file name (CLfdf) and conversion
1708                      factors; function returns array of dfs (dfArray) and
1709                      corresponding CL values (CLArray) and max number of
1710                      terms in arrays (ndf) */
1711                   uiuc_1DdataFileReader(CLfdf,
1712                                         CLfdf_dfArray,
1713                                         CLfdf_CLArray,
1714                                         CLfdf_ndf);
1715                   aeroLiftParts -> storeCommands (*command_line);
1716
1717                   // additional variables to streamline flap routine in aerodeflections
1718                   ndf = CLfdf_ndf;
1719                   int temp_counter = 1;
1720                   while (temp_counter <= ndf)
1721                     {
1722                       dfArray[temp_counter] = CLfdf_dfArray[temp_counter];
1723                       TimeArray[temp_counter] = dfTimefdf_TimeArray[temp_counter];
1724                       temp_counter++;
1725                     }
1726                   break;
1727                 }
1728               case CLfadf_flag:
1729                 {
1730                   CLfadf = aircraft_directory + linetoken3;
1731                   token4 >> token_value_convert1;
1732                   token5 >> token_value_convert2;
1733                   token6 >> token_value_convert3;
1734                   convert_z = uiuc_convert(token_value_convert1);
1735                   convert_x = uiuc_convert(token_value_convert2);
1736                   convert_y = uiuc_convert(token_value_convert3);
1737                   /* call 2D File Reader with file name (CLfadf) and
1738                      conversion factors; function returns array of
1739                      flap deflections (dfArray) and corresponding
1740                      alpha (aArray) and delta CL (CLArray) values and
1741                      max number of terms in alpha arrays (nAlphaArray)
1742                      and deflection array (ndf) */
1743                   uiuc_2DdataFileReader(CLfadf,
1744                                         CLfadf_aArray,
1745                                         CLfadf_dfArray,
1746                                         CLfadf_CLArray,
1747                                         CLfadf_nAlphaArray,
1748                                         CLfadf_ndf);
1749                   aeroLiftParts -> storeCommands (*command_line);
1750                   break;
1751                 }
1752               case CZo_flag:
1753                 {
1754                   if (check_float(linetoken3))
1755                     token3 >> token_value;
1756                   else
1757                     uiuc_warnings_errors(1, *command_line);
1758
1759                   CZo = token_value;
1760                   CZo_clean = CZo;
1761                   aeroLiftParts -> storeCommands (*command_line);
1762                   break;
1763                 }
1764               case CZ_a_flag:
1765                 {
1766                   if (check_float(linetoken3))
1767                     token3 >> token_value;
1768                   else
1769                     uiuc_warnings_errors(1, *command_line);
1770
1771                   CZ_a = token_value;
1772                   CZ_a_clean = CZ_a;
1773                   aeroLiftParts -> storeCommands (*command_line);
1774                   break;
1775                 }
1776               case CZ_a2_flag:
1777                 {
1778                   if (check_float(linetoken3))
1779                     token3 >> token_value;
1780                   else
1781                     uiuc_warnings_errors(1, *command_line);
1782
1783                   CZ_a2 = token_value;
1784                   CZ_a2_clean = CZ_a2;
1785                   aeroLiftParts -> storeCommands (*command_line);
1786                   break;
1787                 }
1788               case CZ_a3_flag:
1789                 {
1790                   if (check_float(linetoken3))
1791                     token3 >> token_value;
1792                   else
1793                     uiuc_warnings_errors(1, *command_line);
1794
1795                   CZ_a3 = token_value;
1796                   CZ_a3_clean = CZ_a3;
1797                   aeroLiftParts -> storeCommands (*command_line);
1798                   break;
1799                 }
1800               case CZ_adot_flag:
1801                 {
1802                   if (check_float(linetoken3))
1803                     token3 >> token_value;
1804                   else
1805                     uiuc_warnings_errors(1, *command_line);
1806
1807                   CZ_adot = token_value;
1808                   CZ_adot_clean = CZ_adot;
1809                   aeroLiftParts -> storeCommands (*command_line);
1810                   break;
1811                 }
1812               case CZ_q_flag:
1813                 {
1814                   if (check_float(linetoken3))
1815                     token3 >> token_value;
1816                   else
1817                     uiuc_warnings_errors(1, *command_line);
1818
1819                   CZ_q = token_value;
1820                   CZ_q_clean = CZ_q;
1821                   aeroLiftParts -> storeCommands (*command_line);
1822                   break;
1823                 }
1824               case CZ_de_flag:
1825                 {
1826                   if (check_float(linetoken3))
1827                     token3 >> token_value;
1828                   else
1829                     uiuc_warnings_errors(1, *command_line);
1830
1831                   CZ_de = token_value;
1832                   CZ_de_clean = CZ_de;
1833                   aeroLiftParts -> storeCommands (*command_line);
1834                   break;
1835                 }
1836               case CZ_deb2_flag:
1837                 {
1838                   if (check_float(linetoken3))
1839                     token3 >> token_value;
1840                   else
1841                     uiuc_warnings_errors(1, *command_line);
1842
1843                   CZ_deb2 = token_value;
1844                   CZ_deb2_clean = CZ_deb2;
1845                   aeroLiftParts -> storeCommands (*command_line);
1846                   break;
1847                 }
1848               case CZ_df_flag:
1849                 {
1850                   if (check_float(linetoken3))
1851                     token3 >> token_value;
1852                   else
1853                     uiuc_warnings_errors(1, *command_line);
1854
1855                   CZ_df = token_value;
1856                   CZ_df_clean = CZ_df;
1857                   aeroLiftParts -> storeCommands (*command_line);
1858                   break;
1859                 }
1860               case CZ_adf_flag:
1861                 {
1862                   if (check_float(linetoken3))
1863                     token3 >> token_value;
1864                   else
1865                     uiuc_warnings_errors(1, *command_line);
1866
1867                   CZ_adf = token_value;
1868                   CZ_adf_clean = CZ_adf;
1869                   aeroLiftParts -> storeCommands (*command_line);
1870                   break;
1871                 }
1872               case CZfa_flag:
1873                 {
1874                   CZfa = aircraft_directory + linetoken3;
1875                   token4 >> token_value_convert1;
1876                   token5 >> token_value_convert2;
1877                   convert_y = uiuc_convert(token_value_convert1);
1878                   convert_x = uiuc_convert(token_value_convert2);
1879                   /* call 1D File Reader with file name (CZfa) and conversion
1880                      factors; function returns array of alphas (aArray) and
1881                      corresponding CZ values (CZArray) and max number of
1882                      terms in arrays (nAlpha) */
1883                   uiuc_1DdataFileReader(CZfa,
1884                                         CZfa_aArray,
1885                                         CZfa_CZArray,
1886                                         CZfa_nAlpha);
1887                   aeroLiftParts -> storeCommands (*command_line);
1888                   break;
1889                 }
1890               case CZfabetaf_flag:
1891                 {
1892                   int CZfabetaf_index, i;
1893                   string CZfabetaf_file;
1894                   double flap_value;
1895                   CZfabetaf_file = aircraft_directory + linetoken3;
1896                   token4 >> CZfabetaf_index;
1897                   if (CZfabetaf_index < 0 || CZfabetaf_index >= 30)
1898                     uiuc_warnings_errors(1, *command_line);
1899                   if (CZfabetaf_index > CZfabetaf_nf)
1900                     CZfabetaf_nf = CZfabetaf_index;
1901                   token5 >> flap_value;
1902                   CZfabetaf_fArray[CZfabetaf_index] = flap_value;
1903                   token6 >> token_value_convert1;
1904                   token7 >> token_value_convert2;
1905                   token8 >> token_value_convert3;
1906                   token9 >> CZfabetaf_nice;
1907                   convert_z = uiuc_convert(token_value_convert1);
1908                   convert_x = uiuc_convert(token_value_convert2);
1909                   convert_y = uiuc_convert(token_value_convert3);
1910                   /* call 2D File Reader with file name (CZfabetaf_file) and
1911                      conversion factors; function returns array of
1912                      beta (betaArray) and corresponding
1913                      alpha (aArray) and CZ (CZArray) values and
1914                      max number of terms in alpha arrays (nAlphaArray)
1915                      and beta array (nbeta) */
1916                   uiuc_2DdataFileReader(CZfabetaf_file,
1917                                         datafile_xArray,
1918                                         datafile_yArray,
1919                                         datafile_zArray,
1920                                         datafile_nxArray,
1921                                         datafile_ny);
1922                   d_2_to_3(datafile_xArray, CZfabetaf_aArray, CZfabetaf_index);
1923                   d_1_to_2(datafile_yArray, CZfabetaf_betaArray, CZfabetaf_index);
1924                   d_2_to_3(datafile_zArray, CZfabetaf_CZArray, CZfabetaf_index);
1925                   i_1_to_2(datafile_nxArray, CZfabetaf_nAlphaArray, CZfabetaf_index);
1926                   CZfabetaf_nbeta[CZfabetaf_index] = datafile_ny;
1927                   if (CZfabetaf_first==true)
1928                     {
1929                       if (CZfabetaf_nice == 1)
1930                         {
1931                           CZfabetaf_na_nice = datafile_nxArray[1];
1932                           CZfabetaf_nb_nice = datafile_ny;
1933                           d_1_to_1(CZfabetaf_bArray_nice, datafile_yArray);
1934                           for (i=1; i<=CZfabetaf_na_nice; i++)
1935                             CZfabetaf_aArray_nice[i] = datafile_xArray[1][i];
1936                         }
1937                       aeroLiftParts -> storeCommands (*command_line);
1938                       CZfabetaf_first=false;
1939                     }
1940                   break;
1941                 }
1942               case CZfadef_flag:
1943                 {
1944                   int CZfadef_index, i;
1945                   string CZfadef_file;
1946                   double flap_value;
1947                   CZfadef_file = aircraft_directory + linetoken3;
1948                   token4 >> CZfadef_index;
1949                   if (CZfadef_index < 0 || CZfadef_index >= 30)
1950                     uiuc_warnings_errors(1, *command_line);
1951                   if (CZfadef_index > CZfadef_nf)
1952                     CZfadef_nf = CZfadef_index;
1953                   token5 >> flap_value;
1954                   CZfadef_fArray[CZfadef_index] = flap_value;
1955                   token6 >> token_value_convert1;
1956                   token7 >> token_value_convert2;
1957                   token8 >> token_value_convert3;
1958                   token9 >> CZfadef_nice;
1959                   convert_z = uiuc_convert(token_value_convert1);
1960                   convert_x = uiuc_convert(token_value_convert2);
1961                   convert_y = uiuc_convert(token_value_convert3);
1962                   /* call 2D File Reader with file name (CZfadef_file) and
1963                      conversion factors; function returns array of
1964                      elevator deflections (deArray) and corresponding
1965                      alpha (aArray) and delta CZ (CZArray) values and
1966                      max number of terms in alpha arrays (nAlphaArray)
1967                      and delfection array (nde) */
1968                   uiuc_2DdataFileReader(CZfadef_file,
1969                                         datafile_xArray,
1970                                         datafile_yArray,
1971                                         datafile_zArray,
1972                                         datafile_nxArray,
1973                                         datafile_ny);
1974                   d_2_to_3(datafile_xArray, CZfadef_aArray, CZfadef_index);
1975                   d_1_to_2(datafile_yArray, CZfadef_deArray, CZfadef_index);
1976                   d_2_to_3(datafile_zArray, CZfadef_CZArray, CZfadef_index);
1977                   i_1_to_2(datafile_nxArray, CZfadef_nAlphaArray, CZfadef_index);
1978                   CZfadef_nde[CZfadef_index] = datafile_ny;
1979                   if (CZfadef_first==true)
1980                     {
1981                       if (CZfadef_nice == 1)
1982                         {
1983                           CZfadef_na_nice = datafile_nxArray[1];
1984                           CZfadef_nde_nice = datafile_ny;
1985                           d_1_to_1(CZfadef_deArray_nice, datafile_yArray);
1986                           for (i=1; i<=CZfadef_na_nice; i++)
1987                             CZfadef_aArray_nice[i] = datafile_xArray[1][i];
1988                         }
1989                       aeroLiftParts -> storeCommands (*command_line);
1990                       CZfadef_first=false;
1991                     }
1992                   break;
1993                 }
1994               case CZfaqf_flag:
1995                 {
1996                   int CZfaqf_index, i;
1997                   string CZfaqf_file;
1998                   double flap_value;
1999                   CZfaqf_file = aircraft_directory + linetoken3;
2000                   token4 >> CZfaqf_index;
2001                   if (CZfaqf_index < 0 || CZfaqf_index >= 30)
2002                     uiuc_warnings_errors(1, *command_line);
2003                   if (CZfaqf_index > CZfaqf_nf)
2004                     CZfaqf_nf = CZfaqf_index;
2005                   token5 >> flap_value;
2006                   CZfaqf_fArray[CZfaqf_index] = flap_value;
2007                   token6 >> token_value_convert1;
2008                   token7 >> token_value_convert2;
2009                   token8 >> token_value_convert3;
2010                   token9 >> CZfaqf_nice;
2011                   convert_z = uiuc_convert(token_value_convert1);
2012                   convert_x = uiuc_convert(token_value_convert2);
2013                   convert_y = uiuc_convert(token_value_convert3);
2014                   /* call 2D File Reader with file name (CZfaqf_file) and
2015                      conversion factors; function returns array of
2016                      pitch rate (qArray) and corresponding
2017                      alpha (aArray) and delta CZ (CZArray) values and
2018                      max number of terms in alpha arrays (nAlphaArray)
2019                      and pitch rate array (nq) */
2020                   uiuc_2DdataFileReader(CZfaqf_file,
2021                                         datafile_xArray,
2022                                         datafile_yArray,
2023                                         datafile_zArray,
2024                                         datafile_nxArray,
2025                                         datafile_ny);
2026                   d_2_to_3(datafile_xArray, CZfaqf_aArray, CZfaqf_index);
2027                   d_1_to_2(datafile_yArray, CZfaqf_qArray, CZfaqf_index);
2028                   d_2_to_3(datafile_zArray, CZfaqf_CZArray, CZfaqf_index);
2029                   i_1_to_2(datafile_nxArray, CZfaqf_nAlphaArray, CZfaqf_index);
2030                   CZfaqf_nq[CZfaqf_index] = datafile_ny;
2031                   if (CZfaqf_first==true)
2032                     {
2033                       if (CZfaqf_nice == 1)
2034                         {
2035                           CZfaqf_na_nice = datafile_nxArray[1];
2036                           CZfaqf_nq_nice = datafile_ny;
2037                           d_1_to_1(CZfaqf_qArray_nice, datafile_yArray);
2038                           for (i=1; i<=CZfaqf_na_nice; i++)
2039                             CZfaqf_aArray_nice[i] = datafile_xArray[1][i];
2040                         }
2041                       aeroLiftParts -> storeCommands (*command_line);
2042                       CZfaqf_first=false;
2043                     }
2044                   break;
2045                 }
2046               default:
2047                 {
2048                   uiuc_warnings_errors(2, *command_line);
2049                   break;
2050                 }
2051               };
2052             break;
2053           } // end CL map
2054
2055
2056         case Cm_flag:
2057           {
2058             switch(Cm_map[linetoken2])
2059               {
2060               case Cmo_flag:
2061                 {
2062                   if (check_float(linetoken3))
2063                     token3 >> token_value;
2064                   else
2065                     uiuc_warnings_errors(1, *command_line);
2066
2067                   Cmo = token_value;
2068                   Cmo_clean = Cmo;
2069                   aeroPitchParts -> storeCommands (*command_line);
2070                   break;
2071                 }
2072               case Cm_a_flag:
2073                 {
2074                   if (check_float(linetoken3))
2075                     token3 >> token_value;
2076                   else
2077                     uiuc_warnings_errors(1, *command_line);
2078
2079                   Cm_a = token_value;
2080                   Cm_a_clean = Cm_a;
2081                   aeroPitchParts -> storeCommands (*command_line);
2082                   break;
2083                 }
2084               case Cm_a2_flag:
2085                 {
2086                   if (check_float(linetoken3))
2087                     token3 >> token_value;
2088                   else
2089                     uiuc_warnings_errors(1, *command_line);
2090
2091                   Cm_a2 = token_value;
2092                   Cm_a2_clean = Cm_a2;
2093                   aeroPitchParts -> storeCommands (*command_line);
2094                   break;
2095                 }
2096               case Cm_adot_flag:
2097                 {
2098                   if (check_float(linetoken3))
2099                     token3 >> token_value;
2100                   else
2101                     uiuc_warnings_errors(1, *command_line);
2102
2103                   Cm_adot = token_value;
2104                   Cm_adot_clean = Cm_adot;
2105                   aeroPitchParts -> storeCommands (*command_line);
2106                   break;
2107                 }
2108               case Cm_q_flag:
2109                 {
2110                   if (check_float(linetoken3))
2111                     token3 >> token_value;
2112                   else
2113                     uiuc_warnings_errors(1, *command_line);
2114
2115                   Cm_q = token_value;
2116                   Cm_q_clean = Cm_q;
2117                   aeroPitchParts -> storeCommands (*command_line);
2118                   break;
2119                 }
2120               case Cm_ih_flag:
2121                 {
2122                   if (check_float(linetoken3))
2123                     token3 >> token_value;
2124                   else
2125                     uiuc_warnings_errors(1, *command_line);
2126
2127                   Cm_ih = token_value;
2128                   aeroPitchParts -> storeCommands (*command_line);
2129                   break;
2130                 }
2131               case Cm_de_flag:
2132                 {
2133                   if (check_float(linetoken3))
2134                     token3 >> token_value;
2135                   else
2136                     uiuc_warnings_errors(1, *command_line);
2137
2138                   Cm_de = token_value;
2139                   Cm_de_clean = Cm_de;
2140                   aeroPitchParts -> storeCommands (*command_line);
2141                   break;
2142                 }
2143               case Cm_b2_flag:
2144                 {
2145                   if (check_float(linetoken3))
2146                     token3 >> token_value;
2147                   else
2148                     uiuc_warnings_errors(1, *command_line);
2149
2150                   Cm_b2 = token_value;
2151                   Cm_b2_clean = Cm_b2;
2152                   aeroPitchParts -> storeCommands (*command_line);
2153                   break;
2154                 }
2155               case Cm_r_flag:
2156                 {
2157                   if (check_float(linetoken3))
2158                     token3 >> token_value;
2159                   else
2160                     uiuc_warnings_errors(1, *command_line);
2161
2162                   Cm_r = token_value;
2163                   Cm_r_clean = Cm_r;
2164                   aeroPitchParts -> storeCommands (*command_line);
2165                   break;
2166                 }
2167               case Cm_df_flag:
2168                 {
2169                   if (check_float(linetoken3))
2170                     token3 >> token_value;
2171                   else
2172                     uiuc_warnings_errors(1, *command_line);
2173
2174                   Cm_df = token_value;
2175                   Cm_df_clean = Cm_df;
2176                   aeroPitchParts -> storeCommands (*command_line);
2177                   break;
2178                 }
2179               case Cmfa_flag:
2180                 {
2181                   Cmfa = aircraft_directory + linetoken3;
2182                   token4 >> token_value_convert1;
2183                   token5 >> token_value_convert2;
2184                   convert_y = uiuc_convert(token_value_convert1);
2185                   convert_x = uiuc_convert(token_value_convert2);
2186                   /* call 1D File Reader with file name (Cmfa) and conversion
2187                      factors; function returns array of alphas (aArray) and
2188                      corresponding Cm values (CmArray) and max number of
2189                      terms in arrays (nAlpha) */
2190                   uiuc_1DdataFileReader(Cmfa,
2191                                         Cmfa_aArray,
2192                                         Cmfa_CmArray,
2193                                         Cmfa_nAlpha);
2194                   aeroPitchParts -> storeCommands (*command_line);
2195                   break;
2196                 }
2197               case Cmfade_flag:
2198                 {
2199                   Cmfade = aircraft_directory + linetoken3;
2200                   token4 >> token_value_convert1;
2201                   token5 >> token_value_convert2;
2202                   token6 >> token_value_convert3;
2203                   convert_z = uiuc_convert(token_value_convert1);
2204                   convert_x = uiuc_convert(token_value_convert2);
2205                   convert_y = uiuc_convert(token_value_convert3);
2206                   /* call 2D File Reader with file name (Cmfade) and
2207                      conversion factors; function returns array of
2208                      elevator deflections (deArray) and corresponding
2209                      alpha (aArray) and delta Cm (CmArray) values and
2210                      max number of terms in alpha arrays (nAlphaArray)
2211                      and deflection array (nde) */
2212                   uiuc_2DdataFileReader(Cmfade,
2213                                         Cmfade_aArray,
2214                                         Cmfade_deArray,
2215                                         Cmfade_CmArray,
2216                                         Cmfade_nAlphaArray,
2217                                         Cmfade_nde);
2218                   aeroPitchParts -> storeCommands (*command_line);
2219                   break;
2220                 }
2221               case Cmfdf_flag:
2222                 {
2223                   Cmfdf = aircraft_directory + linetoken3;
2224                   token4 >> token_value_convert1;
2225                   token5 >> token_value_convert2;
2226                   convert_y = uiuc_convert(token_value_convert1);
2227                   convert_x = uiuc_convert(token_value_convert2);
2228                   /* call 1D File Reader with file name (Cmfdf) and conversion
2229                      factors; function returns array of dfs (dfArray) and
2230                      corresponding Cm values (CmArray) and max number of
2231                      terms in arrays (ndf) */
2232                   uiuc_1DdataFileReader(Cmfdf,
2233                                         Cmfdf_dfArray,
2234                                         Cmfdf_CmArray,
2235                                         Cmfdf_ndf);
2236                   aeroPitchParts -> storeCommands (*command_line);
2237                   break;
2238                 }
2239               case Cmfadf_flag:
2240                 {
2241                   Cmfadf = aircraft_directory + linetoken3;
2242                   token4 >> token_value_convert1;
2243                   token5 >> token_value_convert2;
2244                   token6 >> token_value_convert3;
2245                   convert_z = uiuc_convert(token_value_convert1);
2246                   convert_x = uiuc_convert(token_value_convert2);
2247                   convert_y = uiuc_convert(token_value_convert3);
2248                   /* call 2D File Reader with file name (Cmfadf) and
2249                      conversion factors; function returns array of
2250                      flap deflections (dfArray) and corresponding
2251                      alpha (aArray) and delta Cm (CmArray) values and
2252                      max number of terms in alpha arrays (nAlphaArray)
2253                      and deflection array (ndf) */
2254                   uiuc_2DdataFileReader(Cmfadf,
2255                                         Cmfadf_aArray,
2256                                         Cmfadf_dfArray,
2257                                         Cmfadf_CmArray,
2258                                         Cmfadf_nAlphaArray,
2259                                         Cmfadf_ndf);
2260                   aeroPitchParts -> storeCommands (*command_line);
2261                   break;
2262                 }
2263               case Cmfabetaf_flag:
2264                 {
2265                   int Cmfabetaf_index, i;
2266                   string Cmfabetaf_file;
2267                   double flap_value;
2268                   Cmfabetaf_file = aircraft_directory + linetoken3;
2269                   token4 >> Cmfabetaf_index;
2270                   if (Cmfabetaf_index < 0 || Cmfabetaf_index >= 30)
2271                     uiuc_warnings_errors(1, *command_line);
2272                   if (Cmfabetaf_index > Cmfabetaf_nf)
2273                     Cmfabetaf_nf = Cmfabetaf_index;
2274                   token5 >> flap_value;
2275                   Cmfabetaf_fArray[Cmfabetaf_index] = flap_value;
2276                   token6 >> token_value_convert1;
2277                   token7 >> token_value_convert2;
2278                   token8 >> token_value_convert3;
2279                   token9 >> Cmfabetaf_nice;
2280                   convert_z = uiuc_convert(token_value_convert1);
2281                   convert_x = uiuc_convert(token_value_convert2);
2282                   convert_y = uiuc_convert(token_value_convert3);
2283                   /* call 2D File Reader with file name (Cmfabetaf_file) and
2284                      conversion factors; function returns array of
2285                      elevator deflections (deArray) and corresponding
2286                      alpha (aArray) and delta CZ (CZArray) values and
2287                      max number of terms in alpha arrays (nAlphaArray)
2288                      and delfection array (nde) */
2289                   uiuc_2DdataFileReader(Cmfabetaf_file,
2290                                         datafile_xArray,
2291                                         datafile_yArray,
2292                                         datafile_zArray,
2293                                         datafile_nxArray,
2294                                         datafile_ny);
2295                   d_2_to_3(datafile_xArray, Cmfabetaf_aArray, Cmfabetaf_index);
2296                   d_1_to_2(datafile_yArray, Cmfabetaf_betaArray, Cmfabetaf_index);
2297                   d_2_to_3(datafile_zArray, Cmfabetaf_CmArray, Cmfabetaf_index);
2298                   i_1_to_2(datafile_nxArray, Cmfabetaf_nAlphaArray, Cmfabetaf_index);
2299                   Cmfabetaf_nbeta[Cmfabetaf_index] = datafile_ny;
2300                   if (Cmfabetaf_first==true)
2301                     {
2302                       if (Cmfabetaf_nice == 1)
2303                         {
2304                           Cmfabetaf_na_nice = datafile_nxArray[1];
2305                           Cmfabetaf_nb_nice = datafile_ny;
2306                           d_1_to_1(Cmfabetaf_bArray_nice, datafile_yArray);
2307                           for (i=1; i<=Cmfabetaf_na_nice; i++)
2308                             Cmfabetaf_aArray_nice[i] = datafile_xArray[1][i];
2309                         }
2310                       aeroPitchParts -> storeCommands (*command_line);
2311                       Cmfabetaf_first=false;
2312                     }
2313                   break;
2314                 }
2315               case Cmfadef_flag:
2316                 {
2317                   int Cmfadef_index, i;
2318                   string Cmfadef_file;
2319                   double flap_value;
2320                   Cmfadef_file = aircraft_directory + linetoken3;
2321                   token4 >> Cmfadef_index;
2322                   if (Cmfadef_index < 0 || Cmfadef_index >= 30)
2323                     uiuc_warnings_errors(1, *command_line);
2324                   if (Cmfadef_index > Cmfadef_nf)
2325                     Cmfadef_nf = Cmfadef_index;
2326                   token5 >> flap_value;
2327                   Cmfadef_fArray[Cmfadef_index] = flap_value;
2328                   token6 >> token_value_convert1;
2329                   token7 >> token_value_convert2;
2330                   token8 >> token_value_convert3;
2331                   token9 >> Cmfadef_nice;
2332                   convert_z = uiuc_convert(token_value_convert1);
2333                   convert_x = uiuc_convert(token_value_convert2);
2334                   convert_y = uiuc_convert(token_value_convert3);
2335                   /* call 2D File Reader with file name (Cmfadef_file) and
2336                      conversion factors; function returns array of
2337                      elevator deflections (deArray) and corresponding
2338                      alpha (aArray) and delta CZ (CZArray) values and
2339                      max number of terms in alpha arrays (nAlphaArray)
2340                      and delfection array (nde) */
2341                   uiuc_2DdataFileReader(Cmfadef_file,
2342                                         datafile_xArray,
2343                                         datafile_yArray,
2344                                         datafile_zArray,
2345                                         datafile_nxArray,
2346                                         datafile_ny);
2347                   d_2_to_3(datafile_xArray, Cmfadef_aArray, Cmfadef_index);
2348                   d_1_to_2(datafile_yArray, Cmfadef_deArray, Cmfadef_index);
2349                   d_2_to_3(datafile_zArray, Cmfadef_CmArray, Cmfadef_index);
2350                   i_1_to_2(datafile_nxArray, Cmfadef_nAlphaArray, Cmfadef_index);
2351                   Cmfadef_nde[Cmfadef_index] = datafile_ny;
2352                   if (Cmfadef_first==true)
2353                     {
2354                       if (Cmfadef_nice == 1)
2355                         {
2356                           Cmfadef_na_nice = datafile_nxArray[1];
2357                           Cmfadef_nde_nice = datafile_ny;
2358                           d_1_to_1(Cmfadef_deArray_nice, datafile_yArray);
2359                           for (i=1; i<=Cmfadef_na_nice; i++)
2360                             Cmfadef_aArray_nice[i] = datafile_xArray[1][i];
2361                         }
2362                       aeroPitchParts -> storeCommands (*command_line);
2363                       Cmfadef_first=false;
2364                     }
2365                   break;
2366                 }
2367               case Cmfaqf_flag:
2368                 {
2369                   int Cmfaqf_index, i;
2370                   string Cmfaqf_file;
2371                   double flap_value;
2372                   Cmfaqf_file = aircraft_directory + linetoken3;
2373                   token4 >> Cmfaqf_index;
2374                   if (Cmfaqf_index < 0 || Cmfaqf_index >= 30)
2375                     uiuc_warnings_errors(1, *command_line);
2376                   if (Cmfaqf_index > Cmfaqf_nf)
2377                     Cmfaqf_nf = Cmfaqf_index;
2378                   token5 >> flap_value;
2379                   Cmfaqf_fArray[Cmfaqf_index] = flap_value;
2380                   token6 >> token_value_convert1;
2381                   token7 >> token_value_convert2;
2382                   token8 >> token_value_convert3;
2383                   token9 >> Cmfaqf_nice;
2384                   convert_z = uiuc_convert(token_value_convert1);
2385                   convert_x = uiuc_convert(token_value_convert2);
2386                   convert_y = uiuc_convert(token_value_convert3);
2387                   /* call 2D File Reader with file name (Cmfaqf_file) and
2388                      conversion factors; function returns array of
2389                      elevator deflections (deArray) and corresponding
2390                      alpha (aArray) and delta CZ (CZArray) values and
2391                      max number of terms in alpha arrays (nAlphaArray)
2392                      and delfection array (nde) */
2393                   uiuc_2DdataFileReader(Cmfaqf_file,
2394                                         datafile_xArray,
2395                                         datafile_yArray,
2396                                         datafile_zArray,
2397                                         datafile_nxArray,
2398                                         datafile_ny);
2399                   d_2_to_3(datafile_xArray, Cmfaqf_aArray, Cmfaqf_index);
2400                   d_1_to_2(datafile_yArray, Cmfaqf_qArray, Cmfaqf_index);
2401                   d_2_to_3(datafile_zArray, Cmfaqf_CmArray, Cmfaqf_index);
2402                   i_1_to_2(datafile_nxArray, Cmfaqf_nAlphaArray, Cmfaqf_index);
2403                   Cmfaqf_nq[Cmfaqf_index] = datafile_ny;
2404                   if (Cmfaqf_first==true)
2405                     {
2406                       if (Cmfaqf_nice == 1)
2407                         {
2408                           Cmfaqf_na_nice = datafile_nxArray[1];
2409                           Cmfaqf_nq_nice = datafile_ny;
2410                           d_1_to_1(Cmfaqf_qArray_nice, datafile_yArray);
2411                           for (i=1; i<=Cmfaqf_na_nice; i++)
2412                             Cmfaqf_aArray_nice[i] = datafile_xArray[1][i];
2413                         }
2414                       aeroPitchParts -> storeCommands (*command_line);
2415                       Cmfaqf_first=false;
2416                     }
2417                   break;
2418                 }
2419               default:
2420                 {
2421                   uiuc_warnings_errors(2, *command_line);
2422                   break;
2423                 }
2424               };
2425             break;
2426           } // end Cm map
2427
2428
2429         case CY_flag:
2430           {
2431             switch(CY_map[linetoken2])
2432               {
2433               case CYo_flag:
2434                 {
2435                   if (check_float(linetoken3))
2436                     token3 >> token_value;
2437                   else
2438                     uiuc_warnings_errors(1, *command_line);
2439
2440                   CYo = token_value;
2441                   CYo_clean = CYo;
2442                   aeroSideforceParts -> storeCommands (*command_line);
2443                   break;
2444                 }
2445               case CY_beta_flag:
2446                 {
2447                   if (check_float(linetoken3))
2448                     token3 >> token_value;
2449                   else
2450                     uiuc_warnings_errors(1, *command_line);
2451
2452                   CY_beta = token_value;
2453                   CY_beta_clean = CY_beta;
2454                   aeroSideforceParts -> storeCommands (*command_line);
2455                   break;
2456                 }
2457               case CY_p_flag:
2458                 {
2459                   if (check_float(linetoken3))
2460                     token3 >> token_value;
2461                   else
2462                     uiuc_warnings_errors(1, *command_line);
2463
2464                   CY_p = token_value;
2465                   CY_p_clean = CY_p;
2466                   aeroSideforceParts -> storeCommands (*command_line);
2467                   break;
2468                 }
2469               case CY_r_flag:
2470                 {
2471                   if (check_float(linetoken3))
2472                     token3 >> token_value;
2473                   else
2474                     uiuc_warnings_errors(1, *command_line);
2475
2476                   CY_r = token_value;
2477                   CY_r_clean = CY_r;
2478                   aeroSideforceParts -> storeCommands (*command_line);
2479                   break;
2480                 }
2481               case CY_da_flag:
2482                 {
2483                   if (check_float(linetoken3))
2484                     token3 >> token_value;
2485                   else
2486                     uiuc_warnings_errors(1, *command_line);
2487
2488                   CY_da = token_value;
2489                   CY_da_clean = CY_da;
2490                   aeroSideforceParts -> storeCommands (*command_line);
2491                   break;
2492                 }
2493               case CY_dr_flag:
2494                 {
2495                   if (check_float(linetoken3))
2496                     token3 >> token_value;
2497                   else
2498                     uiuc_warnings_errors(2, *command_line);
2499
2500                   CY_dr = token_value;
2501                   CY_dr_clean = CY_dr;
2502                   aeroSideforceParts -> storeCommands (*command_line);
2503                   break;
2504                 }
2505               case CY_dra_flag:
2506                 {
2507                   if (check_float(linetoken3))
2508                     token3 >> token_value;
2509                   else
2510                     uiuc_warnings_errors(2, *command_line);
2511
2512                   CY_dra = token_value;
2513                   CY_dra_clean = CY_dra;
2514                   aeroSideforceParts -> storeCommands (*command_line);
2515                   break;
2516                 }
2517               case CY_bdot_flag:
2518                 {
2519                   if (check_float(linetoken3))
2520                     token3 >> token_value;
2521                   else
2522                     uiuc_warnings_errors(2, *command_line);
2523
2524                   CY_bdot = token_value;
2525                   CY_bdot_clean = CY_bdot;
2526                   aeroSideforceParts -> storeCommands (*command_line);
2527                   break;
2528                 }
2529               case CYfada_flag:
2530                 {
2531                   CYfada = aircraft_directory + linetoken3;
2532                   token4 >> token_value_convert1;
2533                   token5 >> token_value_convert2;
2534                   token6 >> token_value_convert3;
2535                   convert_z = uiuc_convert(token_value_convert1);
2536                   convert_x = uiuc_convert(token_value_convert2);
2537                   convert_y = uiuc_convert(token_value_convert3);
2538                   /* call 2D File Reader with file name (CYfada) and
2539                      conversion factors; function returns array of
2540                      aileron deflections (daArray) and corresponding
2541                      alpha (aArray) and delta CY (CYArray) values and
2542                      max number of terms in alpha arrays (nAlphaArray)
2543                      and deflection array (nda) */
2544                   uiuc_2DdataFileReader(CYfada,
2545                                         CYfada_aArray,
2546                                         CYfada_daArray,
2547                                         CYfada_CYArray,
2548                                         CYfada_nAlphaArray,
2549                                         CYfada_nda);
2550                   aeroSideforceParts -> storeCommands (*command_line);
2551                   break;
2552                 }
2553               case CYfbetadr_flag:
2554                 {
2555                   CYfbetadr = aircraft_directory + linetoken3;
2556                   token4 >> token_value_convert1;
2557                   token5 >> token_value_convert2;
2558                   token6 >> token_value_convert3;
2559                   convert_z = uiuc_convert(token_value_convert1);
2560                   convert_x = uiuc_convert(token_value_convert2);
2561                   convert_y = uiuc_convert(token_value_convert3);
2562                   /* call 2D File Reader with file name (CYfbetadr) and
2563                      conversion factors; function returns array of
2564                      rudder deflections (drArray) and corresponding
2565                      beta (betaArray) and delta CY (CYArray) values and
2566                      max number of terms in beta arrays (nBetaArray)
2567                      and deflection array (ndr) */
2568                   uiuc_2DdataFileReader(CYfbetadr,
2569                                         CYfbetadr_betaArray,
2570                                         CYfbetadr_drArray,
2571                                         CYfbetadr_CYArray,
2572                                         CYfbetadr_nBetaArray,
2573                                         CYfbetadr_ndr);
2574                   aeroSideforceParts -> storeCommands (*command_line);
2575                   break;
2576                 }
2577               case CYfabetaf_flag:
2578                 {
2579                   int CYfabetaf_index, i;
2580                   string CYfabetaf_file;
2581                   double flap_value;
2582                   CYfabetaf_file = aircraft_directory + linetoken3;
2583                   token4 >> CYfabetaf_index;
2584                   if (CYfabetaf_index < 0 || CYfabetaf_index >= 30)
2585                     uiuc_warnings_errors(1, *command_line);
2586                   if (CYfabetaf_index > CYfabetaf_nf)
2587                     CYfabetaf_nf = CYfabetaf_index;
2588                   token5 >> flap_value;
2589                   CYfabetaf_fArray[CYfabetaf_index] = flap_value;
2590                   token6 >> token_value_convert1;
2591                   token7 >> token_value_convert2;
2592                   token8 >> token_value_convert3;
2593                   token9 >> CYfabetaf_nice;
2594                   convert_z = uiuc_convert(token_value_convert1);
2595                   convert_x = uiuc_convert(token_value_convert2);
2596                   convert_y = uiuc_convert(token_value_convert3);
2597                   /* call 2D File Reader with file name (CYfabetaf_file) and
2598                      conversion factors; function returns array of
2599                      elevator deflections (deArray) and corresponding
2600                      alpha (aArray) and delta CZ (CZArray) values and
2601                      max number of terms in alpha arrays (nAlphaArray)
2602                      and delfection array (nde) */
2603                   uiuc_2DdataFileReader(CYfabetaf_file,
2604                                         datafile_xArray,
2605                                         datafile_yArray,
2606                                         datafile_zArray,
2607                                         datafile_nxArray,
2608                                         datafile_ny);
2609                   d_2_to_3(datafile_xArray, CYfabetaf_aArray, CYfabetaf_index);
2610                   d_1_to_2(datafile_yArray, CYfabetaf_betaArray, CYfabetaf_index);
2611                   d_2_to_3(datafile_zArray, CYfabetaf_CYArray, CYfabetaf_index);
2612                   i_1_to_2(datafile_nxArray, CYfabetaf_nAlphaArray, CYfabetaf_index);
2613                   CYfabetaf_nbeta[CYfabetaf_index] = datafile_ny;
2614                   if (CYfabetaf_first==true)
2615                     {
2616                       if (CYfabetaf_nice == 1)
2617                         {
2618                           CYfabetaf_na_nice = datafile_nxArray[1];
2619                           CYfabetaf_nb_nice = datafile_ny;
2620                           d_1_to_1(CYfabetaf_bArray_nice, datafile_yArray);
2621                           for (i=1; i<=CYfabetaf_na_nice; i++)
2622                             CYfabetaf_aArray_nice[i] = datafile_xArray[1][i];
2623                         }
2624                       aeroSideforceParts -> storeCommands (*command_line);
2625                       CYfabetaf_first=false;
2626                     }
2627                   break;
2628                 }
2629               case CYfadaf_flag:
2630                 {
2631                   int CYfadaf_index, i;
2632                   string CYfadaf_file;
2633                   double flap_value;
2634                   CYfadaf_file = aircraft_directory + linetoken3;
2635                   token4 >> CYfadaf_index;
2636                   if (CYfadaf_index < 0 || CYfadaf_index >= 30)
2637                     uiuc_warnings_errors(1, *command_line);
2638                   if (CYfadaf_index > CYfadaf_nf)
2639                     CYfadaf_nf = CYfadaf_index;
2640                   token5 >> flap_value;
2641                   CYfadaf_fArray[CYfadaf_index] = flap_value;
2642                   token6 >> token_value_convert1;
2643                   token7 >> token_value_convert2;
2644                   token8 >> token_value_convert3;
2645                   token9 >> CYfadaf_nice;
2646                   convert_z = uiuc_convert(token_value_convert1);
2647                   convert_x = uiuc_convert(token_value_convert2);
2648                   convert_y = uiuc_convert(token_value_convert3);
2649                   /* call 2D File Reader with file name (CYfadaf_file) and
2650                      conversion factors; function returns array of
2651                      elevator deflections (deArray) and corresponding
2652                      alpha (aArray) and delta CZ (CZArray) values and
2653                      max number of terms in alpha arrays (nAlphaArray)
2654                      and delfection array (nde) */
2655                   uiuc_2DdataFileReader(CYfadaf_file,
2656                                         datafile_xArray,
2657                                         datafile_yArray,
2658                                         datafile_zArray,
2659                                         datafile_nxArray,
2660                                         datafile_ny);
2661                   d_2_to_3(datafile_xArray, CYfadaf_aArray, CYfadaf_index);
2662                   d_1_to_2(datafile_yArray, CYfadaf_daArray, CYfadaf_index);
2663                   d_2_to_3(datafile_zArray, CYfadaf_CYArray, CYfadaf_index);
2664                   i_1_to_2(datafile_nxArray, CYfadaf_nAlphaArray, CYfadaf_index);
2665                   CYfadaf_nda[CYfadaf_index] = datafile_ny;
2666                   if (CYfadaf_first==true)
2667                     {
2668                       if (CYfadaf_nice == 1)
2669                         {
2670                           CYfadaf_na_nice = datafile_nxArray[1];
2671                           CYfadaf_nda_nice = datafile_ny;
2672                           d_1_to_1(CYfadaf_daArray_nice, datafile_yArray);
2673                           for (i=1; i<=CYfadaf_na_nice; i++)
2674                             CYfadaf_aArray_nice[i] = datafile_xArray[1][i];
2675                         }
2676                       aeroSideforceParts -> storeCommands (*command_line);
2677                       CYfadaf_first=false;
2678                     }
2679                   break;
2680                 }
2681               case CYfadrf_flag:
2682                 {
2683                   int CYfadrf_index, i;
2684                   string CYfadrf_file;
2685                   double flap_value;
2686                   CYfadrf_file = aircraft_directory + linetoken3;
2687                   token4 >> CYfadrf_index;
2688                   if (CYfadrf_index < 0 || CYfadrf_index >= 30)
2689                     uiuc_warnings_errors(1, *command_line);
2690                   if (CYfadrf_index > CYfadrf_nf)
2691                     CYfadrf_nf = CYfadrf_index;
2692                   token5 >> flap_value;
2693                   CYfadrf_fArray[CYfadrf_index] = flap_value;
2694                   token6 >> token_value_convert1;
2695                   token7 >> token_value_convert2;
2696                   token8 >> token_value_convert3;
2697                   token9 >> CYfadrf_nice;
2698                   convert_z = uiuc_convert(token_value_convert1);
2699                   convert_x = uiuc_convert(token_value_convert2);
2700                   convert_y = uiuc_convert(token_value_convert3);
2701                   /* call 2D File Reader with file name (CYfadrf_file) and
2702                      conversion factors; function returns array of
2703                      elevator deflections (deArray) and corresponding
2704                      alpha (aArray) and delta CZ (CZArray) values and
2705                      max number of terms in alpha arrays (nAlphaArray)
2706                      and delfection array (nde) */
2707                   uiuc_2DdataFileReader(CYfadrf_file,
2708                                         datafile_xArray,
2709                                         datafile_yArray,
2710                                         datafile_zArray,
2711                                         datafile_nxArray,
2712                                         datafile_ny);
2713                   d_2_to_3(datafile_xArray, CYfadrf_aArray, CYfadrf_index);
2714                   d_1_to_2(datafile_yArray, CYfadrf_drArray, CYfadrf_index);
2715                   d_2_to_3(datafile_zArray, CYfadrf_CYArray, CYfadrf_index);
2716                   i_1_to_2(datafile_nxArray, CYfadrf_nAlphaArray, CYfadrf_index);
2717                   CYfadrf_ndr[CYfadrf_index] = datafile_ny;
2718                   if (CYfadrf_first==true)
2719                     {
2720                       if (CYfadrf_nice == 1)
2721                         {
2722                           CYfadrf_na_nice = datafile_nxArray[1];
2723                           CYfadrf_ndr_nice = datafile_ny;
2724                           d_1_to_1(CYfadrf_drArray_nice, datafile_yArray);
2725                           for (i=1; i<=CYfadrf_na_nice; i++)
2726                             CYfadrf_aArray_nice[i] = datafile_xArray[1][i];
2727                         }
2728                       aeroSideforceParts -> storeCommands (*command_line);
2729                       CYfadrf_first=false;
2730                     }
2731                   break;
2732                 }
2733               case CYfapf_flag:
2734                 {
2735                   int CYfapf_index, i;
2736                   string CYfapf_file;
2737                   double flap_value;
2738                   CYfapf_file = aircraft_directory + linetoken3;
2739                   token4 >> CYfapf_index;
2740                   if (CYfapf_index < 0 || CYfapf_index >= 30)
2741                     uiuc_warnings_errors(1, *command_line);
2742                   if (CYfapf_index > CYfapf_nf)
2743                     CYfapf_nf = CYfapf_index;
2744                   token5 >> flap_value;
2745                   CYfapf_fArray[CYfapf_index] = flap_value;
2746                   token6 >> token_value_convert1;
2747                   token7 >> token_value_convert2;
2748                   token8 >> token_value_convert3;
2749                   token9 >> CYfapf_nice;
2750                   convert_z = uiuc_convert(token_value_convert1);
2751                   convert_x = uiuc_convert(token_value_convert2);
2752                   convert_y = uiuc_convert(token_value_convert3);
2753                   /* call 2D File Reader with file name (CYfapf_file) and
2754                      conversion factors; function returns array of
2755                      elevator deflections (deArray) and corresponding
2756                      alpha (aArray) and delta CZ (CZArray) values and
2757                      max number of terms in alpha arrays (nAlphaArray)
2758                      and delfection array (nde) */
2759                   uiuc_2DdataFileReader(CYfapf_file,
2760                                         datafile_xArray,
2761                                         datafile_yArray,
2762                                         datafile_zArray,
2763                                         datafile_nxArray,
2764                                         datafile_ny);
2765                   d_2_to_3(datafile_xArray, CYfapf_aArray, CYfapf_index);
2766                   d_1_to_2(datafile_yArray, CYfapf_pArray, CYfapf_index);
2767                   d_2_to_3(datafile_zArray, CYfapf_CYArray, CYfapf_index);
2768                   i_1_to_2(datafile_nxArray, CYfapf_nAlphaArray, CYfapf_index);
2769                   CYfapf_np[CYfapf_index] = datafile_ny;
2770                   if (CYfapf_first==true)
2771                     {
2772                       if (CYfapf_nice == 1)
2773                         {
2774                           CYfapf_na_nice = datafile_nxArray[1];
2775                           CYfapf_np_nice = datafile_ny;
2776                           d_1_to_1(CYfapf_pArray_nice, datafile_yArray);
2777                           for (i=1; i<=CYfapf_na_nice; i++)
2778                             CYfapf_aArray_nice[i] = datafile_xArray[1][i];
2779                         }
2780                       aeroSideforceParts -> storeCommands (*command_line);
2781                       CYfapf_first=false;
2782                     }
2783                   break;
2784                 }
2785               case CYfarf_flag:
2786                 {
2787                   int CYfarf_index, i;
2788                   string CYfarf_file;
2789                   double flap_value;
2790                   CYfarf_file = aircraft_directory + linetoken3;
2791                   token4 >> CYfarf_index;
2792                   if (CYfarf_index < 0 || CYfarf_index >= 30)
2793                     uiuc_warnings_errors(1, *command_line);
2794                   if (CYfarf_index > CYfarf_nf)
2795                     CYfarf_nf = CYfarf_index;
2796                   token5 >> flap_value;
2797                   CYfarf_fArray[CYfarf_index] = flap_value;
2798                   token6 >> token_value_convert1;
2799                   token7 >> token_value_convert2;
2800                   token8 >> token_value_convert3;
2801                   token9 >> CYfarf_nice;
2802                   convert_z = uiuc_convert(token_value_convert1);
2803                   convert_x = uiuc_convert(token_value_convert2);
2804                   convert_y = uiuc_convert(token_value_convert3);
2805                   /* call 2D File Reader with file name (CYfarf_file) and
2806                      conversion factors; function returns array of
2807                      elevator deflections (deArray) and corresponding
2808                      alpha (aArray) and delta CZ (CZArray) values and
2809                      max number of terms in alpha arrays (nAlphaArray)
2810                      and delfection array (nde) */
2811                   uiuc_2DdataFileReader(CYfarf_file,
2812                                         datafile_xArray,
2813                                         datafile_yArray,
2814                                         datafile_zArray,
2815                                         datafile_nxArray,
2816                                         datafile_ny);
2817                   d_2_to_3(datafile_xArray, CYfarf_aArray, CYfarf_index);
2818                   d_1_to_2(datafile_yArray, CYfarf_rArray, CYfarf_index);
2819                   d_2_to_3(datafile_zArray, CYfarf_CYArray, CYfarf_index);
2820                   i_1_to_2(datafile_nxArray, CYfarf_nAlphaArray, CYfarf_index);
2821                   CYfarf_nr[CYfarf_index] = datafile_ny;
2822                   if (CYfarf_first==true)
2823                     {
2824                       if (CYfarf_nice == 1)
2825                         {
2826                           CYfarf_na_nice = datafile_nxArray[1];
2827                           CYfarf_nr_nice = datafile_ny;
2828                           d_1_to_1(CYfarf_rArray_nice, datafile_yArray);
2829                           for (i=1; i<=CYfarf_na_nice; i++)
2830                             CYfarf_aArray_nice[i] = datafile_xArray[1][i];
2831                         }
2832                       aeroSideforceParts -> storeCommands (*command_line);
2833                       CYfarf_first=false;
2834                     }
2835                   break;
2836                 }
2837               default:
2838                 {
2839                   uiuc_warnings_errors(2, *command_line);
2840                   break;
2841                 }
2842               };
2843             break;
2844           } // end CY map
2845
2846
2847         case Cl_flag:
2848           {
2849             switch(Cl_map[linetoken2])
2850               {
2851               case Clo_flag:
2852                 {
2853                   if (check_float(linetoken3))
2854                     token3 >> token_value;
2855                   else
2856                     uiuc_warnings_errors(1, *command_line);
2857
2858                   Clo = token_value;
2859                   Clo_clean = Clo;
2860                   aeroRollParts -> storeCommands (*command_line);
2861                   break;
2862                 }
2863               case Cl_beta_flag:
2864                 {
2865                   if (check_float(linetoken3))
2866                     token3 >> token_value;
2867                   else
2868                     uiuc_warnings_errors(1, *command_line);
2869
2870                   Cl_beta = token_value;
2871                   Cl_beta_clean = Cl_beta;
2872                   aeroRollParts -> storeCommands (*command_line);
2873                   break;
2874                 }
2875               case Cl_p_flag:
2876                 {
2877                   if (check_float(linetoken3))
2878                     token3 >> token_value;
2879                   else
2880                     uiuc_warnings_errors(1, *command_line);
2881
2882                   Cl_p = token_value;
2883                   Cl_p_clean = Cl_p;
2884                   aeroRollParts -> storeCommands (*command_line);
2885                   break;
2886                 }
2887               case Cl_r_flag:
2888                 {
2889                   if (check_float(linetoken3))
2890                     token3 >> token_value;
2891                   else
2892                     uiuc_warnings_errors(1, *command_line);
2893
2894                   Cl_r = token_value;
2895                   Cl_r_clean = Cl_r;
2896                   aeroRollParts -> storeCommands (*command_line);
2897                   break;
2898                 }
2899               case Cl_da_flag:
2900                 {
2901                   if (check_float(linetoken3))
2902                     token3 >> token_value;
2903                   else
2904                     uiuc_warnings_errors(1, *command_line);
2905
2906                   Cl_da = token_value;
2907                   Cl_da_clean = Cl_da;
2908                   aeroRollParts -> storeCommands (*command_line);
2909                   break;
2910                 }
2911               case Cl_dr_flag:
2912                 {
2913                   if (check_float(linetoken3))
2914                     token3 >> token_value;
2915                   else
2916                     uiuc_warnings_errors(1, *command_line);
2917
2918                   Cl_dr = token_value;
2919                   Cl_dr_clean = Cl_dr;
2920                   aeroRollParts -> storeCommands (*command_line);
2921                   break;
2922                 }
2923               case Cl_daa_flag:
2924                 {
2925                   if (check_float(linetoken3))
2926                     token3 >> token_value;
2927                   else
2928                     uiuc_warnings_errors(1, *command_line);
2929
2930                   Cl_daa = token_value;
2931                   Cl_daa_clean = Cl_daa;
2932                   aeroRollParts -> storeCommands (*command_line);
2933                   break;
2934                 }
2935               case Clfada_flag:
2936                 {
2937                   Clfada = aircraft_directory + linetoken3;
2938                   token4 >> token_value_convert1;
2939                   token5 >> token_value_convert2;
2940                   token6 >> token_value_convert3;
2941                   convert_z = uiuc_convert(token_value_convert1);
2942                   convert_x = uiuc_convert(token_value_convert2);
2943                   convert_y = uiuc_convert(token_value_convert3);
2944                   /* call 2D File Reader with file name (Clfada) and
2945                      conversion factors; function returns array of
2946                      aileron deflections (daArray) and corresponding
2947                      alpha (aArray) and delta Cl (ClArray) values and
2948                      max number of terms in alpha arrays (nAlphaArray)
2949                      and deflection array (nda) */
2950                   uiuc_2DdataFileReader(Clfada,
2951                                         Clfada_aArray,
2952                                         Clfada_daArray,
2953                                         Clfada_ClArray,
2954                                         Clfada_nAlphaArray,
2955                                         Clfada_nda);
2956                   aeroRollParts -> storeCommands (*command_line);
2957                   break;
2958                 }
2959               case Clfbetadr_flag:
2960                 {
2961                   Clfbetadr = aircraft_directory + linetoken3;
2962                   token4 >> token_value_convert1;
2963                   token5 >> token_value_convert2;
2964                   token6 >> token_value_convert3;
2965                   convert_z = uiuc_convert(token_value_convert1);
2966                   convert_x = uiuc_convert(token_value_convert2);
2967                   convert_y = uiuc_convert(token_value_convert3);
2968                   /* call 2D File Reader with file name (Clfbetadr) and
2969                      conversion factors; function returns array of
2970                      rudder deflections (drArray) and corresponding
2971                      beta (betaArray) and delta Cl (ClArray) values and
2972                      max number of terms in beta arrays (nBetaArray)
2973                      and deflection array (ndr) */
2974                   uiuc_2DdataFileReader(Clfbetadr,
2975                                         Clfbetadr_betaArray,
2976                                         Clfbetadr_drArray,
2977                                         Clfbetadr_ClArray,
2978                                         Clfbetadr_nBetaArray,
2979                                         Clfbetadr_ndr);
2980                   aeroRollParts -> storeCommands (*command_line);
2981                   break;
2982                 }
2983               case Clfabetaf_flag:
2984                 {
2985                   int Clfabetaf_index, i;
2986                   string Clfabetaf_file;
2987                   double flap_value;
2988                   Clfabetaf_file = aircraft_directory + linetoken3;
2989                   token4 >> Clfabetaf_index;
2990                   if (Clfabetaf_index < 0 || Clfabetaf_index >= 100)
2991                     uiuc_warnings_errors(1, *command_line);
2992                   if (Clfabetaf_index > Clfabetaf_nf)
2993                     Clfabetaf_nf = Clfabetaf_index;
2994                   token5 >> flap_value;
2995                   Clfabetaf_fArray[Clfabetaf_index] = flap_value;
2996                   token6 >> token_value_convert1;
2997                   token7 >> token_value_convert2;
2998                   token8 >> token_value_convert3;
2999                   token9 >> Clfabetaf_nice;
3000                   convert_z = uiuc_convert(token_value_convert1);
3001                   convert_x = uiuc_convert(token_value_convert2);
3002                   convert_y = uiuc_convert(token_value_convert3);
3003                   /* call 2D File Reader with file name (Clfabetaf_file) and
3004                      conversion factors; function returns array of
3005                      elevator deflections (deArray) and corresponding
3006                      alpha (aArray) and delta CZ (CZArray) values and
3007                      max number of terms in alpha arrays (nAlphaArray)
3008                      and delfection array (nde) */
3009                   uiuc_2DdataFileReader(Clfabetaf_file,
3010                                         datafile_xArray,
3011                                         datafile_yArray,
3012                                         datafile_zArray,
3013                                         datafile_nxArray,
3014                                         datafile_ny);
3015                   d_2_to_3(datafile_xArray, Clfabetaf_aArray, Clfabetaf_index);
3016                   d_1_to_2(datafile_yArray, Clfabetaf_betaArray, Clfabetaf_index);
3017                   d_2_to_3(datafile_zArray, Clfabetaf_ClArray, Clfabetaf_index);
3018                   i_1_to_2(datafile_nxArray, Clfabetaf_nAlphaArray, Clfabetaf_index);
3019                   Clfabetaf_nbeta[Clfabetaf_index] = datafile_ny;
3020                   if (Clfabetaf_first==true)
3021                     {
3022                       if (Clfabetaf_nice == 1)
3023                         {
3024                           Clfabetaf_na_nice = datafile_nxArray[1];
3025                           Clfabetaf_nb_nice = datafile_ny;
3026                           d_1_to_1(Clfabetaf_bArray_nice, datafile_yArray);
3027                           for (i=1; i<=Clfabetaf_na_nice; i++)
3028                             Clfabetaf_aArray_nice[i] = datafile_xArray[1][i];
3029                         }
3030                       aeroRollParts -> storeCommands (*command_line);
3031                       Clfabetaf_first=false;
3032                     }
3033                   break;
3034                 }
3035               case Clfadaf_flag:
3036                 {
3037                   int Clfadaf_index, i;
3038                   string Clfadaf_file;
3039                   double flap_value;
3040                   Clfadaf_file = aircraft_directory + linetoken3;
3041                   token4 >> Clfadaf_index;
3042                   if (Clfadaf_index < 0 || Clfadaf_index >= 100)
3043                     uiuc_warnings_errors(1, *command_line);
3044                   if (Clfadaf_index > Clfadaf_nf)
3045                     Clfadaf_nf = Clfadaf_index;
3046                   token5 >> flap_value;
3047                   Clfadaf_fArray[Clfadaf_index] = flap_value;
3048                   token6 >> token_value_convert1;
3049                   token7 >> token_value_convert2;
3050                   token8 >> token_value_convert3;
3051                   token9 >> Clfadaf_nice;
3052                   convert_z = uiuc_convert(token_value_convert1);
3053                   convert_x = uiuc_convert(token_value_convert2);
3054                   convert_y = uiuc_convert(token_value_convert3);
3055                   /* call 2D File Reader with file name (Clfadaf_file) and
3056                      conversion factors; function returns array of
3057                      elevator deflections (deArray) and corresponding
3058                      alpha (aArray) and delta CZ (CZArray) values and
3059                      max number of terms in alpha arrays (nAlphaArray)
3060                      and delfection array (nde) */
3061                   uiuc_2DdataFileReader(Clfadaf_file,
3062                                         datafile_xArray,
3063                                         datafile_yArray,
3064                                         datafile_zArray,
3065                                         datafile_nxArray,
3066                                         datafile_ny);
3067                   d_2_to_3(datafile_xArray, Clfadaf_aArray, Clfadaf_index);
3068                   d_1_to_2(datafile_yArray, Clfadaf_daArray, Clfadaf_index);
3069                   d_2_to_3(datafile_zArray, Clfadaf_ClArray, Clfadaf_index);
3070                   i_1_to_2(datafile_nxArray, Clfadaf_nAlphaArray, Clfadaf_index);
3071                   Clfadaf_nda[Clfadaf_index] = datafile_ny;
3072                   if (Clfadaf_first==true)
3073                     {
3074                       if (Clfadaf_nice == 1)
3075                         {
3076                           Clfadaf_na_nice = datafile_nxArray[1];
3077                           Clfadaf_nda_nice = datafile_ny;
3078                           d_1_to_1(Clfadaf_daArray_nice, datafile_yArray);
3079                           for (i=1; i<=Clfadaf_na_nice; i++)
3080                             Clfadaf_aArray_nice[i] = datafile_xArray[1][i];
3081                         }
3082                       aeroRollParts -> storeCommands (*command_line);
3083                       Clfadaf_first=false;
3084                     }
3085                   break;
3086                 }
3087               case Clfadrf_flag:
3088                 {
3089                   int Clfadrf_index, i;
3090                   string Clfadrf_file;
3091                   double flap_value;
3092                   Clfadrf_file = aircraft_directory + linetoken3;
3093                   token4 >> Clfadrf_index;
3094                   if (Clfadrf_index < 0 || Clfadrf_index >= 100)
3095                     uiuc_warnings_errors(1, *command_line);
3096                   if (Clfadrf_index > Clfadrf_nf)
3097                     Clfadrf_nf = Clfadrf_index;
3098                   token5 >> flap_value;
3099                   Clfadrf_fArray[Clfadrf_index] = flap_value;
3100                   token6 >> token_value_convert1;
3101                   token7 >> token_value_convert2;
3102                   token8 >> token_value_convert3;
3103                   token9 >> Clfadrf_nice;
3104                   convert_z = uiuc_convert(token_value_convert1);
3105                   convert_x = uiuc_convert(token_value_convert2);
3106                   convert_y = uiuc_convert(token_value_convert3);
3107                   /* call 2D File Reader with file name (Clfadrf_file) and
3108                      conversion factors; function returns array of
3109                      elevator deflections (deArray) and corresponding
3110                      alpha (aArray) and delta CZ (CZArray) values and
3111                      max number of terms in alpha arrays (nAlphaArray)
3112                      and delfection array (nde) */
3113                   uiuc_2DdataFileReader(Clfadrf_file,
3114                                         datafile_xArray,
3115                                         datafile_yArray,
3116                                         datafile_zArray,
3117                                         datafile_nxArray,
3118                                         datafile_ny);
3119                   d_2_to_3(datafile_xArray, Clfadrf_aArray, Clfadrf_index);
3120                   d_1_to_2(datafile_yArray, Clfadrf_drArray, Clfadrf_index);
3121                   d_2_to_3(datafile_zArray, Clfadrf_ClArray, Clfadrf_index);
3122                   i_1_to_2(datafile_nxArray, Clfadrf_nAlphaArray, Clfadrf_index);
3123                   Clfadrf_ndr[Clfadrf_index] = datafile_ny;
3124                   if (Clfadrf_first==true)
3125                     {
3126                       if (Clfadrf_nice == 1)
3127                         {
3128                           Clfadrf_na_nice = datafile_nxArray[1];
3129                           Clfadrf_ndr_nice = datafile_ny;
3130                           d_1_to_1(Clfadrf_drArray_nice, datafile_yArray);
3131                           for (i=1; i<=Clfadrf_na_nice; i++)
3132                             Clfadrf_aArray_nice[i] = datafile_xArray[1][i];
3133                         }
3134                       aeroRollParts -> storeCommands (*command_line);
3135                       Clfadrf_first=false;
3136                     }
3137                   break;
3138                 }
3139               case Clfapf_flag:
3140                 {
3141                   int Clfapf_index, i;
3142                   string Clfapf_file;
3143                   double flap_value;
3144                   Clfapf_file = aircraft_directory + linetoken3;
3145                   token4 >> Clfapf_index;
3146                   if (Clfapf_index < 0 || Clfapf_index >= 100)
3147                     uiuc_warnings_errors(1, *command_line);
3148                   if (Clfapf_index > Clfapf_nf)
3149                     Clfapf_nf = Clfapf_index;
3150                   token5 >> flap_value;
3151                   Clfapf_fArray[Clfapf_index] = flap_value;
3152                   token6 >> token_value_convert1;
3153                   token7 >> token_value_convert2;
3154                   token8 >> token_value_convert3;
3155                   token9 >> Clfapf_nice;
3156                   convert_z = uiuc_convert(token_value_convert1);
3157                   convert_x = uiuc_convert(token_value_convert2);
3158                   convert_y = uiuc_convert(token_value_convert3);
3159                   /* call 2D File Reader with file name (Clfapf_file) and
3160                      conversion factors; function returns array of
3161                      elevator deflections (deArray) and corresponding
3162                      alpha (aArray) and delta CZ (CZArray) values and
3163                      max number of terms in alpha arrays (nAlphaArray)
3164                      and delfection array (nde) */
3165                   uiuc_2DdataFileReader(Clfapf_file,
3166                                         datafile_xArray,
3167                                         datafile_yArray,
3168                                         datafile_zArray,
3169                                         datafile_nxArray,
3170                                         datafile_ny);
3171                   d_2_to_3(datafile_xArray, Clfapf_aArray, Clfapf_index);
3172                   d_1_to_2(datafile_yArray, Clfapf_pArray, Clfapf_index);
3173                   d_2_to_3(datafile_zArray, Clfapf_ClArray, Clfapf_index);
3174                   i_1_to_2(datafile_nxArray, Clfapf_nAlphaArray, Clfapf_index);
3175                   Clfapf_np[Clfapf_index] = datafile_ny;
3176                   if (Clfapf_first==true)
3177                     {
3178                       if (Clfapf_nice == 1)
3179                         {
3180                           Clfapf_na_nice = datafile_nxArray[1];
3181                           Clfapf_np_nice = datafile_ny;
3182                           d_1_to_1(Clfapf_pArray_nice, datafile_yArray);
3183                           for (i=1; i<=Clfapf_na_nice; i++)
3184                             Clfapf_aArray_nice[i] = datafile_xArray[1][i];
3185                         }
3186                       aeroRollParts -> storeCommands (*command_line);
3187                       Clfapf_first=false;
3188                     }
3189                   break;
3190                 }
3191               case Clfarf_flag:
3192                 {
3193                   int Clfarf_index, i;
3194                   string Clfarf_file;
3195                   double flap_value;
3196                   Clfarf_file = aircraft_directory + linetoken3;
3197                   token4 >> Clfarf_index;
3198                   if (Clfarf_index < 0 || Clfarf_index >= 100)
3199                     uiuc_warnings_errors(1, *command_line);
3200                   if (Clfarf_index > Clfarf_nf)
3201                     Clfarf_nf = Clfarf_index;
3202                   token5 >> flap_value;
3203                   Clfarf_fArray[Clfarf_index] = flap_value;
3204                   token6 >> token_value_convert1;
3205                   token7 >> token_value_convert2;
3206                   token8 >> token_value_convert3;
3207                   token9 >> Clfarf_nice;
3208                   convert_z = uiuc_convert(token_value_convert1);
3209                   convert_x = uiuc_convert(token_value_convert2);
3210                   convert_y = uiuc_convert(token_value_convert3);
3211                   /* call 2D File Reader with file name (Clfarf_file) and
3212                      conversion factors; function returns array of
3213                      elevator deflections (deArray) and corresponding
3214                      alpha (aArray) and delta CZ (CZArray) values and
3215                      max number of terms in alpha arrays (nAlphaArray)
3216                      and delfection array (nde) */
3217                   uiuc_2DdataFileReader(Clfarf_file,
3218                                         datafile_xArray,
3219                                         datafile_yArray,
3220                                         datafile_zArray,
3221                                         datafile_nxArray,
3222                                         datafile_ny);
3223                   d_2_to_3(datafile_xArray, Clfarf_aArray, Clfarf_index);
3224                   d_1_to_2(datafile_yArray, Clfarf_rArray, Clfarf_index);
3225                   d_2_to_3(datafile_zArray, Clfarf_ClArray, Clfarf_index);
3226                   i_1_to_2(datafile_nxArray, Clfarf_nAlphaArray, Clfarf_index);
3227                   Clfarf_nr[Clfarf_index] = datafile_ny;
3228                   if (Clfarf_first==true)
3229                     {
3230                       if (Clfarf_nice == 1)
3231                         {
3232                           Clfarf_na_nice = datafile_nxArray[1];
3233                           Clfarf_nr_nice = datafile_ny;
3234                           d_1_to_1(Clfarf_rArray_nice, datafile_yArray);
3235                           for (i=1; i<=Clfarf_na_nice; i++)
3236                             Clfarf_aArray_nice[i] = datafile_xArray[1][i];
3237                         }
3238                       aeroRollParts -> storeCommands (*command_line);
3239                       Clfarf_first=false;
3240                     }
3241                   break;
3242                 }
3243               default:
3244                 {
3245                   uiuc_warnings_errors(2, *command_line);
3246                   break;
3247                 }
3248               };
3249             break;
3250           } // end Cl map
3251
3252
3253         case Cn_flag:
3254           {
3255             switch(Cn_map[linetoken2])
3256               {
3257               case Cno_flag:
3258                 {
3259                   if (check_float(linetoken3))
3260                     token3 >> token_value;
3261                   else
3262                     uiuc_warnings_errors(1, *command_line);
3263
3264                   Cno = token_value;
3265                   Cno_clean = Cno;
3266                   aeroYawParts -> storeCommands (*command_line);
3267                   break;
3268                 }
3269               case Cn_beta_flag:
3270                 {
3271                   if (check_float(linetoken3))
3272                     token3 >> token_value;
3273                   else
3274                     uiuc_warnings_errors(1, *command_line);
3275
3276                   Cn_beta = token_value;
3277                   Cn_beta_clean = Cn_beta;
3278                   aeroYawParts -> storeCommands (*command_line);
3279                   break;
3280                 }
3281               case Cn_p_flag:
3282                 {
3283                   if (check_float(linetoken3))
3284                     token3 >> token_value;
3285                   else
3286                     uiuc_warnings_errors(1, *command_line);
3287
3288                   Cn_p = token_value;
3289                   Cn_p_clean = Cn_p;
3290                   aeroYawParts -> storeCommands (*command_line);
3291                   break;
3292                 }
3293               case Cn_r_flag:
3294                 {
3295                   if (check_float(linetoken3))
3296                     token3 >> token_value;
3297                   else
3298                     uiuc_warnings_errors(1, *command_line);
3299
3300                   Cn_r = token_value;
3301                   Cn_r_clean = Cn_r;
3302                   aeroYawParts -> storeCommands (*command_line);
3303                   break;
3304                 }
3305               case Cn_da_flag:
3306                 {
3307                   if (check_float(linetoken3))
3308                     token3 >> token_value;
3309                   else
3310                     uiuc_warnings_errors(1, *command_line);
3311
3312                   Cn_da = token_value;
3313                   Cn_da_clean = Cn_da;
3314                   aeroYawParts -> storeCommands (*command_line);
3315                   break;
3316                 }
3317               case Cn_dr_flag:
3318                 {
3319                   if (check_float(linetoken3))
3320                     token3 >> token_value;
3321                   else
3322                     uiuc_warnings_errors(1, *command_line);
3323
3324                   Cn_dr = token_value;
3325                   Cn_dr_clean = Cn_dr;
3326                   aeroYawParts -> storeCommands (*command_line);
3327                   break;
3328                 }
3329               case Cn_q_flag:
3330                 {
3331                   if (check_float(linetoken3))
3332                     token3 >> token_value;
3333                   else
3334                     uiuc_warnings_errors(1, *command_line);
3335
3336                   Cn_q = token_value;
3337                   Cn_q_clean = Cn_q;
3338                   aeroYawParts -> storeCommands (*command_line);
3339                   break;
3340                 }
3341               case Cn_b3_flag:
3342                 {
3343                   if (check_float(linetoken3))
3344                     token3 >> token_value;
3345                   else
3346                     uiuc_warnings_errors(1, *command_line);
3347
3348                   Cn_b3 = token_value;
3349                   Cn_b3_clean = Cn_b3;
3350                   aeroYawParts -> storeCommands (*command_line);
3351                   break;
3352                 }
3353               case Cnfada_flag:
3354                 {
3355                   Cnfada = aircraft_directory + linetoken3;
3356                   token4 >> token_value_convert1;
3357                   token5 >> token_value_convert2;
3358                   token6 >> token_value_convert3;
3359                   convert_z = uiuc_convert(token_value_convert1);
3360                   convert_x = uiuc_convert(token_value_convert2);
3361                   convert_y = uiuc_convert(token_value_convert3);
3362                   /* call 2D File Reader with file name (Cnfada) and
3363                      conversion factors; function returns array of
3364                      aileron deflections (daArray) and corresponding
3365                      alpha (aArray) and delta Cn (CnArray) values and
3366                      max number of terms in alpha arrays (nAlphaArray)
3367                      and deflection array (nda) */
3368                   uiuc_2DdataFileReader(Cnfada,
3369                                         Cnfada_aArray,
3370                                         Cnfada_daArray,
3371                                         Cnfada_CnArray,
3372                                         Cnfada_nAlphaArray,
3373                                         Cnfada_nda);
3374                   aeroYawParts -> storeCommands (*command_line);
3375                   break;
3376                 }
3377               case Cnfbetadr_flag:
3378                 {
3379                   Cnfbetadr = aircraft_directory + linetoken3;
3380                   token4 >> token_value_convert1;
3381                   token5 >> token_value_convert2;
3382                   token6 >> token_value_convert3;
3383                   convert_z = uiuc_convert(token_value_convert1);
3384                   convert_x = uiuc_convert(token_value_convert2);
3385                   convert_y = uiuc_convert(token_value_convert3);
3386                   /* call 2D File Reader with file name (Cnfbetadr) and
3387                      conversion factors; function returns array of
3388                      rudder deflections (drArray) and corresponding
3389                      beta (betaArray) and delta Cn (CnArray) values and
3390                      max number of terms in beta arrays (nBetaArray)
3391                      and deflection array (ndr) */
3392                   uiuc_2DdataFileReader(Cnfbetadr,
3393                                         Cnfbetadr_betaArray,
3394                                         Cnfbetadr_drArray,
3395                                         Cnfbetadr_CnArray,
3396                                         Cnfbetadr_nBetaArray,
3397                                         Cnfbetadr_ndr);
3398                   aeroYawParts -> storeCommands (*command_line);
3399                   break;
3400                 }
3401               case Cnfabetaf_flag:
3402                 {
3403                   int Cnfabetaf_index, i;
3404                   string Cnfabetaf_file;
3405                   double flap_value;
3406                   Cnfabetaf_file = aircraft_directory + linetoken3;
3407                   token4 >> Cnfabetaf_index;
3408                   if (Cnfabetaf_index < 0 || Cnfabetaf_index >= 100)
3409                     uiuc_warnings_errors(1, *command_line);
3410                   if (Cnfabetaf_index > Cnfabetaf_nf)
3411                     Cnfabetaf_nf = Cnfabetaf_index;
3412                   token5 >> flap_value;
3413                   Cnfabetaf_fArray[Cnfabetaf_index] = flap_value;
3414                   token6 >> token_value_convert1;
3415                   token7 >> token_value_convert2;
3416                   token8 >> token_value_convert3;
3417                   token9 >> Cnfabetaf_nice;
3418                   convert_z = uiuc_convert(token_value_convert1);
3419                   convert_x = uiuc_convert(token_value_convert2);
3420                   convert_y = uiuc_convert(token_value_convert3);
3421                   /* call 2D File Reader with file name (Cnfabetaf_file) and
3422                      conversion factors; function returns array of
3423                      elevator deflections (deArray) and corresponding
3424                      alpha (aArray) and delta CZ (CZArray) values and
3425                      max number of terms in alpha arrays (nAlphaArray)
3426                      and delfection array (nde) */
3427                   uiuc_2DdataFileReader(Cnfabetaf_file,
3428                                         datafile_xArray,
3429                                         datafile_yArray,
3430                                         datafile_zArray,
3431                                         datafile_nxArray,
3432                                         datafile_ny);
3433                   d_2_to_3(datafile_xArray, Cnfabetaf_aArray, Cnfabetaf_index);
3434                   d_1_to_2(datafile_yArray, Cnfabetaf_betaArray, Cnfabetaf_index);
3435                   d_2_to_3(datafile_zArray, Cnfabetaf_CnArray, Cnfabetaf_index);
3436                   i_1_to_2(datafile_nxArray, Cnfabetaf_nAlphaArray, Cnfabetaf_index);
3437                   Cnfabetaf_nbeta[Cnfabetaf_index] = datafile_ny;
3438                   if (Cnfabetaf_first==true)
3439                     {
3440                       if (Cnfabetaf_nice == 1)
3441                         {
3442                           Cnfabetaf_na_nice = datafile_nxArray[1];
3443                           Cnfabetaf_nb_nice = datafile_ny;
3444                           d_1_to_1(Cnfabetaf_bArray_nice, datafile_yArray);
3445                           for (i=1; i<=Cnfabetaf_na_nice; i++)
3446                             Cnfabetaf_aArray_nice[i] = datafile_xArray[1][i];
3447                         }
3448                       aeroYawParts -> storeCommands (*command_line);
3449                       Cnfabetaf_first=false;
3450                     }
3451                   break;
3452                 }
3453               case Cnfadaf_flag:
3454                 {
3455                   int Cnfadaf_index, i;
3456                   string Cnfadaf_file;
3457                   double flap_value;
3458                   Cnfadaf_file = aircraft_directory + linetoken3;
3459                   token4 >> Cnfadaf_index;
3460                   if (Cnfadaf_index < 0 || Cnfadaf_index >= 100)
3461                     uiuc_warnings_errors(1, *command_line);
3462                   if (Cnfadaf_index > Cnfadaf_nf)
3463                     Cnfadaf_nf = Cnfadaf_index;
3464                   token5 >> flap_value;
3465                   Cnfadaf_fArray[Cnfadaf_index] = flap_value;
3466                   token6 >> token_value_convert1;
3467                   token7 >> token_value_convert2;
3468                   token8 >> token_value_convert3;
3469                   token9 >> Cnfadaf_nice;
3470                   convert_z = uiuc_convert(token_value_convert1);
3471                   convert_x = uiuc_convert(token_value_convert2);
3472                   convert_y = uiuc_convert(token_value_convert3);
3473                   /* call 2D File Reader with file name (Cnfadaf_file) and
3474                      conversion factors; function returns array of
3475                      elevator deflections (deArray) and corresponding
3476                      alpha (aArray) and delta CZ (CZArray) values and
3477                      max number of terms in alpha arrays (nAlphaArray)
3478                      and delfection array (nde) */
3479                   uiuc_2DdataFileReader(Cnfadaf_file,
3480                                         datafile_xArray,
3481                                         datafile_yArray,
3482                                         datafile_zArray,
3483                                         datafile_nxArray,
3484                                         datafile_ny);
3485                   d_2_to_3(datafile_xArray, Cnfadaf_aArray, Cnfadaf_index);
3486                   d_1_to_2(datafile_yArray, Cnfadaf_daArray, Cnfadaf_index);
3487                   d_2_to_3(datafile_zArray, Cnfadaf_CnArray, Cnfadaf_index);
3488                   i_1_to_2(datafile_nxArray, Cnfadaf_nAlphaArray, Cnfadaf_index);
3489                   Cnfadaf_nda[Cnfadaf_index] = datafile_ny;
3490                   if (Cnfadaf_first==true)
3491                     {
3492                       if (Cnfadaf_nice == 1)
3493                         {
3494                           Cnfadaf_na_nice = datafile_nxArray[1];
3495                           Cnfadaf_nda_nice = datafile_ny;
3496                           d_1_to_1(Cnfadaf_daArray_nice, datafile_yArray);
3497                           for (i=1; i<=Cnfadaf_na_nice; i++)
3498                             Cnfadaf_aArray_nice[i] = datafile_xArray[1][i];
3499                         }
3500                       aeroYawParts -> storeCommands (*command_line);
3501                       Cnfadaf_first=false;
3502                     }
3503                   break;
3504                 }
3505               case Cnfadrf_flag:
3506                 {
3507                   int Cnfadrf_index, i;
3508                   string Cnfadrf_file;
3509                   double flap_value;
3510                   Cnfadrf_file = aircraft_directory + linetoken3;
3511                   token4 >> Cnfadrf_index;
3512                   if (Cnfadrf_index < 0 || Cnfadrf_index >= 100)
3513                     uiuc_warnings_errors(1, *command_line);
3514                   if (Cnfadrf_index > Cnfadrf_nf)
3515                     Cnfadrf_nf = Cnfadrf_index;
3516                   token5 >> flap_value;
3517                   Cnfadrf_fArray[Cnfadrf_index] = flap_value;
3518                   token6 >> token_value_convert1;
3519                   token7 >> token_value_convert2;
3520                   token8 >> token_value_convert3;
3521                   token9 >> Cnfadrf_nice;
3522                   convert_z = uiuc_convert(token_value_convert1);
3523                   convert_x = uiuc_convert(token_value_convert2);
3524                   convert_y = uiuc_convert(token_value_convert3);
3525                   /* call 2D File Reader with file name (Cnfadrf_file) and
3526                      conversion factors; function returns array of
3527                      elevator deflections (deArray) and corresponding
3528                      alpha (aArray) and delta CZ (CZArray) values and
3529                      max number of terms in alpha arrays (nAlphaArray)
3530                      and delfection array (nde) */
3531                   uiuc_2DdataFileReader(Cnfadrf_file,
3532                                         datafile_xArray,
3533                                         datafile_yArray,
3534                                         datafile_zArray,
3535                                         datafile_nxArray,
3536                                         datafile_ny);
3537                   d_2_to_3(datafile_xArray, Cnfadrf_aArray, Cnfadrf_index);
3538                   d_1_to_2(datafile_yArray, Cnfadrf_drArray, Cnfadrf_index);
3539                   d_2_to_3(datafile_zArray, Cnfadrf_CnArray, Cnfadrf_index);
3540                   i_1_to_2(datafile_nxArray, Cnfadrf_nAlphaArray, Cnfadrf_index);
3541                   Cnfadrf_ndr[Cnfadrf_index] = datafile_ny;
3542                   if (Cnfadrf_first==true)
3543                     {
3544                       if (Cnfadrf_nice == 1)
3545                         {
3546                           Cnfadrf_na_nice = datafile_nxArray[1];
3547                           Cnfadrf_ndr_nice = datafile_ny;
3548                           d_1_to_1(Cnfadrf_drArray_nice, datafile_yArray);
3549                           for (i=1; i<=Cnfadrf_na_nice; i++)
3550                             Cnfadrf_aArray_nice[i] = datafile_xArray[1][i];
3551                         }
3552                       aeroYawParts -> storeCommands (*command_line);
3553                       Cnfadrf_first=false;
3554                     }
3555                   break;
3556                 }
3557               case Cnfapf_flag:
3558                 {
3559                   int Cnfapf_index, i;
3560                   string Cnfapf_file;
3561                   double flap_value;
3562                   Cnfapf_file = aircraft_directory + linetoken3;
3563                   token4 >> Cnfapf_index;
3564                   if (Cnfapf_index < 0 || Cnfapf_index >= 100)
3565                     uiuc_warnings_errors(1, *command_line);
3566                   if (Cnfapf_index > Cnfapf_nf)
3567                     Cnfapf_nf = Cnfapf_index;
3568                   token5 >> flap_value;
3569                   Cnfapf_fArray[Cnfapf_index] = flap_value;
3570                   token6 >> token_value_convert1;
3571                   token7 >> token_value_convert2;
3572                   token8 >> token_value_convert3;
3573                   token9 >> Cnfapf_nice;
3574                   convert_z = uiuc_convert(token_value_convert1);
3575                   convert_x = uiuc_convert(token_value_convert2);
3576                   convert_y = uiuc_convert(token_value_convert3);
3577                   /* call 2D File Reader with file name (Cnfapf_file) and
3578                      conversion factors; function returns array of
3579                      elevator deflections (deArray) and corresponding
3580                      alpha (aArray) and delta CZ (CZArray) values and
3581                      max number of terms in alpha arrays (nAlphaArray)
3582                      and delfection array (nde) */
3583                   uiuc_2DdataFileReader(Cnfapf_file,
3584                                         datafile_xArray,
3585                                         datafile_yArray,
3586                                         datafile_zArray,
3587                                         datafile_nxArray,
3588                                         datafile_ny);
3589                   d_2_to_3(datafile_xArray, Cnfapf_aArray, Cnfapf_index);
3590                   d_1_to_2(datafile_yArray, Cnfapf_pArray, Cnfapf_index);
3591                   d_2_to_3(datafile_zArray, Cnfapf_CnArray, Cnfapf_index);
3592                   i_1_to_2(datafile_nxArray, Cnfapf_nAlphaArray, Cnfapf_index);
3593                   Cnfapf_np[Cnfapf_index] = datafile_ny;
3594                   if (Cnfapf_first==true)
3595                     {
3596                       if (Cnfapf_nice == 1)
3597                         {
3598                           Cnfapf_na_nice = datafile_nxArray[1];
3599                           Cnfapf_np_nice = datafile_ny;
3600                           d_1_to_1(Cnfapf_pArray_nice, datafile_yArray);
3601                           for (i=1; i<=Cnfapf_na_nice; i++)
3602                             Cnfapf_aArray_nice[i] = datafile_xArray[1][i];
3603                         }
3604                       aeroYawParts -> storeCommands (*command_line);
3605                       Cnfapf_first=false;
3606                     }
3607                   break;
3608                 }
3609               case Cnfarf_flag:
3610                 {
3611                   int Cnfarf_index, i;
3612                   string Cnfarf_file;
3613                   double flap_value;
3614                   Cnfarf_file = aircraft_directory + linetoken3;
3615                   token4 >> Cnfarf_index;
3616                   if (Cnfarf_index < 0 || Cnfarf_index >= 100)
3617                     uiuc_warnings_errors(1, *command_line);
3618                   if (Cnfarf_index > Cnfarf_nf)
3619                     Cnfarf_nf = Cnfarf_index;
3620                   token5 >> flap_value;
3621                   Cnfarf_fArray[Cnfarf_index] = flap_value;
3622                   token6 >> token_value_convert1;
3623                   token7 >> token_value_convert2;
3624                   token8 >> token_value_convert3;
3625                   token9 >> Cnfarf_nice;
3626                   convert_z = uiuc_convert(token_value_convert1);
3627                   convert_x = uiuc_convert(token_value_convert2);
3628                   convert_y = uiuc_convert(token_value_convert3);
3629                   /* call 2D File Reader with file name (Cnfarf_file) and
3630                      conversion factors; function returns array of
3631                      elevator deflections (deArray) and corresponding
3632                      alpha (aArray) and delta CZ (CZArray) values and
3633                      max number of terms in alpha arrays (nAlphaArray)
3634                      and delfection array (nde) */
3635                   uiuc_2DdataFileReader(Cnfarf_file,
3636                                         datafile_xArray,
3637                                         datafile_yArray,
3638                                         datafile_zArray,
3639                                         datafile_nxArray,
3640                                         datafile_ny);
3641                   d_2_to_3(datafile_xArray, Cnfarf_aArray, Cnfarf_index);
3642                   d_1_to_2(datafile_yArray, Cnfarf_rArray, Cnfarf_index);
3643                   d_2_to_3(datafile_zArray, Cnfarf_CnArray, Cnfarf_index);
3644                   i_1_to_2(datafile_nxArray, Cnfarf_nAlphaArray, Cnfarf_index);
3645                   Cnfarf_nr[Cnfarf_index] = datafile_ny;
3646                   if (Cnfarf_first==true)
3647                     {
3648                       if (Cnfarf_nice == 1)
3649                         {
3650                           Cnfarf_na_nice = datafile_nxArray[1];
3651                           Cnfarf_nr_nice = datafile_ny;
3652                           d_1_to_1(Cnfarf_rArray_nice, datafile_yArray);
3653                           for (i=1; i<=Cnfarf_na_nice; i++)
3654                             Cnfarf_aArray_nice[i] = datafile_xArray[1][i];
3655                         }
3656                       aeroYawParts -> storeCommands (*command_line);
3657                       Cnfarf_first=false;
3658                     }
3659                   break;
3660                 }
3661               default:
3662                 {
3663                   uiuc_warnings_errors(2, *command_line);
3664                   break;
3665                 }
3666               };
3667             break;
3668           } // end Cn map
3669
3670
3671         case gear_flag:
3672           {
3673             int index;
3674             token3 >> index;
3675             if (index < 0 || index >= 16)
3676               uiuc_warnings_errors(1, *command_line);
3677             switch(gear_map[linetoken2])
3678               {
3679               case Dx_gear_flag:
3680                 {
3681                   if (check_float(linetoken3))
3682                     token4 >> token_value;
3683                   else
3684                     uiuc_warnings_errors(1, *command_line);
3685                   D_gear_v[index][0] = token_value;
3686                   gear_model[index] = true;
3687                   break;
3688                 }
3689               case Dy_gear_flag:
3690                 {
3691                   if (check_float(linetoken3))
3692                     token4 >> token_value;
3693                   else
3694                     uiuc_warnings_errors(1, *command_line);
3695                   D_gear_v[index][1] = token_value;
3696                   gear_model[index] = true;
3697                   break;
3698                 }
3699               case Dz_gear_flag:
3700                 {
3701                   if (check_float(linetoken3))
3702                     token4 >> token_value;
3703                   else
3704                     uiuc_warnings_errors(1, *command_line);
3705                   D_gear_v[index][2] = token_value;
3706                   gear_model[index] = true;
3707                   break;
3708                 }
3709               case cgear_flag:
3710                 {
3711                   if (check_float(linetoken3))
3712                     token4 >> token_value;
3713                   else
3714                     uiuc_warnings_errors(1, *command_line);
3715                   cgear[index] = token_value;
3716                   gear_model[index] = true;
3717                   break;
3718                 }
3719               case kgear_flag:
3720                 {
3721                   if (check_float(linetoken3))
3722                     token4 >> token_value;
3723                   else
3724                     uiuc_warnings_errors(1, *command_line);
3725                   kgear[index] = token_value;
3726                   gear_model[index] = true;
3727                   break;
3728                 }
3729               case muGear_flag:
3730                 {
3731                   if (check_float(linetoken3))
3732                     token4 >> token_value;
3733                   else
3734                     uiuc_warnings_errors(1, *command_line);
3735                   muGear[index] = token_value;
3736                   gear_model[index] = true;
3737                   break;
3738                 }
3739               case strutLength_flag:
3740                 {
3741                   if (check_float(linetoken3))
3742                     token4 >> token_value;
3743                   else
3744                     uiuc_warnings_errors(1, *command_line);
3745                   strutLength[index] = token_value;
3746                   gear_model[index] = true;
3747                   break;
3748                 }
3749               default:
3750                 {
3751                   uiuc_warnings_errors(2, *command_line);
3752                   break;
3753                 }
3754               };
3755             break;
3756           } // end gear map
3757
3758
3759         case ice_flag:
3760           {
3761             switch(ice_map[linetoken2])
3762               {
3763               case iceTime_flag:
3764                 {
3765                   if (check_float(linetoken3))
3766                     token3 >> token_value;
3767
3768                   else
3769                     uiuc_warnings_errors(1, *command_line);
3770
3771                   ice_model = true;
3772                   iceTime = token_value;
3773                   break;
3774                 }
3775               case transientTime_flag:
3776                 {
3777                   if (check_float(linetoken3))
3778                     token3 >> token_value;
3779                   else
3780                     uiuc_warnings_errors(1, *command_line);
3781
3782                   transientTime = token_value;
3783                   break;
3784                 }
3785               case eta_ice_final_flag:
3786                 {
3787                   if (check_float(linetoken3))
3788                     token3 >> token_value;
3789                   else
3790                     uiuc_warnings_errors(1, *command_line);
3791
3792                   eta_ice_final = token_value;
3793                   break;
3794                 }
3795               case beta_probe_wing_flag:
3796                 {
3797                   if (check_float(linetoken3))
3798                     token3 >> token_value;
3799                   else
3800                     uiuc_warnings_errors(1, *command_line);
3801
3802                   beta_model = true;
3803                   x_probe_wing = token_value;
3804                   break;
3805                 }
3806               case beta_probe_tail_flag:
3807                 {
3808                   if (check_float(linetoken3))
3809                     token3 >> token_value;
3810                   else
3811                     uiuc_warnings_errors(1, *command_line);
3812
3813                   beta_model = true;
3814                   x_probe_tail = token_value;
3815                   break;
3816                 }
3817               case kCDo_flag:
3818                 {
3819                   if (check_float(linetoken3))
3820                     token3 >> token_value;
3821                   else
3822                     uiuc_warnings_errors(1, *command_line);
3823
3824                   kCDo = token_value;
3825                   break;
3826                 }
3827               case kCDK_flag:
3828                 {
3829                   if (check_float(linetoken3))
3830                     token3 >> token_value;
3831                   else
3832                     uiuc_warnings_errors(1, *command_line);
3833
3834                   kCDK = token_value;
3835                   break;
3836                 }
3837               case kCD_a_flag:
3838                 {
3839                   if (check_float(linetoken3))
3840                     token3 >> token_value;
3841                   else
3842                     uiuc_warnings_errors(1, *command_line);
3843
3844                   kCD_a = token_value;
3845                   break;
3846                 }
3847               case kCD_adot_flag:
3848                 {
3849                   if (check_float(linetoken3))
3850                     token3 >> token_value;
3851                   else
3852                     uiuc_warnings_errors(1, *command_line);
3853
3854                   kCD_adot = token_value;
3855                   break;
3856                 }
3857               case kCD_q_flag:
3858                 {
3859                   if (check_float(linetoken3))
3860                     token3 >> token_value;
3861                   else
3862                     uiuc_warnings_errors(1, *command_line);
3863
3864                   kCD_q = token_value;
3865                   break;
3866                 }
3867               case kCD_de_flag:
3868                 {
3869                   if (check_float(linetoken3))
3870                     token3 >> token_value;
3871                   else
3872                     uiuc_warnings_errors(1, *command_line);
3873
3874                   kCD_de = token_value;
3875                   break;
3876                 }
3877               case kCXo_flag:
3878                 {
3879                   if (check_float(linetoken3))
3880                     token3 >> token_value;
3881                   else
3882                     uiuc_warnings_errors(1, *command_line);
3883
3884                   kCXo = token_value;
3885                   break;
3886                 }
3887               case kCXK_flag:
3888                 {
3889                   if (check_float(linetoken3))
3890                     token3 >> token_value;
3891                   else
3892                     uiuc_warnings_errors(1, *command_line);
3893
3894                   kCXK = token_value;
3895                   break;
3896                 }
3897               case kCX_a_flag:
3898                 {
3899                   if (check_float(linetoken3))
3900                     token3 >> token_value;
3901                   else
3902                     uiuc_warnings_errors(1, *command_line);
3903
3904                   kCX_a = token_value;
3905                   break;
3906                 }
3907               case kCX_a2_flag:
3908                 {
3909                   if (check_float(linetoken3))
3910                     token3 >> token_value;
3911                   else
3912                     uiuc_warnings_errors(1, *command_line);
3913
3914                   kCX_a2 = token_value;
3915                   break;
3916                 }
3917               case kCX_a3_flag:
3918                 {
3919                   if (check_float(linetoken3))
3920                     token3 >> token_value;
3921                   else
3922                     uiuc_warnings_errors(1, *command_line);
3923
3924                   kCX_a3 = token_value;
3925                   break;
3926                 }
3927               case kCX_adot_flag:
3928                 {
3929                   if (check_float(linetoken3))
3930                     token3 >> token_value;
3931                   else
3932                     uiuc_warnings_errors(1, *command_line);
3933
3934                   kCX_adot = token_value;
3935                   break;
3936                 }
3937               case kCX_q_flag:
3938                 {
3939                   if (check_float(linetoken3))
3940                     token3 >> token_value;
3941                   else
3942                     uiuc_warnings_errors(1, *command_line);
3943
3944                   kCX_q = token_value;
3945                   break;
3946                 }
3947               case kCX_de_flag:
3948                 {
3949                   if (check_float(linetoken3))
3950                     token3 >> token_value;
3951                   else
3952                     uiuc_warnings_errors(1, *command_line);
3953
3954                   kCX_de = token_value;
3955                   break;
3956                 }
3957               case kCX_dr_flag:
3958                 {
3959                   if (check_float(linetoken3))
3960                     token3 >> token_value;
3961                   else
3962                     uiuc_warnings_errors(1, *command_line);
3963
3964                   kCX_dr = token_value;
3965                   break;
3966                 }
3967               case kCX_df_flag:
3968                 {
3969                   if (check_float(linetoken3))
3970                     token3 >> token_value;
3971                   else
3972                     uiuc_warnings_errors(1, *command_line);
3973
3974                   kCX_df = token_value;
3975                   break;
3976                 }
3977               case kCX_adf_flag:
3978                 {
3979                   if (check_float(linetoken3))
3980                     token3 >> token_value;
3981                   else
3982                     uiuc_warnings_errors(1, *command_line);
3983
3984                   kCX_adf = token_value;
3985                   break;
3986                 }
3987               case kCLo_flag:
3988                 {
3989                   if (check_float(linetoken3))
3990                     token3 >> token_value;
3991                   else
3992                     uiuc_warnings_errors(1, *command_line);
3993
3994                   kCLo = token_value;
3995                   break;
3996                 }
3997               case kCL_a_flag:
3998                 {
3999                   if (check_float(linetoken3))
4000                     token3 >> token_value;
4001                   else
4002                     uiuc_warnings_errors(1, *command_line);
4003
4004                   kCL_a = token_value;
4005                   break;
4006                 }
4007               case kCL_adot_flag:
4008                 {
4009                   if (check_float(linetoken3))
4010                     token3 >> token_value;
4011                   else
4012                     uiuc_warnings_errors(1, *command_line);
4013
4014                   kCL_adot = token_value;
4015                   break;
4016                 }
4017               case kCL_q_flag:
4018                 {
4019                   if (check_float(linetoken3))
4020                     token3 >> token_value;
4021                   else
4022                     uiuc_warnings_errors(1, *command_line);
4023
4024                   kCL_q = token_value;
4025                   break;
4026                 }
4027               case kCL_de_flag:
4028                 {
4029                   if (check_float(linetoken3))
4030                     token3 >> token_value;
4031                   else
4032                     uiuc_warnings_errors(1, *command_line);
4033
4034                   kCL_de = token_value;
4035                   break;
4036                 }
4037               case kCZo_flag:
4038                 {
4039                   if (check_float(linetoken3))
4040                     token3 >> token_value;
4041                   else
4042                     uiuc_warnings_errors(1, *command_line);
4043
4044                   kCZo = token_value;
4045                   break;
4046                 }
4047               case kCZ_a_flag:
4048                 {
4049                   if (check_float(linetoken3))
4050                     token3 >> token_value;
4051                   else
4052                     uiuc_warnings_errors(1, *command_line);
4053
4054                   kCZ_a = token_value;
4055                   break;
4056                 }
4057               case kCZ_a2_flag:
4058                 {
4059                   if (check_float(linetoken3))
4060                     token3 >> token_value;
4061                   else
4062                     uiuc_warnings_errors(1, *command_line);
4063
4064                   kCZ_a2 = token_value;
4065                   break;
4066                 }
4067               case kCZ_a3_flag:
4068                 {
4069                   if (check_float(linetoken3))
4070                     token3 >> token_value;
4071                   else
4072                     uiuc_warnings_errors(1, *command_line);
4073
4074                   kCZ_a3 = token_value;
4075                   break;
4076                 }
4077               case kCZ_adot_flag:
4078                 {
4079                   if (check_float(linetoken3))
4080                     token3 >> token_value;
4081                   else
4082                     uiuc_warnings_errors(1, *command_line);
4083
4084                   kCZ_adot = token_value;
4085                   break;
4086                 }
4087               case kCZ_q_flag:
4088                 {
4089                   if (check_float(linetoken3))
4090                     token3 >> token_value;
4091                   else
4092                     uiuc_warnings_errors(1, *command_line);
4093
4094                   kCZ_q = token_value;
4095                   break;
4096                 }
4097               case kCZ_de_flag:
4098                 {
4099                   if (check_float(linetoken3))
4100                     token3 >> token_value;
4101                   else
4102                     uiuc_warnings_errors(1, *command_line);
4103
4104                   kCZ_de = token_value;
4105                   break;
4106                 }
4107               case kCZ_deb2_flag:
4108                 {
4109                   if (check_float(linetoken3))
4110                     token3 >> token_value;
4111                   else
4112                     uiuc_warnings_errors(1, *command_line);
4113
4114                   kCZ_deb2 = token_value;
4115                   break;
4116                 }
4117               case kCZ_df_flag:
4118                 {
4119                   if (check_float(linetoken3))
4120                     token3 >> token_value;
4121                   else
4122                     uiuc_warnings_errors(1, *command_line);
4123
4124                   kCZ_df = token_value;
4125                   break;
4126                 }
4127               case kCZ_adf_flag:
4128                 {
4129                   if (check_float(linetoken3))
4130                     token3 >> token_value;
4131                   else
4132                     uiuc_warnings_errors(1, *command_line);
4133
4134                   kCZ_adf = token_value;
4135                   break;
4136                 }
4137               case kCmo_flag:
4138                 {
4139                   if (check_float(linetoken3))
4140                     token3 >> token_value;
4141                   else
4142                     uiuc_warnings_errors(1, *command_line);
4143
4144                   kCmo = token_value;
4145                   break;
4146                 }
4147               case kCm_a_flag:
4148                 {
4149                   if (check_float(linetoken3))
4150                     token3 >> token_value;
4151                   else
4152                     uiuc_warnings_errors(1, *command_line);
4153
4154                   kCm_a = token_value;
4155                   break;
4156                 }
4157               case kCm_a2_flag:
4158                 {
4159                   if (check_float(linetoken3))
4160                     token3 >> token_value;
4161                   else
4162                     uiuc_warnings_errors(1, *command_line);
4163
4164                   kCm_a2 = token_value;
4165                   break;
4166                 }
4167               case kCm_adot_flag:
4168                 {
4169                   if (check_float(linetoken3))
4170                     token3 >> token_value;
4171                   else
4172                     uiuc_warnings_errors(1, *command_line);
4173
4174                   kCm_adot = token_value;
4175                   break;
4176                 }
4177               case kCm_q_flag:
4178                 {
4179                   if (check_float(linetoken3))
4180                     token3 >> token_value;
4181                   else
4182                     uiuc_warnings_errors(1, *command_line);
4183
4184                   kCm_q = token_value;
4185                   break;
4186                 }
4187               case kCm_de_flag:
4188                 {
4189                   if (check_float(linetoken3))
4190                     token3 >> token_value;
4191                   else
4192                     uiuc_warnings_errors(1, *command_line);
4193
4194                   kCm_de = token_value;
4195                   break;
4196                 }
4197               case kCm_b2_flag:
4198                 {
4199                   if (check_float(linetoken3))
4200                     token3 >> token_value;
4201                   else
4202                     uiuc_warnings_errors(1, *command_line);
4203
4204                   kCm_b2 = token_value;
4205                   break;
4206                 }
4207               case kCm_r_flag:
4208                 {
4209                   if (check_float(linetoken3))
4210                     token3 >> token_value;
4211                   else
4212                     uiuc_warnings_errors(1, *command_line);
4213
4214                   kCm_r = token_value;
4215                   break;
4216                 }
4217               case kCm_df_flag:
4218                 {
4219                   if (check_float(linetoken3))
4220                     token3 >> token_value;
4221                   else
4222                     uiuc_warnings_errors(1, *command_line);
4223
4224                   kCm_df = token_value;
4225                   break;
4226                 }
4227               case kCYo_flag:
4228                 {
4229                   if (check_float(linetoken3))
4230                     token3 >> token_value;
4231                   else
4232                     uiuc_warnings_errors(1, *command_line);
4233
4234                   kCYo = token_value;
4235                   break;
4236                 }
4237               case kCY_beta_flag:
4238                 {
4239                   if (check_float(linetoken3))
4240                     token3 >> token_value;
4241                   else
4242                     uiuc_warnings_errors(1, *command_line);
4243
4244                   kCY_beta = token_value;
4245                   break;
4246                 }
4247               case kCY_p_flag:
4248                 {
4249                   if (check_float(linetoken3))
4250                     token3 >> token_value;
4251                   else
4252                     uiuc_warnings_errors(1, *command_line);
4253
4254                   kCY_p = token_value;
4255                   break;
4256                 }
4257               case kCY_r_flag:
4258                 {
4259                   if (check_float(linetoken3))
4260                     token3 >> token_value;
4261                   else
4262                     uiuc_warnings_errors(1, *command_line);
4263
4264                   kCY_r = token_value;
4265                   break;
4266                 }
4267               case kCY_da_flag:
4268                 {
4269                   if (check_float(linetoken3))
4270                     token3 >> token_value;
4271                   else
4272                     uiuc_warnings_errors(1, *command_line);
4273
4274                   kCY_da = token_value;
4275                   break;
4276                 }
4277               case kCY_dr_flag:
4278                 {
4279                   if (check_float(linetoken3))
4280                     token3 >> token_value;
4281                   else
4282                     uiuc_warnings_errors(1, *command_line);
4283
4284                   kCY_dr = token_value;
4285                   break;
4286                 }
4287               case kCY_dra_flag:
4288                 {
4289                   if (check_float(linetoken3))
4290                     token3 >> token_value;
4291                   else
4292                     uiuc_warnings_errors(1, *command_line);
4293
4294                   kCY_dra = token_value;
4295                   break;
4296                 }
4297               case kCY_bdot_flag:
4298                 {
4299                   if (check_float(linetoken3))
4300                     token3 >> token_value;
4301                   else
4302                     uiuc_warnings_errors(1, *command_line);
4303
4304                   kCY_bdot = token_value;
4305                   break;
4306                 }
4307               case kClo_flag:
4308                 {
4309                   if (check_float(linetoken3))
4310                     token3 >> token_value;
4311                   else
4312                     uiuc_warnings_errors(1, *command_line);
4313
4314                   kClo = token_value;
4315                   break;
4316                 }
4317               case kCl_beta_flag:
4318                 {
4319                   if (check_float(linetoken3))
4320                     token3 >> token_value;
4321                   else
4322                     uiuc_warnings_errors(1, *command_line);
4323
4324                   kCl_beta = token_value;
4325                   break;
4326                 }
4327               case kCl_p_flag:
4328                 {
4329                   if (check_float(linetoken3))
4330                     token3 >> token_value;
4331                   else
4332                     uiuc_warnings_errors(1, *command_line);
4333
4334                   kCl_p = token_value;
4335                   break;
4336                 }
4337               case kCl_r_flag:
4338                 {
4339                   if (check_float(linetoken3))
4340                     token3 >> token_value;
4341                   else
4342                     uiuc_warnings_errors(1, *command_line);
4343
4344                   kCl_r = token_value;
4345                   break;
4346                 }
4347               case kCl_da_flag:
4348                 {
4349                   if (check_float(linetoken3))
4350                     token3 >> token_value;
4351                   else
4352                     uiuc_warnings_errors(1, *command_line);
4353
4354                   kCl_da = token_value;
4355                   break;
4356                 }
4357               case kCl_dr_flag:
4358                 {
4359                   if (check_float(linetoken3))
4360                     token3 >> token_value;
4361                   else
4362                     uiuc_warnings_errors(1, *command_line);
4363
4364                   kCl_dr = token_value;
4365                   break;
4366                 }
4367               case kCl_daa_flag:
4368                 {
4369                   if (check_float(linetoken3))
4370                     token3 >> token_value;
4371                   else
4372                     uiuc_warnings_errors(1, *command_line);
4373
4374                   kCl_daa = token_value;
4375                   break;
4376                 }
4377               case kCno_flag:
4378                 {
4379                   if (check_float(linetoken3))
4380                     token3 >> token_value;
4381                   else
4382                     uiuc_warnings_errors(1, *command_line);
4383
4384                   kCno = token_value;
4385                   break;
4386                 }
4387               case kCn_beta_flag:
4388                 {
4389                   if (check_float(linetoken3))
4390                     token3 >> token_value;
4391                   else
4392                     uiuc_warnings_errors(1, *command_line);
4393
4394                   kCn_beta = token_value;
4395                   break;
4396                 }
4397               case kCn_p_flag:
4398                 {
4399                   if (check_float(linetoken3))
4400                     token3 >> token_value;
4401                   else
4402                     uiuc_warnings_errors(1, *command_line);
4403
4404                   kCn_p = token_value;
4405                   break;
4406                 }
4407               case kCn_r_flag:
4408                 {
4409                   if (check_float(linetoken3))
4410                     token3 >> token_value;
4411                   else
4412                     uiuc_warnings_errors(1, *command_line);
4413
4414                   kCn_r = token_value;
4415                   break;
4416                 }
4417               case kCn_da_flag:
4418                 {
4419                   if (check_float(linetoken3))
4420                     token3 >> token_value;
4421                   else
4422                     uiuc_warnings_errors(1, *command_line);
4423
4424                   kCn_da = token_value;
4425                   break;
4426                 }
4427               case kCn_dr_flag:
4428                 {
4429                   if (check_float(linetoken3))
4430                     token3 >> token_value;
4431                   else
4432                     uiuc_warnings_errors(1, *command_line);
4433
4434                   kCn_dr = token_value;
4435                   break;
4436                 }
4437               case kCn_q_flag:
4438                 {
4439                   if (check_float(linetoken3))
4440                     token3 >> token_value;
4441                   else
4442                     uiuc_warnings_errors(1, *command_line);
4443
4444                   kCn_q = token_value;
4445                   break;
4446                 }
4447               case kCn_b3_flag:
4448                 {
4449                   if (check_float(linetoken3))
4450                     token3 >> token_value;
4451                   else
4452                     uiuc_warnings_errors(1, *command_line);
4453
4454                   kCn_b3 = token_value;
4455                   break;
4456                 }
4457               default:
4458                 {
4459                   uiuc_warnings_errors(2, *command_line);
4460                   break;
4461                 }
4462               };
4463             break;
4464           } // end ice map
4465
4466
4467         case fog_flag:
4468           {
4469             switch(fog_map[linetoken2])
4470               {
4471               case fog_segments_flag:
4472                 {
4473                   if (check_float(linetoken3))
4474                     token3 >> token_value_convert1;
4475                   else
4476                     uiuc_warnings_errors(1, *command_line);
4477
4478                   if (token_value_convert1 < 1 || token_value_convert1 > 100)
4479                     uiuc_warnings_errors(1, *command_line);
4480
4481                   fog_field = true;
4482                   fog_point_index = 0;
4483                   delete[] fog_time;
4484                   delete[] fog_value;
4485                   fog_segments = token_value_convert1;
4486                   fog_time = new double[fog_segments+1];
4487                   fog_time[0] = 0.0;
4488                   fog_value = new int[fog_segments+1];
4489                   fog_value[0] = 0;
4490
4491                   break;
4492                 }
4493               case fog_point_flag:
4494                 {
4495                   if (check_float(linetoken3))
4496                     token3 >> token_value;
4497                   else
4498                     uiuc_warnings_errors(1, *command_line);
4499
4500                   if (token_value < 0.1)
4501                     uiuc_warnings_errors(1, *command_line);
4502
4503                   if (check_float(linetoken4))
4504                     token4 >> token_value_convert1;
4505                   else
4506                     uiuc_warnings_errors(1, *command_line);
4507
4508                   if (token_value_convert1 < -1000 || token_value_convert1 > 1000)
4509                     uiuc_warnings_errors(1, *command_line);
4510
4511                   if (fog_point_index == fog_segments || fog_point_index == -1)
4512                     uiuc_warnings_errors(1, *command_line);
4513
4514                   fog_point_index++;
4515                   fog_time[fog_point_index] = token_value;
4516                   fog_value[fog_point_index] = token_value_convert1;
4517
4518                   break;
4519                 }
4520               default:
4521                 {
4522                   uiuc_warnings_errors(2, *command_line);
4523                   break;
4524                 }
4525               };
4526             break;
4527           } // end fog map
4528
4529
4530
4531
4532
4533
4534         case record_flag:
4535           {
4536             static int fout_flag=0;
4537             if (fout_flag==0)
4538             {
4539               fout_flag=-1;
4540               fout.open("uiuc_record.dat");
4541             }
4542             switch(record_map[linetoken2])
4543               {
4544                 /************************* Time ************************/
4545               case Simtime_record:
4546                 {
4547                   recordParts -> storeCommands (*command_line);
4548                   break;
4549                 }
4550               case dt_record:
4551                 {
4552                   recordParts -> storeCommands (*command_line);
4553                   break;
4554                 }
4555
4556                 /************************* Mass ************************/
4557               case Weight_record:
4558                 {
4559                   recordParts -> storeCommands (*command_line);
4560                   break;
4561                 }
4562               case Mass_record:
4563                 {
4564                   recordParts -> storeCommands (*command_line);
4565                   break;
4566                 }
4567               case I_xx_record:
4568                 {
4569                   recordParts -> storeCommands (*command_line);
4570                   break;
4571                 }
4572               case I_yy_record:
4573                 {
4574                   recordParts -> storeCommands (*command_line);
4575                   break;
4576                 }
4577               case I_zz_record:
4578                 {
4579                   recordParts -> storeCommands (*command_line);
4580                   break;
4581                 }
4582               case I_xz_record:
4583                 {
4584                   recordParts -> storeCommands (*command_line);
4585                   break;
4586                 }
4587
4588                 /*********************** Geometry **********************/
4589               case Dx_pilot_record:
4590                 {
4591                   recordParts -> storeCommands (*command_line);
4592                   break;
4593                 }
4594               case Dy_pilot_record:
4595                 {
4596                   recordParts -> storeCommands (*command_line);
4597                   break;
4598                 }
4599               case Dz_pilot_record:
4600                 {
4601                   recordParts -> storeCommands (*command_line);
4602                   break;
4603                 }
4604               case Dx_cg_record:
4605                 {
4606                   recordParts -> storeCommands (*command_line);
4607                   break;
4608                 }
4609               case Dy_cg_record:
4610                 {
4611                   recordParts -> storeCommands (*command_line);
4612                   break;
4613                 }
4614               case Dz_cg_record:
4615                 {
4616                   recordParts -> storeCommands (*command_line);
4617                   break;
4618                 }
4619
4620                 /********************** Positions **********************/
4621               case Lat_geocentric_record:
4622                 {
4623                   recordParts -> storeCommands (*command_line);
4624                   break;
4625                 }
4626               case Lon_geocentric_record:
4627                 {
4628                   recordParts -> storeCommands (*command_line);
4629                   break;
4630                 }
4631               case Radius_to_vehicle_record:
4632                 {
4633                   recordParts -> storeCommands (*command_line);
4634                   break;
4635                 }
4636               case Latitude_record:
4637                 {
4638                   recordParts -> storeCommands (*command_line);
4639                   break;
4640                 }
4641               case Longitude_record:
4642                 {
4643                   recordParts -> storeCommands (*command_line);
4644                   break;
4645                 }
4646               case Altitude_record:
4647                 {
4648                   recordParts -> storeCommands (*command_line);
4649                   break;
4650                 }
4651               case Phi_record:
4652                 {
4653                   recordParts -> storeCommands (*command_line);
4654                   break;
4655                 }
4656               case Theta_record:
4657                 {
4658                   recordParts -> storeCommands (*command_line);
4659                   break;
4660                 }
4661               case Psi_record:
4662                 {
4663                   recordParts -> storeCommands (*command_line);
4664                   break;
4665                 }
4666
4667                 /******************** Accelerations ********************/
4668               case V_dot_north_record:
4669                 {
4670                   recordParts -> storeCommands (*command_line);
4671                   break;
4672                 }
4673               case V_dot_east_record:
4674                 {
4675                   recordParts -> storeCommands (*command_line);
4676                   break;
4677                 }
4678               case V_dot_down_record:
4679                 {
4680                   recordParts -> storeCommands (*command_line);
4681                   break;
4682                 }
4683               case U_dot_body_record:
4684                 {
4685                   recordParts -> storeCommands (*command_line);
4686                   break;
4687                 }
4688               case V_dot_body_record:
4689                 {
4690                   recordParts -> storeCommands (*command_line);
4691                   break;
4692                 }
4693               case W_dot_body_record:
4694                 {
4695                   recordParts -> storeCommands (*command_line);
4696                   break;
4697                 }
4698               case A_X_pilot_record:
4699                 {
4700                   recordParts -> storeCommands (*command_line);
4701                   break;
4702                 }
4703               case A_Y_pilot_record:
4704                 {
4705                   recordParts -> storeCommands (*command_line);
4706                   break;
4707                 }
4708               case A_Z_pilot_record:
4709                 {
4710                   recordParts -> storeCommands (*command_line);
4711                   break;
4712                 }
4713               case A_X_cg_record:
4714                 {
4715                   recordParts -> storeCommands (*command_line);
4716                   break;
4717                 }
4718               case A_Y_cg_record:
4719                 {
4720                   recordParts -> storeCommands (*command_line);
4721                   break;
4722                 }
4723               case A_Z_cg_record:
4724                 {
4725                   recordParts -> storeCommands (*command_line);
4726                   break;
4727                 }
4728               case N_X_pilot_record:
4729                 {
4730                   recordParts -> storeCommands (*command_line);
4731                   break;
4732                 }
4733               case N_Y_pilot_record:
4734                 {
4735                   recordParts -> storeCommands (*command_line);
4736                   break;
4737                 }
4738               case N_Z_pilot_record:
4739                 {
4740                   recordParts -> storeCommands (*command_line);
4741                   break;
4742                 }
4743               case N_X_cg_record:
4744                 {
4745                   recordParts -> storeCommands (*command_line);
4746                   break;
4747                 }
4748               case N_Y_cg_record:
4749                 {
4750                   recordParts -> storeCommands (*command_line);
4751                   break;
4752                 }
4753               case N_Z_cg_record:
4754                 {
4755                   recordParts -> storeCommands (*command_line);
4756                   break;
4757                 }
4758               case P_dot_body_record:
4759                 {
4760                   recordParts -> storeCommands (*command_line);
4761                   break;
4762                 }
4763               case Q_dot_body_record:
4764                 {
4765                   recordParts -> storeCommands (*command_line);
4766                   break;
4767                 }
4768               case R_dot_body_record:
4769                 {
4770                   recordParts -> storeCommands (*command_line);
4771                   break;
4772                 }
4773
4774                 /********************** Velocities *********************/
4775               case V_north_record:
4776                 {
4777                   recordParts -> storeCommands (*command_line);
4778                   break;
4779                 }
4780               case V_east_record:
4781                 {
4782                   recordParts -> storeCommands (*command_line);
4783                   break;
4784                 }
4785               case V_down_record:
4786                 {
4787                   recordParts -> storeCommands (*command_line);
4788                   break;
4789                 }
4790               case V_north_rel_ground_record:
4791                 {
4792                   recordParts -> storeCommands (*command_line);
4793                   break;
4794                 }
4795               case V_east_rel_ground_record:
4796                 {
4797                   recordParts -> storeCommands (*command_line);
4798                   break;
4799                 }
4800               case V_down_rel_ground_record:
4801                 {
4802                   recordParts -> storeCommands (*command_line);
4803                   break;
4804                 }
4805               case V_north_airmass_record:
4806                 {
4807                   recordParts -> storeCommands (*command_line);
4808                   break;
4809                 }
4810               case V_east_airmass_record:
4811                 {
4812                   recordParts -> storeCommands (*command_line);
4813                   break;
4814                 }
4815               case V_down_airmass_record:
4816                 {
4817                   recordParts -> storeCommands (*command_line);
4818                   break;
4819                 }
4820               case V_north_rel_airmass_record:
4821                 {
4822                   recordParts -> storeCommands (*command_line);
4823                   break;
4824                 }
4825               case V_east_rel_airmass_record:
4826                 {
4827                   recordParts -> storeCommands (*command_line);
4828                   break;
4829                 }
4830               case V_down_rel_airmass_record:
4831                 {
4832                   recordParts -> storeCommands (*command_line);
4833                   break;
4834                 }
4835               case U_gust_record:
4836                 {
4837                   recordParts -> storeCommands (*command_line);
4838                   break;
4839                 }
4840               case V_gust_record:
4841                 {
4842                   recordParts -> storeCommands (*command_line);
4843                   break;
4844                 }
4845               case W_gust_record:
4846                 {
4847                   recordParts -> storeCommands (*command_line);
4848                   break;
4849                 }
4850               case U_body_record:
4851                 {
4852                   recordParts -> storeCommands (*command_line);
4853                   break;
4854                 }
4855               case V_body_record:
4856                 {
4857                   recordParts -> storeCommands (*command_line);
4858                   break;
4859                 }
4860               case W_body_record:
4861                 {
4862                   recordParts -> storeCommands (*command_line);
4863                   break;
4864                 }
4865               case V_rel_wind_record:
4866                 {
4867                   recordParts -> storeCommands (*command_line);
4868                   break;
4869                 }
4870               case V_true_kts_record:
4871                 {
4872                   recordParts -> storeCommands (*command_line);
4873                   break;
4874                 }
4875               case V_rel_ground_record:
4876                 {
4877                   recordParts -> storeCommands (*command_line);
4878                   break;
4879                 }
4880               case V_inertial_record:
4881                 {
4882                   recordParts -> storeCommands (*command_line);
4883                   break;
4884                 }
4885               case V_ground_speed_record:
4886                 {
4887                   recordParts -> storeCommands (*command_line);
4888                   break;
4889                 }
4890               case V_equiv_record:
4891                 {
4892                   recordParts -> storeCommands (*command_line);
4893                   break;
4894                 }
4895               case V_equiv_kts_record:
4896                 {
4897                   recordParts -> storeCommands (*command_line);
4898                   break;
4899                 }
4900               case V_calibrated_record:
4901                 {
4902                   recordParts -> storeCommands (*command_line);
4903                   break;
4904                 }
4905               case V_calibrated_kts_record:
4906                 {
4907                   recordParts -> storeCommands (*command_line);
4908                   break;
4909                 }
4910               case P_local_record:
4911                 {
4912                   recordParts -> storeCommands (*command_line);
4913                   break;
4914                 }
4915               case Q_local_record:
4916                 {
4917                   recordParts -> storeCommands (*command_line);
4918                   break;
4919                 }
4920               case R_local_record:
4921                 {
4922                   recordParts -> storeCommands (*command_line);
4923                   break;
4924                 }
4925               case P_body_record:
4926                 {
4927                   recordParts -> storeCommands (*command_line);
4928                   break;
4929                 }
4930               case Q_body_record:
4931                 {
4932                   recordParts -> storeCommands (*command_line);
4933                   break;
4934                 }
4935               case R_body_record:
4936                 {
4937                   recordParts -> storeCommands (*command_line);
4938                   break;
4939                 }
4940               case P_total_record:
4941                 {
4942                   recordParts -> storeCommands (*command_line);
4943                   break;
4944                 }
4945               case Q_total_record:
4946                 {
4947                   recordParts -> storeCommands (*command_line);
4948                   break;
4949                 }
4950               case R_total_record:
4951                 {
4952                   recordParts -> storeCommands (*command_line);
4953                   break;
4954                 }
4955               case Phi_dot_record:
4956                 {
4957                   recordParts -> storeCommands (*command_line);
4958                   break;
4959                 }
4960               case Theta_dot_record:
4961                 {
4962                   recordParts -> storeCommands (*command_line);
4963                   break;
4964                 }
4965               case Psi_dot_record:
4966                 {
4967                   recordParts -> storeCommands (*command_line);
4968                   break;
4969                 }
4970               case Latitude_dot_record:
4971                 {
4972                   recordParts -> storeCommands (*command_line);
4973                   break;
4974                 }
4975               case Longitude_dot_record:
4976                 {
4977                   recordParts -> storeCommands (*command_line);
4978                   break;
4979                 }
4980               case Radius_dot_record:
4981                 {
4982                   recordParts -> storeCommands (*command_line);
4983                   break;
4984                 }
4985
4986                 /************************ Angles ***********************/
4987               case Alpha_record:
4988                 {
4989                   recordParts -> storeCommands (*command_line);
4990                   break;
4991                 }
4992               case Alpha_deg_record:
4993                 {
4994                   recordParts -> storeCommands (*command_line);
4995                   break;
4996                 }
4997               case Alpha_dot_record:
4998                 {
4999                   recordParts -> storeCommands (*command_line);
5000                   break;
5001                 }
5002               case Alpha_dot_deg_record:
5003                 {
5004                   recordParts -> storeCommands (*command_line);
5005                   break;
5006                 }
5007               case Beta_record:
5008                 {
5009                   recordParts -> storeCommands (*command_line);
5010                   break;
5011                 }
5012               case Beta_deg_record:
5013                 {
5014                   recordParts -> storeCommands (*command_line);
5015                   break;
5016                 }
5017               case Beta_dot_record:
5018                 {
5019                   recordParts -> storeCommands (*command_line);
5020                   break;
5021                 }
5022               case Beta_dot_deg_record:
5023                 {
5024                   recordParts -> storeCommands (*command_line);
5025                   break;
5026                 }
5027               case Gamma_vert_record:
5028                 {
5029                   recordParts -> storeCommands (*command_line);
5030                   break;
5031                 }
5032               case Gamma_vert_deg_record:
5033                 {
5034                   recordParts -> storeCommands (*command_line);
5035                   break;
5036                 }
5037               case Gamma_horiz_record:
5038                 {
5039                   recordParts -> storeCommands (*command_line);
5040                   break;
5041                 }
5042               case Gamma_horiz_deg_record:
5043                 {
5044                   recordParts -> storeCommands (*command_line);
5045                   break;
5046                 }
5047
5048                 /**************** Atmospheric Properties ***************/
5049               case Density_record:
5050                 {
5051                   recordParts -> storeCommands (*command_line);
5052                   break;
5053                 }
5054               case V_sound_record:
5055                 {
5056                   recordParts -> storeCommands (*command_line);
5057                   break;
5058                 }
5059               case Mach_number_record:
5060                 {
5061                   recordParts -> storeCommands (*command_line);
5062                   break;
5063                 }
5064               case Static_pressure_record:
5065                 {
5066                   recordParts -> storeCommands (*command_line);
5067                   break;
5068                 }
5069               case Total_pressure_record:
5070                 {
5071                   recordParts -> storeCommands (*command_line);
5072                   break;
5073                 }
5074               case Impact_pressure_record:
5075                 {
5076                   recordParts -> storeCommands (*command_line);
5077                   break;
5078                 }
5079               case Dynamic_pressure_record:
5080                 {
5081                   recordParts -> storeCommands (*command_line);
5082                   break;
5083                 }
5084               case Static_temperature_record:
5085                 {
5086                   recordParts -> storeCommands (*command_line);
5087                   break;
5088                 }
5089               case Total_temperature_record:
5090                 {
5091                   recordParts -> storeCommands (*command_line);
5092                   break;
5093                 }
5094
5095                 /******************** Earth Properties *****************/
5096               case Gravity_record:
5097                 {
5098                   recordParts -> storeCommands (*command_line);
5099                   break;
5100                 }
5101               case Sea_level_radius_record:
5102                 {
5103                   recordParts -> storeCommands (*command_line);
5104                   break;
5105                 }
5106               case Earth_position_angle_record:
5107                 {
5108                   recordParts -> storeCommands (*command_line);
5109                   break;
5110                 }
5111               case Runway_altitude_record:
5112                 {
5113                   recordParts -> storeCommands (*command_line);
5114                   break;
5115                 }
5116               case Runway_latitude_record:
5117                 {
5118                   recordParts -> storeCommands (*command_line);
5119                   break;
5120                 }
5121               case Runway_longitude_record:
5122                 {
5123                   recordParts -> storeCommands (*command_line);
5124                   break;
5125                 }
5126               case Runway_heading_record:
5127                 {
5128                   recordParts -> storeCommands (*command_line);
5129                   break;
5130                 }
5131               case Radius_to_rwy_record:
5132                 {
5133                   recordParts -> storeCommands (*command_line);
5134                   break;
5135                 }
5136               case D_pilot_north_of_rwy_record:
5137                 {
5138                   recordParts -> storeCommands (*command_line);
5139                   break;
5140                 }
5141               case D_pilot_east_of_rwy_record:
5142                 {
5143                   recordParts -> storeCommands (*command_line);
5144                   break;
5145                 }
5146               case D_pilot_above_rwy_record:
5147                 {
5148                   recordParts -> storeCommands (*command_line);
5149                   break;
5150                 }
5151               case X_pilot_rwy_record:
5152                 {
5153                   recordParts -> storeCommands (*command_line);
5154                   break;
5155                 }
5156               case Y_pilot_rwy_record:
5157                 {
5158                   recordParts -> storeCommands (*command_line);
5159                   break;
5160                 }
5161               case H_pilot_rwy_record:
5162                 {
5163                   recordParts -> storeCommands (*command_line);
5164                   break;
5165                 }
5166               case D_cg_north_of_rwy_record:
5167                 {
5168                   recordParts -> storeCommands (*command_line);
5169                   break;
5170                 }
5171               case D_cg_east_of_rwy_record:
5172                 {
5173                   recordParts -> storeCommands (*command_line);
5174                   break;
5175                 }
5176               case D_cg_above_rwy_record:
5177                 {
5178                   recordParts -> storeCommands (*command_line);
5179                   break;
5180                 }
5181               case X_cg_rwy_record:
5182                 {
5183                   recordParts -> storeCommands (*command_line);
5184                   break;
5185                 }
5186               case Y_cg_rwy_record:
5187                 {
5188                   recordParts -> storeCommands (*command_line);
5189                   break;
5190                 }
5191               case H_cg_rwy_record:
5192                 {
5193                   recordParts -> storeCommands (*command_line);
5194                   break;
5195                 }
5196
5197                 /********************* Engine Inputs *******************/
5198               case Throttle_pct_record:
5199                 {
5200                   recordParts -> storeCommands (*command_line);
5201                   break;
5202                 }
5203               case Throttle_3_record:
5204                 {
5205                   recordParts -> storeCommands (*command_line);
5206                   break;
5207                 }
5208
5209                 /******************** Control Inputs *******************/
5210               case Long_control_record:
5211                 {
5212                   recordParts -> storeCommands (*command_line);
5213                   break;
5214                 }
5215               case Long_trim_record:
5216                 {
5217                   recordParts -> storeCommands (*command_line);
5218                   break;
5219                 }
5220               case Long_trim_deg_record:
5221                 {
5222                   recordParts -> storeCommands (*command_line);
5223                   break;
5224                 }
5225               case elevator_record:
5226                 {
5227                   recordParts -> storeCommands (*command_line);
5228                   break;
5229                 }
5230               case elevator_deg_record:
5231                 {
5232                   recordParts -> storeCommands (*command_line);
5233                   break;
5234                 }
5235               case Lat_control_record:
5236                 {
5237                   recordParts -> storeCommands (*command_line);
5238                   break;
5239                 }
5240               case aileron_record:
5241                 {
5242                   recordParts -> storeCommands (*command_line);
5243                   break;
5244                 }
5245               case aileron_deg_record:
5246                 {
5247                   recordParts -> storeCommands (*command_line);
5248                   break;
5249                 }
5250               case Rudder_pedal_record:
5251                 {
5252                   recordParts -> storeCommands (*command_line);
5253                   break;
5254                 }
5255               case rudder_record:
5256                 {
5257                   recordParts -> storeCommands (*command_line);
5258                   break;
5259                 }
5260               case rudder_deg_record:
5261                 {
5262                   recordParts -> storeCommands (*command_line);
5263                   break;
5264                 }
5265               case Flap_handle_record:
5266                 {
5267                   recordParts -> storeCommands (*command_line);
5268                   break;
5269                 }
5270               case flap_record:
5271                 {
5272                   recordParts -> storeCommands (*command_line);
5273                   break;
5274                 }
5275               case flap_deg_record:
5276                 {
5277                   recordParts -> storeCommands (*command_line);
5278                   break;
5279                 }
5280               case flap_goal_record:
5281                 {
5282                   recordParts -> storeCommands (*command_line);
5283                   break;
5284                 }
5285               case flap_pos_record:
5286                 {
5287                   recordParts -> storeCommands (*command_line);
5288                   break;
5289                 }
5290
5291                 /****************** Aero Coefficients ******************/
5292               case CD_record:
5293                 {
5294                   recordParts -> storeCommands (*command_line);
5295                   break;
5296                 }
5297               case CDfaI_record:
5298                 {
5299                   recordParts -> storeCommands (*command_line);
5300                   break;
5301                 }
5302               case CDfadeI_record:
5303                 {
5304                   recordParts -> storeCommands (*command_line);
5305                   break;
5306                 }
5307               case CDfdfI_record:
5308                 {
5309                   recordParts -> storeCommands (*command_line);
5310                   break;
5311                 }
5312               case CDfadfI_record:
5313                 {
5314                   recordParts -> storeCommands (*command_line);
5315                   break;
5316                 }
5317               case CX_record:
5318                 {
5319                   recordParts -> storeCommands (*command_line);
5320                   break;
5321                 }
5322               case CXfabetafI_record:
5323                 {
5324                   recordParts -> storeCommands (*command_line);
5325                   break;
5326                 }
5327               case CXfadefI_record:
5328                 {
5329                   recordParts -> storeCommands (*command_line);
5330                   break;
5331                 }
5332               case CXfaqfI_record:
5333                 {
5334                   recordParts -> storeCommands (*command_line);
5335                   break;
5336                 }
5337               case CDo_save_record:
5338                 {
5339                   recordParts -> storeCommands (*command_line);
5340                   break;
5341                 }
5342               case CDK_save_record:
5343                 {
5344                   recordParts -> storeCommands (*command_line);
5345                   break;
5346                 }
5347               case CD_a_save_record:
5348                 {
5349                   recordParts -> storeCommands (*command_line);
5350                   break;
5351                 }
5352               case CD_adot_save_record:
5353                 {
5354                   recordParts -> storeCommands (*command_line);
5355                   break;
5356                 }
5357               case CD_q_save_record:
5358                 {
5359                   recordParts -> storeCommands (*command_line);
5360                   break;
5361                 }
5362               case CD_ih_save_record:
5363                 {
5364                   recordParts -> storeCommands (*command_line);
5365                   break;
5366                 }
5367               case CD_de_save_record:
5368                 {
5369                   recordParts -> storeCommands (*command_line);
5370                   break;
5371                 }
5372               case CXo_save_record:
5373                 {
5374                   recordParts -> storeCommands (*command_line);
5375                   break;
5376                 }
5377               case CXK_save_record:
5378                 {
5379                   recordParts -> storeCommands (*command_line);
5380                   break;
5381                 }
5382               case CX_a_save_record:
5383                 {
5384                   recordParts -> storeCommands (*command_line);
5385                   break;
5386                 }
5387               case CX_a2_save_record:
5388                 {
5389                   recordParts -> storeCommands (*command_line);
5390                   break;
5391                 }
5392               case CX_a3_save_record:
5393                 {
5394                   recordParts -> storeCommands (*command_line);
5395                   break;
5396                 }
5397               case CX_adot_save_record:
5398                 {
5399                   recordParts -> storeCommands (*command_line);
5400                   break;
5401                 }
5402               case CX_q_save_record:
5403                 {
5404                   recordParts -> storeCommands (*command_line);
5405                   break;
5406                 }
5407               case CX_de_save_record:
5408                 {
5409                   recordParts -> storeCommands (*command_line);
5410                   break;
5411                 }
5412               case CX_dr_save_record:
5413                 {
5414                   recordParts -> storeCommands (*command_line);
5415                   break;
5416                 }
5417               case CX_df_save_record:
5418                 {
5419                   recordParts -> storeCommands (*command_line);
5420                   break;
5421                 }
5422               case CX_adf_save_record:
5423                 {
5424                   recordParts -> storeCommands (*command_line);
5425                   break;
5426                 }
5427               case CL_record:
5428                 {
5429                   recordParts -> storeCommands (*command_line);
5430                   break;
5431                 }
5432               case CLfaI_record:
5433                 {
5434                   recordParts -> storeCommands (*command_line);
5435                   break;
5436                 }
5437               case CLfadeI_record:
5438                 {
5439                   recordParts -> storeCommands (*command_line);
5440                   break;
5441                 }
5442               case CLfdfI_record:
5443                 {
5444                   recordParts -> storeCommands (*command_line);
5445                   break;
5446                 }
5447               case CLfadfI_record:
5448                 {
5449                   recordParts -> storeCommands (*command_line);
5450                   break;
5451                 }
5452               case CZ_record:
5453                 {
5454                   recordParts -> storeCommands (*command_line);
5455                   break;
5456                 }
5457               case CZfaI_record:
5458                 {
5459                   recordParts -> storeCommands (*command_line);
5460                   break;
5461                 }
5462               case CZfabetafI_record:
5463                 {
5464                   recordParts -> storeCommands (*command_line);
5465                   break;
5466                 }
5467               case CZfadefI_record:
5468                 {
5469                   recordParts -> storeCommands (*command_line);
5470                   break;
5471                 }
5472               case CZfaqfI_record:
5473                 {
5474                   recordParts -> storeCommands (*command_line);
5475                   break;
5476                 }
5477               case CLo_save_record:
5478                 {
5479                   recordParts -> storeCommands (*command_line);
5480                   break;
5481                 }
5482               case CL_a_save_record:
5483                 {
5484                   recordParts -> storeCommands (*command_line);
5485                   break;
5486                 }
5487               case CL_adot_save_record:
5488                 {
5489                   recordParts -> storeCommands (*command_line);
5490                   break;
5491                 }
5492               case CL_q_save_record:
5493                 {
5494                   recordParts -> storeCommands (*command_line);
5495                   break;
5496                 }
5497               case CL_ih_save_record:
5498                 {
5499                   recordParts -> storeCommands (*command_line);
5500                   break;
5501                 }
5502               case CL_de_save_record:
5503                 {
5504                   recordParts -> storeCommands (*command_line);
5505                   break;
5506                 }
5507               case CZo_save_record:
5508                 {
5509                   recordParts -> storeCommands (*command_line);
5510                   break;
5511                 }
5512               case CZ_a_save_record:
5513                 {
5514                   recordParts -> storeCommands (*command_line);
5515                   break;
5516                 }
5517               case CZ_a2_save_record:
5518                 {
5519                   recordParts -> storeCommands (*command_line);
5520                   break;
5521                 }
5522               case CZ_a3_save_record:
5523                 {
5524                   recordParts -> storeCommands (*command_line);
5525                   break;
5526                 }
5527               case CZ_adot_save_record:
5528                 {
5529                   recordParts -> storeCommands (*command_line);
5530                   break;
5531                 }
5532               case CZ_q_save_record:
5533                 {
5534                   recordParts -> storeCommands (*command_line);
5535                   break;
5536                 }
5537               case CZ_de_save_record:
5538                 {
5539                   recordParts -> storeCommands (*command_line);
5540                   break;
5541                 }
5542               case CZ_deb2_save_record:
5543                 {
5544                   recordParts -> storeCommands (*command_line);
5545                   break;
5546                 }
5547               case CZ_df_save_record:
5548                 {
5549                   recordParts -> storeCommands (*command_line);
5550                   break;
5551                 }
5552               case CZ_adf_save_record:
5553                 {
5554                   recordParts -> storeCommands (*command_line);
5555                   break;
5556                 }
5557               case Cm_record:
5558                 {
5559                   recordParts -> storeCommands (*command_line);
5560                   break;
5561                 }
5562               case CmfaI_record:
5563                 {
5564                   recordParts -> storeCommands (*command_line);
5565                   break;
5566                 }
5567               case CmfadeI_record:
5568                 {
5569                   recordParts -> storeCommands (*command_line);
5570                   break;
5571                 }
5572               case CmfdfI_record:
5573                 {
5574                   recordParts -> storeCommands (*command_line);
5575                   break;
5576                 }
5577               case CmfadfI_record:
5578                 {
5579                   recordParts -> storeCommands (*command_line);
5580                   break;
5581                 }
5582               case CmfabetafI_record:
5583                 {
5584                   recordParts -> storeCommands (*command_line);
5585                   break;
5586                 }
5587               case CmfadefI_record:
5588                 {
5589                   recordParts -> storeCommands (*command_line);
5590                   break;
5591                 }
5592               case CmfaqfI_record:
5593                 {
5594                   recordParts -> storeCommands (*command_line);
5595                   break;
5596                 }
5597               case Cmo_save_record:
5598                 {
5599                   recordParts -> storeCommands (*command_line);
5600                   break;
5601                 }
5602               case Cm_a_save_record:
5603                 {
5604                   recordParts -> storeCommands (*command_line);
5605                   break;
5606                 }
5607               case Cm_a2_save_record:
5608                 {
5609                   recordParts -> storeCommands (*command_line);
5610                   break;
5611                 }
5612               case Cm_adot_save_record:
5613                 {
5614                   recordParts -> storeCommands (*command_line);
5615                   break;
5616                 }
5617               case Cm_q_save_record:
5618                 {
5619                   recordParts -> storeCommands (*command_line);
5620                   break;
5621                 }
5622               case Cm_ih_save_record:
5623                 {
5624                   recordParts -> storeCommands (*command_line);
5625                   break;
5626                 }
5627               case Cm_de_save_record:
5628                 {
5629                   recordParts -> storeCommands (*command_line);
5630                   break;
5631                 }
5632               case Cm_b2_save_record:
5633                 {
5634                   recordParts -> storeCommands (*command_line);
5635                   break;
5636                 }
5637               case Cm_r_save_record:
5638                 {
5639                   recordParts -> storeCommands (*command_line);
5640                   break;
5641                 }
5642               case Cm_df_save_record:
5643                 {
5644                   recordParts -> storeCommands (*command_line);
5645                   break;
5646                 }
5647               case CY_record:
5648                 {
5649                   recordParts -> storeCommands (*command_line);
5650                   break;
5651                 }
5652               case CYfadaI_record:
5653                 {
5654                   recordParts -> storeCommands (*command_line);
5655                   break;
5656                 }
5657               case CYfbetadrI_record:
5658                 {
5659                   recordParts -> storeCommands (*command_line);
5660                   break;
5661                 }
5662               case CYfabetafI_record:
5663                 {
5664                   recordParts -> storeCommands (*command_line);
5665                   break;
5666                 }
5667               case CYfadafI_record:
5668                 {
5669                   recordParts -> storeCommands (*command_line);
5670                   break;
5671                 }
5672               case CYfadrfI_record:
5673                 {
5674                   recordParts -> storeCommands (*command_line);
5675                   break;
5676                 }
5677               case CYfapfI_record:
5678                 {
5679                   recordParts -> storeCommands (*command_line);
5680                   break;
5681                 }
5682               case CYfarfI_record:
5683                 {
5684                   recordParts -> storeCommands (*command_line);
5685                   break;
5686                 }
5687               case CYo_save_record:
5688                 {
5689                   recordParts -> storeCommands (*command_line);
5690                   break;
5691                 }
5692               case CY_beta_save_record:
5693                 {
5694                   recordParts -> storeCommands (*command_line);
5695                   break;
5696                 }
5697               case CY_p_save_record:
5698                 {
5699                   recordParts -> storeCommands (*command_line);
5700                   break;
5701                 }
5702               case CY_r_save_record:
5703                 {
5704                   recordParts -> storeCommands (*command_line);
5705                   break;
5706                 }
5707               case CY_da_save_record:
5708                 {
5709                   recordParts -> storeCommands (*command_line);
5710                   break;
5711                 }
5712               case CY_dr_save_record:
5713                 {
5714                   recordParts -> storeCommands (*command_line);
5715                   break;
5716                 }
5717               case CY_dra_save_record:
5718                 {
5719                   recordParts -> storeCommands (*command_line);
5720                   break;
5721                 }
5722               case CY_bdot_save_record:
5723                 {
5724                   recordParts -> storeCommands (*command_line);
5725                   break;
5726                 }
5727               case Cl_record:
5728                 {
5729                   recordParts -> storeCommands (*command_line);
5730                   break;
5731                 }
5732               case ClfadaI_record:
5733                 {
5734                   recordParts -> storeCommands (*command_line);
5735                   break;
5736                 }
5737               case ClfbetadrI_record:
5738                 {
5739                   recordParts -> storeCommands (*command_line);
5740                   break;
5741                 }
5742               case ClfabetafI_record:
5743                 {
5744                   recordParts -> storeCommands (*command_line);
5745                   break;
5746                 }
5747               case ClfadafI_record:
5748                 {
5749                   recordParts -> storeCommands (*command_line);
5750                   break;
5751                 }
5752               case ClfadrfI_record:
5753                 {
5754                   recordParts -> storeCommands (*command_line);
5755                   break;
5756                 }
5757               case ClfapfI_record:
5758                 {
5759                   recordParts -> storeCommands (*command_line);
5760                   break;
5761                 }
5762               case ClfarfI_record:
5763                 {
5764                   recordParts -> storeCommands (*command_line);
5765                   break;
5766                 }
5767               case Clo_save_record:
5768                 {
5769                   recordParts -> storeCommands (*command_line);
5770                   break;
5771                 }
5772               case Cl_beta_save_record:
5773                 {
5774                   recordParts -> storeCommands (*command_line);
5775                   break;
5776                 }
5777               case Cl_p_save_record:
5778                 {
5779                   recordParts -> storeCommands (*command_line);
5780                   break;
5781                 }
5782               case Cl_r_save_record:
5783                 {
5784                   recordParts -> storeCommands (*command_line);
5785                   break;
5786                 }
5787               case Cl_da_save_record:
5788                 {
5789                   recordParts -> storeCommands (*command_line);
5790                   break;
5791                 }
5792               case Cl_dr_save_record:
5793                 {
5794                   recordParts -> storeCommands (*command_line);
5795                   break;
5796                 }
5797               case Cl_daa_save_record:
5798                 {
5799                   recordParts -> storeCommands (*command_line);
5800                   break;
5801                 }
5802               case Cn_record:
5803                 {
5804                   recordParts -> storeCommands (*command_line);
5805                   break;
5806                 }
5807               case CnfadaI_record:
5808                 {
5809                   recordParts -> storeCommands (*command_line);
5810                   break;
5811                 }
5812               case CnfbetadrI_record:
5813                 {
5814                   recordParts -> storeCommands (*command_line);
5815                   break;
5816                 }
5817               case CnfabetafI_record:
5818                 {
5819                   recordParts -> storeCommands (*command_line);
5820                   break;
5821                 }
5822               case CnfadafI_record:
5823                 {
5824                   recordParts -> storeCommands (*command_line);
5825                   break;
5826                 }
5827               case CnfadrfI_record:
5828                 {
5829                   recordParts -> storeCommands (*command_line);
5830                   break;
5831                 }
5832               case CnfapfI_record:
5833                 {
5834                   recordParts -> storeCommands (*command_line);
5835                   break;
5836                 }
5837               case CnfarfI_record:
5838                 {
5839                   recordParts -> storeCommands (*command_line);
5840                   break;
5841                 }
5842               case Cno_save_record:
5843                 {
5844                   recordParts -> storeCommands (*command_line);
5845                   break;
5846                 }
5847               case Cn_beta_save_record:
5848                 {
5849                   recordParts -> storeCommands (*command_line);
5850                   break;
5851                 }
5852               case Cn_p_save_record:
5853                 {
5854                   recordParts -> storeCommands (*command_line);
5855                   break;
5856                 }
5857               case Cn_r_save_record:
5858                 {
5859                   recordParts -> storeCommands (*command_line);
5860                   break;
5861                 }
5862               case Cn_da_save_record:
5863                 {
5864                   recordParts -> storeCommands (*command_line);
5865                   break;
5866                 }
5867               case Cn_dr_save_record:
5868                 {
5869                   recordParts -> storeCommands (*command_line);
5870                   break;
5871                 }
5872               case Cn_q_save_record:
5873                 {
5874                   recordParts -> storeCommands (*command_line);
5875                   break;
5876                 }
5877               case Cn_b3_save_record:
5878                 {
5879                   recordParts -> storeCommands (*command_line);
5880                   break;
5881                 }
5882
5883                 /******************** Ice Detection ********************/
5884               case CLclean_wing_record:
5885                 {
5886                   recordParts -> storeCommands (*command_line);
5887                   break;
5888                 }
5889               case CLiced_wing_record:
5890                 {
5891                   recordParts -> storeCommands (*command_line);
5892                   break;
5893                 }
5894               case CLclean_tail_record:
5895                 {
5896                   recordParts -> storeCommands (*command_line);
5897                   break;
5898                 }
5899               case CLiced_tail_record:
5900                 {
5901                   recordParts -> storeCommands (*command_line);
5902                   break;
5903                 }
5904               case Lift_clean_wing_record:
5905                 {
5906                   recordParts -> storeCommands (*command_line);
5907                   break;
5908                 }
5909               case Lift_iced_wing_record:
5910                 {
5911                   recordParts -> storeCommands (*command_line);
5912                   break;
5913                 }
5914               case Lift_clean_tail_record:
5915                 {
5916                   recordParts -> storeCommands (*command_line);
5917                   break;
5918                 }
5919               case Lift_iced_tail_record:
5920                 {
5921                   recordParts -> storeCommands (*command_line);
5922                   break;
5923                 }
5924               case Gamma_clean_wing_record:
5925                 {
5926                   recordParts -> storeCommands (*command_line);
5927                   break;
5928                 }
5929               case Gamma_iced_wing_record:
5930                 {
5931                   recordParts -> storeCommands (*command_line);
5932                   break;
5933                 }
5934               case Gamma_clean_tail_record:
5935                 {
5936                   recordParts -> storeCommands (*command_line);
5937                   break;
5938                 }
5939               case Gamma_iced_tail_record:
5940                 {
5941                   recordParts -> storeCommands (*command_line);
5942                   break;
5943                 }
5944               case w_clean_wing_record:
5945                 {
5946                   recordParts -> storeCommands (*command_line);
5947                   break;
5948                 }
5949               case w_iced_wing_record:
5950                 {
5951                   recordParts -> storeCommands (*command_line);
5952                   break;
5953                 }
5954               case w_clean_tail_record:
5955                 {
5956                   recordParts -> storeCommands (*command_line);
5957                   break;
5958                 }
5959               case w_iced_tail_record:
5960                 {
5961                   recordParts -> storeCommands (*command_line);
5962                   break;
5963                 }
5964               case V_total_clean_wing_record:
5965                 {
5966                   recordParts -> storeCommands (*command_line);
5967                   break;
5968                 }
5969               case V_total_iced_wing_record:
5970                 {
5971                   recordParts -> storeCommands (*command_line);
5972                   break;
5973                 }
5974               case V_total_clean_tail_record:
5975                 {
5976                   recordParts -> storeCommands (*command_line);
5977                   break;
5978                 }
5979               case V_total_iced_tail_record:
5980                 {
5981                   recordParts -> storeCommands (*command_line);
5982                   break;
5983                 }
5984               case beta_flow_clean_wing_record:
5985                 {
5986                   recordParts -> storeCommands (*command_line);
5987                   break;
5988                 }
5989               case beta_flow_clean_wing_deg_record:
5990                 {
5991                   recordParts -> storeCommands (*command_line);
5992                   break;
5993                 }
5994               case beta_flow_iced_wing_record:
5995                 {
5996                   recordParts -> storeCommands (*command_line);
5997                   break;
5998                 }
5999               case beta_flow_iced_wing_deg_record:
6000                 {
6001                   recordParts -> storeCommands (*command_line);
6002                   break;
6003                 }
6004               case beta_flow_clean_tail_record:
6005                 {
6006                   recordParts -> storeCommands (*command_line);
6007                   break;
6008                 }
6009               case beta_flow_clean_tail_deg_record:
6010                 {
6011                   recordParts -> storeCommands (*command_line);
6012                   break;
6013                 }
6014               case beta_flow_iced_tail_record:
6015                 {
6016                   recordParts -> storeCommands (*command_line);
6017                   break;
6018                 }
6019               case beta_flow_iced_tail_deg_record:
6020                 {
6021                   recordParts -> storeCommands (*command_line);
6022                   break;
6023                 }
6024               case Dbeta_flow_wing_record:
6025                 {
6026                   recordParts -> storeCommands (*command_line);
6027                   break;
6028                 }
6029               case Dbeta_flow_wing_deg_record:
6030                 {
6031                   recordParts -> storeCommands (*command_line);
6032                   break;
6033                 }
6034               case Dbeta_flow_tail_record:
6035                 {
6036                   recordParts -> storeCommands (*command_line);
6037                   break;
6038                 }
6039               case Dbeta_flow_tail_deg_record:
6040                 {
6041                   recordParts -> storeCommands (*command_line);
6042                   break;
6043                 }
6044               case pct_beta_flow_wing_record:
6045                 {
6046                   recordParts -> storeCommands (*command_line);
6047                   break;
6048                 }
6049               case pct_beta_flow_tail_record:
6050                 {
6051                   recordParts -> storeCommands (*command_line);
6052                   break;
6053                 }
6054
6055                 /************************ Forces ***********************/
6056               case F_X_wind_record:
6057                 {
6058                   recordParts -> storeCommands (*command_line);
6059                   break;
6060                 }
6061               case F_Y_wind_record:
6062                 {
6063                   recordParts -> storeCommands (*command_line);
6064                   break;
6065                 }
6066               case F_Z_wind_record:
6067                 {
6068                   recordParts -> storeCommands (*command_line);
6069                   break;
6070                 }
6071               case F_X_aero_record:
6072                 {
6073                   recordParts -> storeCommands (*command_line);
6074                   break;
6075                 }
6076               case F_Y_aero_record:
6077                 {
6078                   recordParts -> storeCommands (*command_line);
6079                   break;
6080                 }
6081               case F_Z_aero_record:
6082                 {
6083                   recordParts -> storeCommands (*command_line);
6084                   break;
6085                 }
6086               case F_X_engine_record:
6087                 {
6088                   recordParts -> storeCommands (*command_line);
6089                   break;
6090                 }
6091               case F_Y_engine_record:
6092                 {
6093                   recordParts -> storeCommands (*command_line);
6094                   break;
6095                 }
6096               case F_Z_engine_record:
6097                 {
6098                   recordParts -> storeCommands (*command_line);
6099                   break;
6100                 }
6101               case F_X_gear_record:
6102                 {
6103                   recordParts -> storeCommands (*command_line);
6104                   break;
6105                 }
6106               case F_Y_gear_record:
6107                 {
6108                   recordParts -> storeCommands (*command_line);
6109                   break;
6110                 }
6111               case F_Z_gear_record:
6112                 {
6113                   recordParts -> storeCommands (*command_line);
6114                   break;
6115                 }
6116               case F_X_record:
6117                 {
6118                   recordParts -> storeCommands (*command_line);
6119                   break;
6120                 }
6121               case F_Y_record:
6122                 {
6123                   recordParts -> storeCommands (*command_line);
6124                   break;
6125                 }
6126               case F_Z_record:
6127                 {
6128                   recordParts -> storeCommands (*command_line);
6129                   break;
6130                 }
6131               case F_north_record:
6132                 {
6133                   recordParts -> storeCommands (*command_line);
6134                   break;
6135                 }
6136               case F_east_record:
6137                 {
6138                   recordParts -> storeCommands (*command_line);
6139                   break;
6140                 }
6141               case F_down_record:
6142                 {
6143                   recordParts -> storeCommands (*command_line);
6144                   break;
6145                 }
6146
6147                 /*********************** Moments ***********************/
6148               case M_l_aero_record:
6149                 {
6150                   recordParts -> storeCommands (*command_line);
6151                   break;
6152                 }
6153               case M_m_aero_record:
6154                 {
6155                   recordParts -> storeCommands (*command_line);
6156                   break;
6157                 }
6158               case M_n_aero_record:
6159                 {
6160                   recordParts -> storeCommands (*command_line);
6161                   break;
6162                 }
6163               case M_l_engine_record:
6164                 {
6165                   recordParts -> storeCommands (*command_line);
6166                   break;
6167                 }
6168               case M_m_engine_record:
6169                 {
6170                   recordParts -> storeCommands (*command_line);
6171                   break;
6172                 }
6173               case M_n_engine_record:
6174                 {
6175                   recordParts -> storeCommands (*command_line);
6176                   break;
6177                 }
6178               case M_l_gear_record:
6179                 {
6180                   recordParts -> storeCommands (*command_line);
6181                   break;
6182                 }
6183               case M_m_gear_record:
6184                 {
6185                   recordParts -> storeCommands (*command_line);
6186                   break;
6187                 }
6188               case M_n_gear_record:
6189                 {
6190                   recordParts -> storeCommands (*command_line);
6191                   break;
6192                 }
6193               case M_l_rp_record:
6194                 {
6195                   recordParts -> storeCommands (*command_line);
6196                   break;
6197                 }
6198               case M_m_rp_record:
6199                 {
6200                   recordParts -> storeCommands (*command_line);
6201                   break;
6202                 }
6203               case M_n_rp_record:
6204                 {
6205                   recordParts -> storeCommands (*command_line);
6206                   break;
6207                 }
6208               default:
6209                 {
6210                   uiuc_warnings_errors(2, *command_line);
6211                   break;
6212                 }
6213               };
6214             break;
6215           } // end record map
6216
6217
6218         case misc_flag:
6219           {
6220             switch(misc_map[linetoken2])
6221               {
6222               case simpleHingeMomentCoef_flag:
6223                 {
6224                   if (check_float(linetoken3))
6225                     token3 >> token_value;
6226                   else
6227                     uiuc_warnings_errors(1, *command_line);
6228
6229                   simpleHingeMomentCoef = token_value;
6230                   break;
6231                 }
6232               case dfTimefdf_flag:
6233                 {
6234                   dfTimefdf = linetoken3;
6235                   /* call 1D File Reader with file name (dfTimefdf);
6236                      function returns array of dfs (dfArray) and
6237                      corresponding time values (TimeArray) and max
6238                      number of terms in arrays (ndf) */
6239                   uiuc_1DdataFileReader(dfTimefdf,
6240                                         dfTimefdf_dfArray,
6241                                         dfTimefdf_TimeArray,
6242                                         dfTimefdf_ndf);
6243                   break;
6244                 }
6245               default:
6246                 {
6247                   uiuc_warnings_errors(2, *command_line);
6248                   break;
6249                 }
6250               };
6251             break;
6252           } // end misc map
6253
6254
6255         default:
6256           {
6257             if (linetoken1=="*")
6258                 return;
6259             uiuc_warnings_errors(2, *command_line);
6260             break;
6261           }
6262         };
6263     } // end keyword map
6264
6265   delete airplane;
6266 }
6267
6268 // end menu.cpp