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