src/FDM/UIUCModel/uiuc_menu_ice.cpp

   1 /**********************************************************************
   2
   3  FILENAME:     uiuc_menu_ice.cpp
   4
   5 ----------------------------------------------------------------------
   6
   7  DESCRIPTION:  reads input data 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:      04/04/2003   initial release
  21                06/30/2003   (RD) replaced istrstream with istringstream
  22                             to get rid of the annoying warning about
  23                             using the strstream header
  24
  25 ----------------------------------------------------------------------
  26
  27  AUTHOR(S):    Robert Deters      <rdeters@uiuc.edu>
  28                Michael Selig      <m-selig@uiuc.edu>
  29
  30 ----------------------------------------------------------------------
  31
  32  VARIABLES:
  33
  34 ----------------------------------------------------------------------
  35
  36  INPUTS:       n/a
  37
  38 ----------------------------------------------------------------------
  39
  40  OUTPUTS:      n/a
  41
  42 ----------------------------------------------------------------------
  43
  44  CALLED BY:    uiuc_menu()
  45
  46 ----------------------------------------------------------------------
  47
  48  CALLS TO:     check_float() if needed
  49                d_2_to_3() if needed
  50                d_1_to_2() if needed
  51                i_1_to_2() if needed
  52                d_1_to_1() if needed
  53
  54  ----------------------------------------------------------------------
  55
  56  COPYRIGHT:    (C) 2003 by Michael Selig
  57
  58  This program is free software; you can redistribute it and/or
  59  modify it under the terms of the GNU General Public License
  60  as published by the Free Software Foundation.
  61
  62  This program is distributed in the hope that it will be useful,
  63  but WITHOUT ANY WARRANTY; without even the implied warranty of
  64  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  65  GNU General Public License for more details.
  66
  67  You should have received a copy of the GNU General Public License
  68  along with this program; if not, write to the Free Software
  69  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  70
  71 **********************************************************************/
  72
  73 #include <simgear/compiler.h>
  74
  75 #if defined( __MWERKS__ )
  76 // -dw- optimizer chokes (big-time) trying to optimize humongous
  77 // loop/switch statements
  78 #pragma optimization_level 0
  79 #endif
  80
  81 #include <cstdlib>
  82 #include <string>
  83 #include STL_IOSTREAM
  84
  85 #include "uiuc_menu_ice.h"
  86
  87 SG_USING_STD(cerr);
  88 SG_USING_STD(cout);
  89 SG_USING_STD(endl);
  90
  91 #ifndef _MSC_VER
  92 SG_USING_STD(exit);
  93 #endif
  94
  95 void parse_ice( const string& linetoken2, const string& linetoken3,
  96                 const string& linetoken4, const string& linetoken5,
  97                 const string& linetoken6, const string& linetoken7,
  98                 const string& linetoken8, const string& linetoken9,
  99                 const string& linetoken10, const string& aircraft_directory,
 100                 LIST command_line ) {
 101     double token_value;
 102     int token_value_convert1, token_value_convert2, token_value_convert3;
 103     int token_value_convert4;
 104     double datafile_xArray[100][100], datafile_yArray[100];
 105     double datafile_zArray[100][100];
 106     double convert_f;
 107     int datafile_nxArray[100], datafile_ny;
 108     istringstream token3(linetoken3.c_str());
 109     istringstream token4(linetoken4.c_str());
 110     istringstream token5(linetoken5.c_str());
 111     istringstream token6(linetoken6.c_str());
 112     istringstream token7(linetoken7.c_str());
 113     istringstream token8(linetoken8.c_str());
 114     istringstream token9(linetoken9.c_str());
 115     istringstream token10(linetoken10.c_str());
 116
 117     static bool tactilefadef_first = true;
 118
 119     switch(ice_map[linetoken2])
 120       {
 121       case iceTime_flag:
 122         {
 123           if (check_float(linetoken3))
 124             token3 >> token_value;
 125
 126           else
 127             uiuc_warnings_errors(1, *command_line);
 128
 129           ice_model = true;
 130           iceTime = token_value;
 131           break;
 132         }
 133       case transientTime_flag:
 134         {
 135           if (check_float(linetoken3))
 136             token3 >> token_value;
 137           else
 138             uiuc_warnings_errors(1, *command_line);
 139
 140           transientTime = token_value;
 141           break;
 142         }
 143       case eta_ice_final_flag:
 144         {
 145           if (check_float(linetoken3))
 146             token3 >> token_value;
 147           else
 148             uiuc_warnings_errors(1, *command_line);
 149
 150           eta_ice_final = token_value;
 151           break;
 152         }
 153       case beta_probe_wing_flag:
 154         {
 155           if (check_float(linetoken3))
 156             token3 >> token_value;
 157           else
 158             uiuc_warnings_errors(1, *command_line);
 159
 160           beta_model = true;
 161           x_probe_wing = token_value;
 162           break;
 163         }
 164       case beta_probe_tail_flag:
 165         {
 166           if (check_float(linetoken3))
 167             token3 >> token_value;
 168           else
 169             uiuc_warnings_errors(1, *command_line);
 170
 171           beta_model = true;
 172           x_probe_tail = token_value;
 173           break;
 174         }
 175       case kCDo_flag:
 176         {
 177           if (check_float(linetoken3))
 178             token3 >> token_value;
 179           else
 180             uiuc_warnings_errors(1, *command_line);
 181
 182           kCDo = token_value;
 183           break;
 184         }
 185       case kCDK_flag:
 186         {
 187           if (check_float(linetoken3))
 188             token3 >> token_value;
 189           else
 190             uiuc_warnings_errors(1, *command_line);
 191
 192           kCDK = token_value;
 193           break;
 194         }
 195       case kCD_a_flag:
 196         {
 197           if (check_float(linetoken3))
 198             token3 >> token_value;
 199           else
 200             uiuc_warnings_errors(1, *command_line);
 201
 202           kCD_a = token_value;
 203           break;
 204         }
 205       case kCD_adot_flag:
 206         {
 207           if (check_float(linetoken3))
 208             token3 >> token_value;
 209           else
 210             uiuc_warnings_errors(1, *command_line);
 211
 212           kCD_adot = token_value;
 213           break;
 214         }
 215       case kCD_q_flag:
 216         {
 217           if (check_float(linetoken3))
 218             token3 >> token_value;
 219           else
 220             uiuc_warnings_errors(1, *command_line);
 221
 222           kCD_q = token_value;
 223           break;
 224         }
 225       case kCD_de_flag:
 226         {
 227           if (check_float(linetoken3))
 228             token3 >> token_value;
 229           else
 230             uiuc_warnings_errors(1, *command_line);
 231
 232           kCD_de = token_value;
 233           break;
 234         }
 235       case kCXo_flag:
 236         {
 237           if (check_float(linetoken3))
 238             token3 >> token_value;
 239           else
 240             uiuc_warnings_errors(1, *command_line);
 241
 242           kCXo = token_value;
 243           break;
 244         }
 245       case kCXK_flag:
 246         {
 247           if (check_float(linetoken3))
 248             token3 >> token_value;
 249           else
 250             uiuc_warnings_errors(1, *command_line);
 251
 252           kCXK = token_value;
 253           break;
 254         }
 255       case kCX_a_flag:
 256         {
 257           if (check_float(linetoken3))
 258             token3 >> token_value;
 259           else
 260             uiuc_warnings_errors(1, *command_line);
 261
 262           kCX_a = token_value;
 263           break;
 264         }
 265       case kCX_a2_flag:
 266         {
 267           if (check_float(linetoken3))
 268             token3 >> token_value;
 269           else
 270             uiuc_warnings_errors(1, *command_line);
 271
 272           kCX_a2 = token_value;
 273           break;
 274         }
 275       case kCX_a3_flag:
 276         {
 277           if (check_float(linetoken3))
 278             token3 >> token_value;
 279           else
 280             uiuc_warnings_errors(1, *command_line);
 281
 282           kCX_a3 = token_value;
 283           break;
 284         }
 285       case kCX_adot_flag:
 286         {
 287           if (check_float(linetoken3))
 288             token3 >> token_value;
 289           else
 290             uiuc_warnings_errors(1, *command_line);
 291
 292           kCX_adot = token_value;
 293           break;
 294         }
 295       case kCX_q_flag:
 296         {
 297           if (check_float(linetoken3))
 298             token3 >> token_value;
 299           else
 300             uiuc_warnings_errors(1, *command_line);
 301
 302           kCX_q = token_value;
 303           break;
 304         }
 305       case kCX_de_flag:
 306         {
 307           if (check_float(linetoken3))
 308             token3 >> token_value;
 309           else
 310             uiuc_warnings_errors(1, *command_line);
 311
 312           kCX_de = token_value;
 313           break;
 314         }
 315       case kCX_dr_flag:
 316         {
 317           if (check_float(linetoken3))
 318             token3 >> token_value;
 319           else
 320             uiuc_warnings_errors(1, *command_line);
 321
 322           kCX_dr = token_value;
 323           break;
 324         }
 325       case kCX_df_flag:
 326         {
 327           if (check_float(linetoken3))
 328             token3 >> token_value;
 329           else
 330             uiuc_warnings_errors(1, *command_line);
 331
 332           kCX_df = token_value;
 333           break;
 334         }
 335       case kCX_adf_flag:
 336         {
 337           if (check_float(linetoken3))
 338             token3 >> token_value;
 339           else
 340             uiuc_warnings_errors(1, *command_line);
 341
 342           kCX_adf = token_value;
 343           break;
 344         }
 345       case kCLo_flag:
 346         {
 347           if (check_float(linetoken3))
 348             token3 >> token_value;
 349           else
 350             uiuc_warnings_errors(1, *command_line);
 351
 352           kCLo = token_value;
 353           break;
 354         }
 355       case kCL_a_flag:
 356         {
 357           if (check_float(linetoken3))
 358             token3 >> token_value;
 359           else
 360             uiuc_warnings_errors(1, *command_line);
 361
 362           kCL_a = token_value;
 363           break;
 364         }
 365       case kCL_adot_flag:
 366         {
 367           if (check_float(linetoken3))
 368             token3 >> token_value;
 369           else
 370             uiuc_warnings_errors(1, *command_line);
 371
 372           kCL_adot = token_value;
 373           break;
 374         }
 375       case kCL_q_flag:
 376         {
 377           if (check_float(linetoken3))
 378             token3 >> token_value;
 379           else
 380             uiuc_warnings_errors(1, *command_line);
 381
 382           kCL_q = token_value;
 383           break;
 384         }
 385       case kCL_de_flag:
 386         {
 387           if (check_float(linetoken3))
 388             token3 >> token_value;
 389           else
 390             uiuc_warnings_errors(1, *command_line);
 391
 392           kCL_de = token_value;
 393           break;
 394         }
 395       case kCZo_flag:
 396         {
 397           if (check_float(linetoken3))
 398             token3 >> token_value;
 399           else
 400             uiuc_warnings_errors(1, *command_line);
 401
 402           kCZo = token_value;
 403           break;
 404         }
 405       case kCZ_a_flag:
 406         {
 407           if (check_float(linetoken3))
 408             token3 >> token_value;
 409           else
 410             uiuc_warnings_errors(1, *command_line);
 411
 412           kCZ_a = token_value;
 413           break;
 414         }
 415       case kCZ_a2_flag:
 416         {
 417           if (check_float(linetoken3))
 418             token3 >> token_value;
 419           else
 420             uiuc_warnings_errors(1, *command_line);
 421
 422           kCZ_a2 = token_value;
 423           break;
 424         }
 425       case kCZ_a3_flag:
 426         {
 427           if (check_float(linetoken3))
 428             token3 >> token_value;
 429           else
 430             uiuc_warnings_errors(1, *command_line);
 431
 432           kCZ_a3 = token_value;
 433           break;
 434         }
 435       case kCZ_adot_flag:
 436         {
 437           if (check_float(linetoken3))
 438             token3 >> token_value;
 439           else
 440             uiuc_warnings_errors(1, *command_line);
 441
 442           kCZ_adot = token_value;
 443           break;
 444         }
 445       case kCZ_q_flag:
 446         {
 447           if (check_float(linetoken3))
 448             token3 >> token_value;
 449           else
 450             uiuc_warnings_errors(1, *command_line);
 451
 452           kCZ_q = token_value;
 453           break;
 454         }
 455       case kCZ_de_flag:
 456         {
 457           if (check_float(linetoken3))
 458             token3 >> token_value;
 459           else
 460             uiuc_warnings_errors(1, *command_line);
 461
 462           kCZ_de = token_value;
 463           break;
 464         }
 465       case kCZ_deb2_flag:
 466         {
 467           if (check_float(linetoken3))
 468             token3 >> token_value;
 469           else
 470             uiuc_warnings_errors(1, *command_line);
 471
 472           kCZ_deb2 = token_value;
 473           break;
 474         }
 475       case kCZ_df_flag:
 476         {
 477           if (check_float(linetoken3))
 478             token3 >> token_value;
 479           else
 480             uiuc_warnings_errors(1, *command_line);
 481
 482           kCZ_df = token_value;
 483           break;
 484         }
 485       case kCZ_adf_flag:
 486         {
 487           if (check_float(linetoken3))
 488             token3 >> token_value;
 489           else
 490             uiuc_warnings_errors(1, *command_line);
 491
 492           kCZ_adf = token_value;
 493           break;
 494         }
 495       case kCmo_flag:
 496         {
 497           if (check_float(linetoken3))
 498             token3 >> token_value;
 499           else
 500             uiuc_warnings_errors(1, *command_line);
 501
 502           kCmo = token_value;
 503           break;
 504         }
 505       case kCm_a_flag:
 506         {
 507           if (check_float(linetoken3))
 508             token3 >> token_value;
 509           else
 510             uiuc_warnings_errors(1, *command_line);
 511
 512           kCm_a = token_value;
 513           break;
 514         }
 515       case kCm_a2_flag:
 516         {
 517           if (check_float(linetoken3))
 518             token3 >> token_value;
 519           else
 520             uiuc_warnings_errors(1, *command_line);
 521
 522           kCm_a2 = token_value;
 523           break;
 524         }
 525       case kCm_adot_flag:
 526         {
 527           if (check_float(linetoken3))
 528             token3 >> token_value;
 529           else
 530             uiuc_warnings_errors(1, *command_line);
 531
 532           kCm_adot = token_value;
 533           break;
 534         }
 535       case kCm_q_flag:
 536         {
 537           if (check_float(linetoken3))
 538             token3 >> token_value;
 539           else
 540             uiuc_warnings_errors(1, *command_line);
 541
 542           kCm_q = token_value;
 543           break;
 544         }
 545       case kCm_de_flag:
 546         {
 547           if (check_float(linetoken3))
 548             token3 >> token_value;
 549           else
 550             uiuc_warnings_errors(1, *command_line);
 551
 552           kCm_de = token_value;
 553           break;
 554         }
 555       case kCm_b2_flag:
 556         {
 557           if (check_float(linetoken3))
 558             token3 >> token_value;
 559           else
 560             uiuc_warnings_errors(1, *command_line);
 561
 562           kCm_b2 = token_value;
 563           break;
 564         }
 565       case kCm_r_flag:
 566         {
 567           if (check_float(linetoken3))
 568             token3 >> token_value;
 569           else
 570             uiuc_warnings_errors(1, *command_line);
 571
 572           kCm_r = token_value;
 573           break;
 574         }
 575       case kCm_df_flag:
 576         {
 577           if (check_float(linetoken3))
 578             token3 >> token_value;
 579           else
 580             uiuc_warnings_errors(1, *command_line);
 581
 582           kCm_df = token_value;
 583           break;
 584         }
 585       case kCYo_flag:
 586         {
 587           if (check_float(linetoken3))
 588             token3 >> token_value;
 589           else
 590             uiuc_warnings_errors(1, *command_line);
 591
 592           kCYo = token_value;
 593           break;
 594         }
 595       case kCY_beta_flag:
 596         {
 597           if (check_float(linetoken3))
 598             token3 >> token_value;
 599           else
 600             uiuc_warnings_errors(1, *command_line);
 601
 602           kCY_beta = token_value;
 603           break;
 604         }
 605       case kCY_p_flag:
 606         {
 607           if (check_float(linetoken3))
 608             token3 >> token_value;
 609           else
 610             uiuc_warnings_errors(1, *command_line);
 611
 612           kCY_p = token_value;
 613           break;
 614         }
 615       case kCY_r_flag:
 616         {
 617           if (check_float(linetoken3))
 618             token3 >> token_value;
 619           else
 620             uiuc_warnings_errors(1, *command_line);
 621
 622           kCY_r = token_value;
 623           break;
 624         }
 625       case kCY_da_flag:
 626         {
 627           if (check_float(linetoken3))
 628             token3 >> token_value;
 629           else
 630             uiuc_warnings_errors(1, *command_line);
 631
 632           kCY_da = token_value;
 633           break;
 634         }
 635       case kCY_dr_flag:
 636         {
 637           if (check_float(linetoken3))
 638             token3 >> token_value;
 639           else
 640             uiuc_warnings_errors(1, *command_line);
 641
 642           kCY_dr = token_value;
 643           break;
 644         }
 645       case kCY_dra_flag:
 646         {
 647           if (check_float(linetoken3))
 648             token3 >> token_value;
 649           else
 650             uiuc_warnings_errors(1, *command_line);
 651
 652           kCY_dra = token_value;
 653           break;
 654         }
 655       case kCY_bdot_flag:
 656         {
 657           if (check_float(linetoken3))
 658             token3 >> token_value;
 659           else
 660             uiuc_warnings_errors(1, *command_line);
 661
 662           kCY_bdot = token_value;
 663           break;
 664         }
 665       case kClo_flag:
 666         {
 667           if (check_float(linetoken3))
 668             token3 >> token_value;
 669           else
 670             uiuc_warnings_errors(1, *command_line);
 671
 672           kClo = token_value;
 673           break;
 674         }
 675       case kCl_beta_flag:
 676         {
 677           if (check_float(linetoken3))
 678             token3 >> token_value;
 679           else
 680             uiuc_warnings_errors(1, *command_line);
 681
 682           kCl_beta = token_value;
 683           break;
 684         }
 685       case kCl_p_flag:
 686         {
 687           if (check_float(linetoken3))
 688             token3 >> token_value;
 689           else
 690             uiuc_warnings_errors(1, *command_line);
 691
 692           kCl_p = token_value;
 693           break;
 694         }
 695       case kCl_r_flag:
 696         {
 697           if (check_float(linetoken3))
 698             token3 >> token_value;
 699           else
 700             uiuc_warnings_errors(1, *command_line);
 701
 702           kCl_r = token_value;
 703           break;
 704         }
 705       case kCl_da_flag:
 706         {
 707           if (check_float(linetoken3))
 708             token3 >> token_value;
 709           else
 710             uiuc_warnings_errors(1, *command_line);
 711
 712           kCl_da = token_value;
 713           break;
 714         }
 715       case kCl_dr_flag:
 716         {
 717           if (check_float(linetoken3))
 718             token3 >> token_value;
 719           else
 720             uiuc_warnings_errors(1, *command_line);
 721
 722           kCl_dr = token_value;
 723           break;
 724         }
 725       case kCl_daa_flag:
 726         {
 727           if (check_float(linetoken3))
 728             token3 >> token_value;
 729           else
 730             uiuc_warnings_errors(1, *command_line);
 731
 732           kCl_daa = token_value;
 733           break;
 734         }
 735       case kCno_flag:
 736         {
 737           if (check_float(linetoken3))
 738             token3 >> token_value;
 739           else
 740             uiuc_warnings_errors(1, *command_line);
 741
 742           kCno = token_value;
 743           break;
 744         }
 745       case kCn_beta_flag:
 746         {
 747           if (check_float(linetoken3))
 748             token3 >> token_value;
 749           else
 750             uiuc_warnings_errors(1, *command_line);
 751
 752           kCn_beta = token_value;
 753           break;
 754         }
 755       case kCn_p_flag:
 756         {
 757           if (check_float(linetoken3))
 758             token3 >> token_value;
 759           else
 760             uiuc_warnings_errors(1, *command_line);
 761
 762           kCn_p = token_value;
 763           break;
 764         }
 765       case kCn_r_flag:
 766         {
 767           if (check_float(linetoken3))
 768             token3 >> token_value;
 769           else
 770             uiuc_warnings_errors(1, *command_line);
 771
 772           kCn_r = token_value;
 773           break;
 774         }
 775       case kCn_da_flag:
 776         {
 777           if (check_float(linetoken3))
 778             token3 >> token_value;
 779           else
 780             uiuc_warnings_errors(1, *command_line);
 781
 782           kCn_da = token_value;
 783           break;
 784         }
 785       case kCn_dr_flag:
 786         {
 787           if (check_float(linetoken3))
 788             token3 >> token_value;
 789           else
 790             uiuc_warnings_errors(1, *command_line);
 791
 792           kCn_dr = token_value;
 793           break;
 794         }
 795       case kCn_q_flag:
 796         {
 797           if (check_float(linetoken3))
 798             token3 >> token_value;
 799           else
 800             uiuc_warnings_errors(1, *command_line);
 801
 802           kCn_q = token_value;
 803           break;
 804         }
 805       case kCn_b3_flag:
 806         {
 807           if (check_float(linetoken3))
 808             token3 >> token_value;
 809           else
 810             uiuc_warnings_errors(1, *command_line);
 811
 812           kCn_b3 = token_value;
 813           break;
 814         }
 815       case bootTime_flag:
 816         {
 817           int index;
 818           if (check_float(linetoken4))
 819             token4 >> token_value;
 820           else
 821             uiuc_warnings_errors(1, *command_line);
 822           token3 >> index;
 823           if (index < 0 || index >= 20)
 824             uiuc_warnings_errors(1, *command_line);
 825           bootTime[index] = token_value;
 826           bootTrue[index] = true;
 827           break;
 828         }
 829       case eta_wing_left_input_flag:
 830         {
 831           eta_from_file = true;
 832           eta_wing_left_input = true;
 833           eta_wing_left_input_file = aircraft_directory + linetoken3;
 834           token4 >> token_value_convert1;
 835           token5 >> token_value_convert2;
 836           convert_y = uiuc_convert(token_value_convert1);
 837           convert_x = uiuc_convert(token_value_convert2);
 838           uiuc_1DdataFileReader(eta_wing_left_input_file,
 839                                 eta_wing_left_input_timeArray,
 840                                 eta_wing_left_input_daArray,
 841                                 eta_wing_left_input_ntime);
 842           token6 >> token_value;
 843           eta_wing_left_input_startTime = token_value;
 844           break;
 845         }
 846       case eta_wing_right_input_flag:
 847         {
 848           eta_from_file = true;
 849           eta_wing_right_input = true;
 850           eta_wing_right_input_file = aircraft_directory + linetoken3;
 851           token4 >> token_value_convert1;
 852           token5 >> token_value_convert2;
 853           convert_y = uiuc_convert(token_value_convert1);
 854           convert_x = uiuc_convert(token_value_convert2);
 855           uiuc_1DdataFileReader(eta_wing_right_input_file,
 856                                 eta_wing_right_input_timeArray,
 857                                 eta_wing_right_input_daArray,
 858                                 eta_wing_right_input_ntime);
 859           token6 >> token_value;
 860           eta_wing_right_input_startTime = token_value;
 861           break;
 862         }
 863       case eta_tail_input_flag:
 864         {
 865           eta_from_file = true;
 866           eta_tail_input = true;
 867           eta_tail_input_file = aircraft_directory + linetoken3;
 868           token4 >> token_value_convert1;
 869           token5 >> token_value_convert2;
 870           convert_y = uiuc_convert(token_value_convert1);
 871           convert_x = uiuc_convert(token_value_convert2);
 872           uiuc_1DdataFileReader(eta_tail_input_file,
 873                                 eta_tail_input_timeArray,
 874                                 eta_tail_input_daArray,
 875                                 eta_tail_input_ntime);
 876           token6 >> token_value;
 877           eta_tail_input_startTime = token_value;
 878           break;
 879         }
 880       case nonlin_ice_case_flag:
 881         {
 882           token3 >> nonlin_ice_case;
 883           break;
 884         }
 885       case eta_tail_flag:
 886         {
 887           if (check_float(linetoken3))
 888             token3 >> token_value;
 889           else
 890             uiuc_warnings_errors(1, *command_line);
 891
 892           eta_tail = token_value;
 893           break;
 894         }
 895       case eta_wing_left_flag:
 896         {
 897           if (check_float(linetoken3))
 898             token3 >> token_value;
 899           else
 900             uiuc_warnings_errors(1, *command_line);
 901
 902           eta_wing_left = token_value;
 903           break;
 904         }
 905       case eta_wing_right_flag:
 906         {
 907           if (check_float(linetoken3))
 908             token3 >> token_value;
 909           else
 910             uiuc_warnings_errors(1, *command_line);
 911
 912           eta_wing_right = token_value;
 913           break;
 914         }
 915       case demo_eps_alpha_max_flag:
 916         {
 917           demo_eps_alpha_max = true;
 918           demo_eps_alpha_max_file = aircraft_directory + linetoken3;
 919           token4 >> token_value_convert1;
 920           token5 >> token_value_convert2;
 921           convert_y = uiuc_convert(token_value_convert1);
 922           convert_x = uiuc_convert(token_value_convert2);
 923           uiuc_1DdataFileReader(demo_eps_alpha_max_file,
 924                                 demo_eps_alpha_max_timeArray,
 925                                 demo_eps_alpha_max_daArray,
 926                                 demo_eps_alpha_max_ntime);
 927           token6 >> token_value;
 928           demo_eps_alpha_max_startTime = token_value;
 929           break;
 930         }
 931       case demo_eps_pitch_max_flag:
 932         {
 933           demo_eps_pitch_max = true;
 934           demo_eps_pitch_max_file = aircraft_directory + linetoken3;
 935           token4 >> token_value_convert1;
 936           token5 >> token_value_convert2;
 937           convert_y = uiuc_convert(token_value_convert1);
 938           convert_x = uiuc_convert(token_value_convert2);
 939           uiuc_1DdataFileReader(demo_eps_pitch_max_file,
 940                                 demo_eps_pitch_max_timeArray,
 941                                 demo_eps_pitch_max_daArray,
 942                                 demo_eps_pitch_max_ntime);
 943           token6 >> token_value;
 944           demo_eps_pitch_max_startTime = token_value;
 945           break;
 946         }
 947       case demo_eps_pitch_min_flag:
 948         {
 949           demo_eps_pitch_min = true;
 950           demo_eps_pitch_min_file = aircraft_directory + linetoken3;
 951           token4 >> token_value_convert1;
 952           token5 >> token_value_convert2;
 953           convert_y = uiuc_convert(token_value_convert1);
 954           convert_x = uiuc_convert(token_value_convert2);
 955           uiuc_1DdataFileReader(demo_eps_pitch_min_file,
 956                                 demo_eps_pitch_min_timeArray,
 957                                 demo_eps_pitch_min_daArray,
 958                                 demo_eps_pitch_min_ntime);
 959           token6 >> token_value;
 960           demo_eps_pitch_min_startTime = token_value;
 961           break;
 962         }
 963       case demo_eps_roll_max_flag:
 964         {
 965           demo_eps_roll_max = true;
 966           demo_eps_roll_max_file = aircraft_directory + linetoken3;
 967           token4 >> token_value_convert1;
 968           token5 >> token_value_convert2;
 969           convert_y = uiuc_convert(token_value_convert1);
 970           convert_x = uiuc_convert(token_value_convert2);
 971           uiuc_1DdataFileReader(demo_eps_roll_max_file,
 972                                 demo_eps_roll_max_timeArray,
 973                                 demo_eps_roll_max_daArray,
 974                                 demo_eps_roll_max_ntime);
 975           token6 >> token_value;
 976           demo_eps_roll_max_startTime = token_value;
 977           break;
 978         }
 979       case demo_eps_thrust_min_flag:
 980         {
 981           demo_eps_thrust_min = true;
 982           demo_eps_thrust_min_file = aircraft_directory + linetoken3;
 983           token4 >> token_value_convert1;
 984           token5 >> token_value_convert2;
 985           convert_y = uiuc_convert(token_value_convert1);
 986           convert_x = uiuc_convert(token_value_convert2);
 987           uiuc_1DdataFileReader(demo_eps_thrust_min_file,
 988                                 demo_eps_thrust_min_timeArray,
 989                                 demo_eps_thrust_min_daArray,
 990                                 demo_eps_thrust_min_ntime);
 991           token6 >> token_value;
 992           demo_eps_thrust_min_startTime = token_value;
 993           break;
 994         }
 995       case demo_eps_airspeed_max_flag:
 996         {
 997           demo_eps_airspeed_max = true;
 998           demo_eps_airspeed_max_file = aircraft_directory + linetoken3;
 999           token4 >> token_value_convert1;
1000           token5 >> token_value_convert2;
1001           convert_y = uiuc_convert(token_value_convert1);
1002           convert_x = uiuc_convert(token_value_convert2);
1003           uiuc_1DdataFileReader(demo_eps_airspeed_max_file,
1004                                 demo_eps_airspeed_max_timeArray,
1005                                 demo_eps_airspeed_max_daArray,
1006                                 demo_eps_airspeed_max_ntime);
1007           token6 >> token_value;
1008           demo_eps_airspeed_max_startTime = token_value;
1009           break;
1010         }
1011       case demo_eps_airspeed_min_flag:
1012         {
1013           demo_eps_airspeed_min = true;
1014           demo_eps_airspeed_min_file = aircraft_directory + linetoken3;
1015           token4 >> token_value_convert1;
1016           token5 >> token_value_convert2;
1017           convert_y = uiuc_convert(token_value_convert1);
1018           convert_x = uiuc_convert(token_value_convert2);
1019           uiuc_1DdataFileReader(demo_eps_airspeed_min_file,
1020                                 demo_eps_airspeed_min_timeArray,
1021                                 demo_eps_airspeed_min_daArray,
1022                                 demo_eps_airspeed_min_ntime);
1023           token6 >> token_value;
1024           demo_eps_airspeed_min_startTime = token_value;
1025           break;
1026         }
1027       case demo_eps_flap_max_flag:
1028         {
1029           demo_eps_flap_max = true;
1030           demo_eps_flap_max_file = aircraft_directory + linetoken3;
1031           token4 >> token_value_convert1;
1032           token5 >> token_value_convert2;
1033           convert_y = uiuc_convert(token_value_convert1);
1034           convert_x = uiuc_convert(token_value_convert2);
1035           uiuc_1DdataFileReader(demo_eps_flap_max_file,
1036                                 demo_eps_flap_max_timeArray,
1037                                 demo_eps_flap_max_daArray,
1038                                 demo_eps_flap_max_ntime);
1039           token6 >> token_value;
1040           demo_eps_flap_max_startTime = token_value;
1041           break;
1042         }
1043       case demo_boot_cycle_tail_flag:
1044         {
1045           demo_boot_cycle_tail = true;
1046           demo_boot_cycle_tail_file = aircraft_directory + linetoken3;
1047           token4 >> token_value_convert1;
1048           token5 >> token_value_convert2;
1049           convert_y = uiuc_convert(token_value_convert1);
1050           convert_x = uiuc_convert(token_value_convert2);
1051           uiuc_1DdataFileReader(demo_boot_cycle_tail_file,
1052                                 demo_boot_cycle_tail_timeArray,
1053                                 demo_boot_cycle_tail_daArray,
1054                                 demo_boot_cycle_tail_ntime);
1055           token6 >> token_value;
1056           demo_boot_cycle_tail_startTime = token_value;
1057           break;
1058         }
1059       case demo_boot_cycle_wing_left_flag:
1060         {
1061           demo_boot_cycle_wing_left = true;
1062           demo_boot_cycle_wing_left_file = aircraft_directory + linetoken3;
1063           token4 >> token_value_convert1;
1064           token5 >> token_value_convert2;
1065           convert_y = uiuc_convert(token_value_convert1);
1066           convert_x = uiuc_convert(token_value_convert2);
1067           uiuc_1DdataFileReader(demo_boot_cycle_wing_left_file,
1068                                 demo_boot_cycle_wing_left_timeArray,
1069                                 demo_boot_cycle_wing_left_daArray,
1070                                 demo_boot_cycle_wing_left_ntime);
1071           token6 >> token_value;
1072           demo_boot_cycle_wing_left_startTime = token_value;
1073           break;
1074         }
1075       case demo_boot_cycle_wing_right_flag:
1076         {
1077           demo_boot_cycle_wing_right = true;
1078           demo_boot_cycle_wing_right_file = aircraft_directory + linetoken3;
1079           token4 >> token_value_convert1;
1080           token5 >> token_value_convert2;
1081           convert_y = uiuc_convert(token_value_convert1);
1082           convert_x = uiuc_convert(token_value_convert2);
1083           uiuc_1DdataFileReader(demo_boot_cycle_wing_right_file,
1084                                 demo_boot_cycle_wing_right_timeArray,
1085                                 demo_boot_cycle_wing_right_daArray,
1086                                 demo_boot_cycle_wing_right_ntime);
1087           token6 >> token_value;
1088           demo_boot_cycle_wing_right_startTime = token_value;
1089           break;
1090         }
1091       case demo_eps_pitch_input_flag:
1092         {
1093           demo_eps_pitch_input = true;
1094           demo_eps_pitch_input_file = aircraft_directory + linetoken3;
1095           token4 >> token_value_convert1;
1096           token5 >> token_value_convert2;
1097           convert_y = uiuc_convert(token_value_convert1);
1098           convert_x = uiuc_convert(token_value_convert2);
1099           uiuc_1DdataFileReader(demo_eps_pitch_input_file,
1100                                 demo_eps_pitch_input_timeArray,
1101                                 demo_eps_pitch_input_daArray,
1102                                 demo_eps_pitch_input_ntime);
1103           token6 >> token_value;
1104           demo_eps_pitch_input_startTime = token_value;
1105           break;
1106         }
1107       case demo_ap_pah_on_flag:
1108         {
1109           demo_ap_pah_on = true;
1110           demo_ap_pah_on_file = aircraft_directory + linetoken3;
1111           token4 >> token_value_convert1;
1112           token5 >> token_value_convert2;
1113           convert_y = uiuc_convert(token_value_convert1);
1114           convert_x = uiuc_convert(token_value_convert2);
1115           uiuc_1DdataFileReader(demo_ap_pah_on_file,
1116                                 demo_ap_pah_on_timeArray,
1117                                 demo_ap_pah_on_daArray,
1118                                 demo_ap_pah_on_ntime);
1119           token6 >> token_value;
1120           demo_ap_pah_on_startTime = token_value;
1121           break;
1122         }
1123       case demo_ap_alh_on_flag:
1124         {
1125           demo_ap_alh_on = true;
1126           demo_ap_alh_on_file = aircraft_directory + linetoken3;
1127           token4 >> token_value_convert1;
1128           token5 >> token_value_convert2;
1129           convert_y = uiuc_convert(token_value_convert1);
1130           convert_x = uiuc_convert(token_value_convert2);
1131           uiuc_1DdataFileReader(demo_ap_alh_on_file,
1132                                 demo_ap_alh_on_timeArray,
1133                                 demo_ap_alh_on_daArray,
1134                                 demo_ap_alh_on_ntime);
1135           token6 >> token_value;
1136           demo_ap_alh_on_startTime = token_value;
1137           break;
1138         }
1139       case demo_ap_rah_on_flag:
1140         {
1141           demo_ap_rah_on = true;
1142           demo_ap_rah_on_file = aircraft_directory + linetoken3;
1143           token4 >> token_value_convert1;
1144           token5 >> token_value_convert2;
1145           convert_y = uiuc_convert(token_value_convert1);
1146           convert_x = uiuc_convert(token_value_convert2);
1147           uiuc_1DdataFileReader(demo_ap_rah_on_file,
1148                                 demo_ap_rah_on_timeArray,
1149                                 demo_ap_rah_on_daArray,
1150                                 demo_ap_rah_on_ntime);
1151           token6 >> token_value;
1152           demo_ap_rah_on_startTime = token_value;
1153           break;
1154         }
1155        case demo_ap_hh_on_flag:
1156         {
1157           demo_ap_hh_on = true;
1158           demo_ap_hh_on_file = aircraft_directory + linetoken3;
1159           token4 >> token_value_convert1;
1160           token5 >> token_value_convert2;
1161           convert_y = uiuc_convert(token_value_convert1);
1162           convert_x = uiuc_convert(token_value_convert2);
1163           uiuc_1DdataFileReader(demo_ap_hh_on_file,
1164                                 demo_ap_hh_on_timeArray,
1165                                 demo_ap_hh_on_daArray,
1166                                 demo_ap_hh_on_ntime);
1167           token6 >> token_value;
1168           demo_ap_hh_on_startTime = token_value;
1169           break;
1170         }
1171      case demo_ap_Theta_ref_flag:
1172         {
1173           demo_ap_Theta_ref = true;
1174           demo_ap_Theta_ref_file = aircraft_directory + linetoken3;
1175           token4 >> token_value_convert1;
1176           token5 >> token_value_convert2;
1177           convert_y = uiuc_convert(token_value_convert1);
1178           convert_x = uiuc_convert(token_value_convert2);
1179           uiuc_1DdataFileReader(demo_ap_Theta_ref_file,
1180                                 demo_ap_Theta_ref_timeArray,
1181                                 demo_ap_Theta_ref_daArray,
1182                                 demo_ap_Theta_ref_ntime);
1183           token6 >> token_value;
1184           demo_ap_Theta_ref_startTime = token_value;
1185           break;
1186         }
1187       case demo_ap_alt_ref_flag:
1188         {
1189           demo_ap_alt_ref = true;
1190           demo_ap_alt_ref_file = aircraft_directory + linetoken3;
1191           token4 >> token_value_convert1;
1192           token5 >> token_value_convert2;
1193           convert_y = uiuc_convert(token_value_convert1);
1194           convert_x = uiuc_convert(token_value_convert2);
1195           uiuc_1DdataFileReader(demo_ap_alt_ref_file,
1196                                 demo_ap_alt_ref_timeArray,
1197                                 demo_ap_alt_ref_daArray,
1198                                 demo_ap_alt_ref_ntime);
1199           token6 >> token_value;
1200           demo_ap_alt_ref_startTime = token_value;
1201           break;
1202         }
1203       case demo_ap_Phi_ref_flag:
1204         {
1205           demo_ap_Phi_ref = true;
1206           demo_ap_Phi_ref_file = aircraft_directory + linetoken3;
1207           token4 >> token_value_convert1;
1208           token5 >> token_value_convert2;
1209           convert_y = uiuc_convert(token_value_convert1);
1210           convert_x = uiuc_convert(token_value_convert2);
1211           uiuc_1DdataFileReader(demo_ap_Phi_ref_file,
1212                                 demo_ap_Phi_ref_timeArray,
1213                                 demo_ap_Phi_ref_daArray,
1214                                 demo_ap_Phi_ref_ntime);
1215           token6 >> token_value;
1216           demo_ap_Phi_ref_startTime = token_value;
1217           break;
1218         }
1219       case demo_ap_Psi_ref_flag:
1220         {
1221           demo_ap_Psi_ref = true;
1222           demo_ap_Psi_ref_file = aircraft_directory + linetoken3;
1223           token4 >> token_value_convert1;
1224           token5 >> token_value_convert2;
1225           convert_y = uiuc_convert(token_value_convert1);
1226           convert_x = uiuc_convert(token_value_convert2);
1227           uiuc_1DdataFileReader(demo_ap_Psi_ref_file,
1228                                 demo_ap_Psi_ref_timeArray,
1229                                 demo_ap_Psi_ref_daArray,
1230                                 demo_ap_Psi_ref_ntime);
1231           token6 >> token_value;
1232           demo_ap_Psi_ref_startTime = token_value;
1233           break;
1234         }
1235       case tactilefadef_flag:
1236         {
1237           int tactilefadef_index, i;
1238           string tactilefadef_file;
1239           double flap_value;
1240           tactilefadef = true;
1241           tactilefadef_file = aircraft_directory + linetoken3;
1242           token4 >> tactilefadef_index;
1243           if (tactilefadef_index < 0 || tactilefadef_index >= 30)
1244             uiuc_warnings_errors(1, *command_line);
1245           if (tactilefadef_index > tactilefadef_nf)
1246             tactilefadef_nf = tactilefadef_index;
1247           token5 >> flap_value;
1248           token6 >> token_value_convert1;
1249           token7 >> token_value_convert2;
1250           token8 >> token_value_convert3;
1251           token9 >> token_value_convert4;
1252           token10 >> tactilefadef_nice;
1253           convert_z = uiuc_convert(token_value_convert1);
1254           convert_x = uiuc_convert(token_value_convert2);
1255           convert_y = uiuc_convert(token_value_convert3);
1256           convert_f = uiuc_convert(token_value_convert4);
1257           tactilefadef_fArray[tactilefadef_index] = flap_value * convert_f;
1258           /* call 2D File Reader with file name (tactilefadef_file) and
1259              conversion factors; function returns array of
1260              elevator deflections (deArray) and corresponding
1261              alpha (aArray) and delta CZ (CZArray) values and
1262              max number of terms in alpha arrays (nAlphaArray)
1263              and delfection array (nde) */
1264           uiuc_2DdataFileReader(tactilefadef_file,
1265                                 datafile_xArray,
1266                                 datafile_yArray,
1267                                 datafile_zArray,
1268                                 datafile_nxArray,
1269                                 datafile_ny);
1270           d_2_to_3(datafile_xArray, tactilefadef_aArray, tactilefadef_index);
1271           d_1_to_2(datafile_yArray, tactilefadef_deArray, tactilefadef_index);
1272           d_2_to_3(datafile_zArray, tactilefadef_tactileArray, tactilefadef_index);
1273           i_1_to_2(datafile_nxArray, tactilefadef_nAlphaArray, tactilefadef_index);
1274           tactilefadef_nde[tactilefadef_index] = datafile_ny;
1275           if (tactilefadef_first==true)
1276             {
1277               if (tactilefadef_nice == 1)
1278                 {
1279                   tactilefadef_na_nice = datafile_nxArray[1];
1280                   tactilefadef_nde_nice = datafile_ny;
1281                   d_1_to_1(datafile_yArray, tactilefadef_deArray_nice);
1282                   for (i=1; i<=tactilefadef_na_nice; i++)
1283                     tactilefadef_aArray_nice[i] = datafile_xArray[1][i];
1284                 }
1285               tactilefadef_first=false;
1286             }
1287           break;
1288         }
1289       case tactile_pitch_flag:
1290         {
1291           tactile_pitch = 1;
1292           break;
1293         }
1294       case demo_tactile_flag:
1295         {
1296           demo_tactile = true;
1297           demo_tactile_file = aircraft_directory + linetoken3;
1298           token4 >> token_value_convert1;
1299           token5 >> token_value_convert2;
1300           convert_y = uiuc_convert(token_value_convert1);
1301           convert_x = uiuc_convert(token_value_convert2);
1302           uiuc_1DdataFileReader(demo_tactile_file,
1303                                 demo_tactile_timeArray,
1304                                 demo_tactile_daArray,
1305                                 demo_tactile_ntime);
1306           token6 >> token_value;
1307           demo_tactile_startTime = token_value;
1308           break;
1309         }
1310       case demo_ice_tail_flag:
1311         {
1312           demo_ice_tail = true;
1313           demo_ice_tail_file = aircraft_directory + linetoken3;
1314           token4 >> token_value_convert1;
1315           token5 >> token_value_convert2;
1316           convert_y = uiuc_convert(token_value_convert1);
1317           convert_x = uiuc_convert(token_value_convert2);
1318           uiuc_1DdataFileReader(demo_ice_tail_file,
1319                                 demo_ice_tail_timeArray,
1320                                 demo_ice_tail_daArray,
1321                                 demo_ice_tail_ntime);
1322           token6 >> token_value;
1323           demo_ice_tail_startTime = token_value;
1324           break;
1325         }
1326       case demo_ice_left_flag:
1327         {
1328           demo_ice_left = true;
1329           demo_ice_left_file = aircraft_directory + linetoken3;
1330           token4 >> token_value_convert1;
1331           token5 >> token_value_convert2;
1332           convert_y = uiuc_convert(token_value_convert1);
1333           convert_x = uiuc_convert(token_value_convert2);
1334           uiuc_1DdataFileReader(demo_ice_left_file,
1335                                 demo_ice_left_timeArray,
1336                                 demo_ice_left_daArray,
1337                                 demo_ice_left_ntime);
1338           token6 >> token_value;
1339           demo_ice_left_startTime = token_value;
1340           break;
1341         }
1342       case demo_ice_right_flag:
1343         {
1344           demo_ice_right = true;
1345           demo_ice_right_file = aircraft_directory + linetoken3;
1346           token4 >> token_value_convert1;
1347           token5 >> token_value_convert2;
1348           convert_y = uiuc_convert(token_value_convert1);
1349           convert_x = uiuc_convert(token_value_convert2);
1350           uiuc_1DdataFileReader(demo_ice_right_file,
1351                                 demo_ice_right_timeArray,
1352                                 demo_ice_right_daArray,
1353                                 demo_ice_right_ntime);
1354           token6 >> token_value;
1355           demo_ice_right_startTime = token_value;
1356           break;
1357         }
1358       default:
1359         {
1360           if (ignore_unknown_keywords) {
1361             // do nothing
1362           } else {
1363             // print error message
1364             uiuc_warnings_errors(2, *command_line);
1365           }
1366           break;
1367         }
1368       };
1369 }