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