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