src/FDM/UIUCModel/uiuc_menu_controlSurface.cpp

   1 /**********************************************************************
   2
   3  FILENAME:     uiuc_menu_controlSurface.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_controlSurface.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_controlSurface( 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,
 101                            const string& aircraft_directory,
 102                            LIST command_line ) {
 103     double token_value;
 104     int token_value_convert1, token_value_convert2;
 105     istringstream token3(linetoken3.c_str());
 106     istringstream token4(linetoken4.c_str());
 107     istringstream token5(linetoken5.c_str());
 108     istringstream token6(linetoken6.c_str());
 109     istringstream token7(linetoken7.c_str());
 110     istringstream token8(linetoken8.c_str());
 111     istringstream token9(linetoken9.c_str());
 112     istringstream token10(linetoken10.c_str());
 113
 114     switch(controlSurface_map[linetoken2])
 115       {
 116       case de_flag:
 117         {
 118           if (check_float(linetoken3))
 119             token3 >> token_value;
 120           else
 121             uiuc_warnings_errors(1, *command_line);
 122
 123           demax = token_value;
 124
 125           if (check_float(linetoken4))
 126             token4 >> token_value;
 127           else
 128             uiuc_warnings_errors(1, *command_line);
 129
 130           demin = token_value;
 131           break;
 132         }
 133       case da_flag:
 134         {
 135           if (check_float(linetoken3))
 136             token3 >> token_value;
 137           else
 138             uiuc_warnings_errors(1, *command_line);
 139
 140           damax = token_value;
 141
 142           if (check_float(linetoken4))
 143             token4 >> token_value;
 144           else
 145             uiuc_warnings_errors(1, *command_line);
 146
 147           damin = token_value;
 148           break;
 149         }
 150       case dr_flag:
 151         {
 152           if (check_float(linetoken3))
 153             token3 >> token_value;
 154           else
 155             uiuc_warnings_errors(1, *command_line);
 156
 157           drmax = token_value;
 158
 159           if (check_float(linetoken4))
 160             token4 >> token_value;
 161           else
 162             uiuc_warnings_errors(1, *command_line);
 163
 164           drmin = token_value;
 165           break;
 166         }
 167       case set_Long_trim_flag:
 168         {
 169           if (check_float(linetoken3))
 170             token3 >> token_value;
 171           else
 172             uiuc_warnings_errors(1, *command_line);
 173
 174           set_Long_trim = true;
 175           elevator_tab = token_value;
 176           break;
 177         }
 178       case set_Long_trim_deg_flag:
 179         {
 180           if (check_float(linetoken3))
 181             token3 >> token_value;
 182           else
 183             uiuc_warnings_errors(1, *command_line);
 184
 185           set_Long_trim = true;
 186           elevator_tab = token_value * DEG_TO_RAD;
 187           break;
 188         }
 189       case zero_Long_trim_flag:
 190         {
 191           zero_Long_trim = true;
 192           break;
 193         }
 194       case elevator_step_flag:
 195         {
 196           // set step input flag
 197           elevator_step = true;
 198
 199           // read in step angle in degrees and convert
 200           if (check_float(linetoken3))
 201             token3 >> token_value;
 202           else
 203             uiuc_warnings_errors(1, *command_line);
 204
 205           elevator_step_angle = token_value * DEG_TO_RAD;
 206
 207           // read in step start time
 208           if (check_float(linetoken4))
 209             token4 >> token_value;
 210           else
 211             uiuc_warnings_errors(1, *command_line);
 212
 213           elevator_step_startTime = token_value;
 214           break;
 215         }
 216       case elevator_singlet_flag:
 217         {
 218           // set singlet input flag
 219           elevator_singlet = true;
 220
 221           // read in singlet angle in degrees and convert
 222           if (check_float(linetoken3))
 223             token3 >> token_value;
 224           else
 225             uiuc_warnings_errors(1, *command_line);
 226
 227           elevator_singlet_angle = token_value * DEG_TO_RAD;
 228
 229           // read in singlet start time
 230           if (check_float(linetoken4))
 231             token4 >> token_value;
 232           else
 233             uiuc_warnings_errors(1, *command_line);
 234
 235           elevator_singlet_startTime = token_value;
 236
 237           // read in singlet duration
 238           if (check_float(linetoken5))
 239             token5 >> token_value;
 240           else
 241             uiuc_warnings_errors(1, *command_line);
 242
 243           elevator_singlet_duration = token_value;
 244           break;
 245         }
 246       case elevator_doublet_flag:
 247         {
 248           // set doublet input flag
 249           elevator_doublet = true;
 250
 251           // read in doublet angle in degrees and convert
 252           if (check_float(linetoken3))
 253             token3 >> token_value;
 254           else
 255             uiuc_warnings_errors(1, *command_line);
 256
 257           elevator_doublet_angle = token_value * DEG_TO_RAD;
 258
 259           // read in doublet start time
 260           if (check_float(linetoken4))
 261             token4 >> token_value;
 262           else
 263             uiuc_warnings_errors(1, *command_line);
 264
 265           elevator_doublet_startTime = token_value;
 266
 267           // read in doublet duration
 268           if (check_float(linetoken5))
 269             token5 >> token_value;
 270           else
 271             uiuc_warnings_errors(1, *command_line);
 272
 273           elevator_doublet_duration = token_value;
 274           break;
 275         }
 276       case elevator_input_flag:
 277         {
 278           elevator_input = true;
 279           elevator_input_file = aircraft_directory + linetoken3;
 280           token4 >> token_value_convert1;
 281           token5 >> token_value_convert2;
 282           convert_y = uiuc_convert(token_value_convert1);
 283           convert_x = uiuc_convert(token_value_convert2);
 284           uiuc_1DdataFileReader(elevator_input_file,
 285                                 elevator_input_timeArray,
 286                                 elevator_input_deArray,
 287                                 elevator_input_ntime);
 288           token6 >> token_value;
 289           elevator_input_startTime = token_value;
 290           break;
 291         }
 292       case aileron_input_flag:
 293         {
 294           aileron_input = true;
 295           aileron_input_file = aircraft_directory + linetoken3;
 296           token4 >> token_value_convert1;
 297           token5 >> token_value_convert2;
 298           convert_y = uiuc_convert(token_value_convert1);
 299           convert_x = uiuc_convert(token_value_convert2);
 300           uiuc_1DdataFileReader(aileron_input_file,
 301                                 aileron_input_timeArray,
 302                                 aileron_input_daArray,
 303                                 aileron_input_ntime);
 304           token6 >> token_value;
 305           aileron_input_startTime = token_value;
 306           break;
 307         }
 308       case rudder_input_flag:
 309         {
 310           rudder_input = true;
 311           rudder_input_file = aircraft_directory + linetoken3;
 312           token4 >> token_value_convert1;
 313           token5 >> token_value_convert2;
 314           convert_y = uiuc_convert(token_value_convert1);
 315           convert_x = uiuc_convert(token_value_convert2);
 316           uiuc_1DdataFileReader(rudder_input_file,
 317                                 rudder_input_timeArray,
 318                                 rudder_input_drArray,
 319                                 rudder_input_ntime);
 320           token6 >> token_value;
 321           rudder_input_startTime = token_value;
 322           break;
 323         }
 324       case flap_pos_input_flag:
 325         {
 326           flap_pos_input = true;
 327           flap_pos_input_file = aircraft_directory + linetoken3;
 328           token4 >> token_value_convert1;
 329           token5 >> token_value_convert2;
 330           convert_y = uiuc_convert(token_value_convert1);
 331           convert_x = uiuc_convert(token_value_convert2);
 332           uiuc_1DdataFileReader(flap_pos_input_file,
 333                                 flap_pos_input_timeArray,
 334                                 flap_pos_input_dfArray,
 335                                 flap_pos_input_ntime);
 336           token6 >> token_value;
 337           flap_pos_input_startTime = token_value;
 338           break;
 339         }
 340       case pilot_elev_no_flag:
 341         {
 342           pilot_elev_no_check = true;
 343           break;
 344         }
 345       case pilot_ail_no_flag:
 346         {
 347           pilot_ail_no_check = true;
 348           break;
 349         }
 350       case pilot_rud_no_flag:
 351         {
 352           pilot_rud_no_check = true;
 353           break;
 354         }
 355       case flap_max_flag:
 356         {
 357           if (check_float(linetoken3))
 358             token3 >> token_value;
 359           else
 360             uiuc_warnings_errors(1, *command_line);
 361
 362           use_flaps = true;
 363           flap_max = token_value;
 364           break;
 365         }
 366       case flap_rate_flag:
 367         {
 368           if (check_float(linetoken3))
 369             token3 >> token_value;
 370           else
 371             uiuc_warnings_errors(1, *command_line);
 372
 373           use_flaps = true;
 374           flap_rate = token_value;
 375           break;
 376         }
 377       case spoiler_max_flag:
 378         {
 379           if (check_float(linetoken3))
 380             token3 >> token_value;
 381           else
 382             uiuc_warnings_errors(1, *command_line);
 383
 384           use_spoilers = true;
 385           spoiler_max = token_value;
 386           break;
 387         }
 388       case spoiler_rate_flag:
 389         {
 390           if (check_float(linetoken3))
 391             token3 >> token_value;
 392           else
 393             uiuc_warnings_errors(1, *command_line);
 394
 395           use_spoilers = true;
 396           spoiler_rate = token_value;
 397           break;
 398         }
 399       case aileron_sas_KP_flag:
 400         {
 401           if (check_float(linetoken3))
 402             token3 >> token_value;
 403           else
 404             uiuc_warnings_errors(1, *command_line);
 405
 406           aileron_sas_KP = token_value;
 407           break;
 408         }
 409       case aileron_sas_max_flag:
 410         {
 411           if (check_float(linetoken3))
 412             token3 >> token_value;
 413           else
 414             uiuc_warnings_errors(1, *command_line);
 415           aileron_sas_max = token_value;
 416           use_aileron_sas_max = true;
 417           break;
 418         }
 419       case aileron_stick_gain_flag:
 420         {
 421           if (check_float(linetoken3))
 422             token3 >> token_value;
 423           else
 424             uiuc_warnings_errors(1, *command_line);
 425           aileron_stick_gain = token_value;
 426           use_aileron_stick_gain = true;
 427           break;
 428         }
 429       case elevator_sas_KQ_flag:
 430         {
 431           if (check_float(linetoken3))
 432             token3 >> token_value;
 433           else
 434             uiuc_warnings_errors(1, *command_line);
 435           elevator_sas_KQ = token_value;
 436           break;
 437         }
 438       case elevator_sas_max_flag:
 439         {
 440           if (check_float(linetoken3))
 441             token3 >> token_value;
 442           else
 443             uiuc_warnings_errors(1, *command_line);
 444           elevator_sas_max = token_value;
 445           use_elevator_sas_max = true;
 446           break;
 447         }
 448       case elevator_sas_min_flag:
 449         {
 450           if (check_float(linetoken3))
 451             token3 >> token_value;
 452           else
 453             uiuc_warnings_errors(1, *command_line);
 454           elevator_sas_min = token_value;
 455           use_elevator_sas_min = true;
 456           break;
 457         }
 458       case elevator_stick_gain_flag:
 459         {
 460           if (check_float(linetoken3))
 461             token3 >> token_value;
 462           else
 463             uiuc_warnings_errors(1, *command_line);
 464           elevator_stick_gain = token_value;
 465           use_elevator_stick_gain = true;
 466           break;
 467         }
 468       case rudder_sas_KR_flag:
 469         {
 470           if (check_float(linetoken3))
 471             token3 >> token_value;
 472           else
 473             uiuc_warnings_errors(1, *command_line);
 474           rudder_sas_KR = token_value;
 475           break;
 476         }
 477       case rudder_sas_max_flag:
 478         {
 479           if (check_float(linetoken3))
 480             token3 >> token_value;
 481           else
 482             uiuc_warnings_errors(1, *command_line);
 483           rudder_sas_max = token_value;
 484           use_rudder_sas_max = true;
 485           break;
 486         }
 487       case rudder_stick_gain_flag:
 488         {
 489           if (check_float(linetoken3))
 490             token3 >> token_value;
 491           else
 492             uiuc_warnings_errors(1, *command_line);
 493           rudder_stick_gain = token_value;
 494           use_rudder_stick_gain = true;
 495           break;
 496         }
 497       case use_aileron_sas_type1_flag:
 498         {
 499           use_aileron_sas_type1 = true;
 500           break;
 501         }
 502       case use_elevator_sas_type1_flag:
 503         {
 504           use_elevator_sas_type1 = true;
 505           break;
 506         }
 507       case use_rudder_sas_type1_flag:
 508         {
 509           use_rudder_sas_type1 = true;
 510           break;
 511         }
 512       case ap_pah_flag:
 513         {
 514           if (check_float(linetoken3))
 515             token3 >> token_value;
 516           else
 517             uiuc_warnings_errors(1, *command_line);
 518
 519           ap_pah_start_time=token_value;
 520           ap_pah_on = 1;
 521           break;
 522         }
 523       case ap_alh_flag:
 524         {
 525           if (check_float(linetoken3))
 526             token3 >> token_value;
 527           else
 528             uiuc_warnings_errors(1, *command_line);
 529
 530           ap_alh_start_time=token_value;
 531           ap_alh_on = 1;
 532           break;
 533         }
 534       case ap_rah_flag:
 535         {
 536           if (check_float(linetoken3))
 537             token3 >> token_value;
 538           else
 539             uiuc_warnings_errors(1, *command_line);
 540
 541           ap_rah_start_time=token_value;
 542           ap_rah_on = 1;
 543           break;
 544         }
 545       case ap_hh_flag:
 546         {
 547           if (check_float(linetoken3))
 548             token3 >> token_value;
 549           else
 550             uiuc_warnings_errors(1, *command_line);
 551
 552           ap_hh_start_time=token_value;
 553           ap_hh_on = 1;
 554           break;
 555         }
 556       case ap_Theta_ref_flag:
 557         {
 558           if (check_float(linetoken3))
 559             token3 >> token_value;
 560           else
 561             uiuc_warnings_errors(1, *command_line);
 562           token4 >> token_value_convert1;
 563           convert_y = uiuc_convert(token_value_convert1);
 564
 565           ap_Theta_ref_rad = token_value * convert_y;
 566           break;
 567         }
 568       case ap_alt_ref_flag:
 569         {
 570           if (check_float(linetoken3))
 571             token3 >> token_value;
 572           else
 573             uiuc_warnings_errors(1, *command_line);
 574
 575           ap_alt_ref_ft = token_value;
 576           break;
 577         }
 578       case ap_Phi_ref_flag:
 579         {
 580           if (check_float(linetoken3))
 581             token3 >> token_value;
 582           else
 583             uiuc_warnings_errors(1, *command_line);
 584           token4 >> token_value_convert1;
 585           convert_y = uiuc_convert(token_value_convert1);
 586
 587           ap_Phi_ref_rad = token_value * convert_y;
 588           break;
 589         }
 590       case ap_Psi_ref_flag:
 591         {
 592           if (check_float(linetoken3))
 593             token3 >> token_value;
 594           else
 595             uiuc_warnings_errors(1, *command_line);
 596           token4 >> token_value_convert1;
 597           convert_y = uiuc_convert(token_value_convert1);
 598
 599           ap_Psi_ref_rad = token_value * convert_y;
 600           break;
 601         }
 602       default:
 603         {
 604           if (ignore_unknown_keywords) {
 605             // do nothing
 606           } else {
 607             // print error message
 608             uiuc_warnings_errors(2, *command_line);
 609           }
 610           break;
 611         }
 612       };
 613 }