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