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