src/FDM/UIUCModel/uiuc_menu.cpp

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