src/FDM/UIUCModel/uiuc_menu_CY.cpp

   1 /**********************************************************************
   2
   3  FILENAME:     uiuc_menu_CY.cpp
   4
   5 ----------------------------------------------------------------------
   6
   7  DESCRIPTION:  reads input data for specified aircraft and creates
   8                approporiate data storage space
   9
  10 ----------------------------------------------------------------------
  11
  12  STATUS:       alpha version
  13
  14 ----------------------------------------------------------------------
  15
  16  REFERENCES:   based on "menu reader" format of Michael Selig
  17
  18 ----------------------------------------------------------------------
  19
  20  HISTORY:      04/04/2003   initial release
  21                06/30/2003   (RD) replaced istrstream with istringstream
  22                             to get rid of the annoying warning about
  23                             using the strstream header
  24
  25 ----------------------------------------------------------------------
  26
  27  AUTHOR(S):    Robert Deters      <rdeters@uiuc.edu>
  28                Michael Selig      <m-selig@uiuc.edu>
  29
  30 ----------------------------------------------------------------------
  31
  32  VARIABLES:
  33
  34 ----------------------------------------------------------------------
  35
  36  INPUTS:       n/a
  37
  38 ----------------------------------------------------------------------
  39
  40  OUTPUTS:      n/a
  41
  42 ----------------------------------------------------------------------
  43
  44  CALLED BY:    uiuc_menu()
  45
  46 ----------------------------------------------------------------------
  47
  48  CALLS TO:     check_float() if needed
  49                d_2_to_3() if needed
  50                d_1_to_2() if needed
  51                i_1_to_2() if needed
  52                d_1_to_1() if needed
  53
  54  ----------------------------------------------------------------------
  55
  56  COPYRIGHT:    (C) 2003 by Michael Selig
  57
  58  This program is free software; you can redistribute it and/or
  59  modify it under the terms of the GNU General Public License
  60  as published by the Free Software Foundation.
  61
  62  This program is distributed in the hope that it will be useful,
  63  but WITHOUT ANY WARRANTY; without even the implied warranty of
  64  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  65  GNU General Public License for more details.
  66
  67  You should have received a copy of the GNU General Public License
  68  along with this program; if not, write to the Free Software
  69  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  70
  71 **********************************************************************/
  72
  73 #include <simgear/compiler.h>
  74
  75
  76 #include <cstdlib>
  77 #include <string>
  78 #include <iostream>
  79
  80 #include "uiuc_menu_CY.h"
  81
  82 using std::cerr;
  83 using std::cout;
  84 using std::endl;
  85
  86 #ifndef _MSC_VER
  87 using std::exit;
  88 #endif
  89
  90 void parse_CY( const string& linetoken2, const string& linetoken3,
  91                const string& linetoken4, const string& linetoken5,
  92                const string& linetoken6, const string& linetoken7,
  93                const string& linetoken8, const string& linetoken9,
  94                const string& linetoken10, const string& aircraft_directory,
  95                LIST command_line ) {
  96     double token_value;
  97     int token_value_convert1, token_value_convert2, token_value_convert3;
  98     int token_value_convert4;
  99     double datafile_xArray[100][100], datafile_yArray[100];
 100     double datafile_zArray[100][100];
 101     double convert_f;
 102     int datafile_nxArray[100], datafile_ny;
 103     istringstream token3(linetoken3.c_str());
 104     istringstream token4(linetoken4.c_str());
 105     istringstream token5(linetoken5.c_str());
 106     istringstream token6(linetoken6.c_str());
 107     istringstream token7(linetoken7.c_str());
 108     istringstream token8(linetoken8.c_str());
 109     istringstream token9(linetoken9.c_str());
 110     istringstream token10(linetoken10.c_str());
 111
 112     static bool CYfabetaf_first = true;
 113     static bool CYfadaf_first = true;
 114     static bool CYfadrf_first = true;
 115     static bool CYfapf_first = true;
 116     static bool CYfarf_first = true;
 117
 118     switch(CY_map[linetoken2])
 119       {
 120       case CYo_flag:
 121         {
 122           if (check_float(linetoken3))
 123             token3 >> token_value;
 124           else
 125             uiuc_warnings_errors(1, *command_line);
 126
 127           CYo = token_value;
 128           CYo_clean = CYo;
 129           aeroSideforceParts -> storeCommands (*command_line);
 130           break;
 131         }
 132       case CY_beta_flag:
 133         {
 134           if (check_float(linetoken3))
 135             token3 >> token_value;
 136           else
 137             uiuc_warnings_errors(1, *command_line);
 138
 139           CY_beta = token_value;
 140           CY_beta_clean = CY_beta;
 141           aeroSideforceParts -> storeCommands (*command_line);
 142           break;
 143         }
 144       case CY_p_flag:
 145         {
 146           if (check_float(linetoken3))
 147             token3 >> token_value;
 148           else
 149             uiuc_warnings_errors(1, *command_line);
 150
 151           CY_p = token_value;
 152           CY_p_clean = CY_p;
 153           aeroSideforceParts -> storeCommands (*command_line);
 154           break;
 155         }
 156       case CY_r_flag:
 157         {
 158           if (check_float(linetoken3))
 159             token3 >> token_value;
 160           else
 161             uiuc_warnings_errors(1, *command_line);
 162
 163           CY_r = token_value;
 164           CY_r_clean = CY_r;
 165           aeroSideforceParts -> storeCommands (*command_line);
 166           break;
 167         }
 168       case CY_da_flag:
 169         {
 170           if (check_float(linetoken3))
 171             token3 >> token_value;
 172           else
 173             uiuc_warnings_errors(1, *command_line);
 174
 175           CY_da = token_value;
 176           CY_da_clean = CY_da;
 177           aeroSideforceParts -> storeCommands (*command_line);
 178           break;
 179         }
 180       case CY_dr_flag:
 181         {
 182           if (check_float(linetoken3))
 183             token3 >> token_value;
 184           else
 185             uiuc_warnings_errors(2, *command_line);
 186
 187           CY_dr = token_value;
 188           CY_dr_clean = CY_dr;
 189           aeroSideforceParts -> storeCommands (*command_line);
 190           break;
 191         }
 192       case CY_dra_flag:
 193         {
 194           if (check_float(linetoken3))
 195             token3 >> token_value;
 196           else
 197             uiuc_warnings_errors(2, *command_line);
 198
 199           CY_dra = token_value;
 200           CY_dra_clean = CY_dra;
 201           aeroSideforceParts -> storeCommands (*command_line);
 202           break;
 203         }
 204       case CY_bdot_flag:
 205         {
 206           if (check_float(linetoken3))
 207             token3 >> token_value;
 208           else
 209             uiuc_warnings_errors(2, *command_line);
 210
 211           CY_bdot = token_value;
 212           CY_bdot_clean = CY_bdot;
 213           aeroSideforceParts -> storeCommands (*command_line);
 214           break;
 215         }
 216       case CYfada_flag:
 217         {
 218           CYfada = aircraft_directory + linetoken3;
 219           token4 >> token_value_convert1;
 220           token5 >> token_value_convert2;
 221           token6 >> token_value_convert3;
 222           convert_z = uiuc_convert(token_value_convert1);
 223           convert_x = uiuc_convert(token_value_convert2);
 224           convert_y = uiuc_convert(token_value_convert3);
 225           /* call 2D File Reader with file name (CYfada) and
 226              conversion factors; function returns array of
 227              aileron deflections (daArray) and corresponding
 228              alpha (aArray) and delta CY (CYArray) values and
 229              max number of terms in alpha arrays (nAlphaArray)
 230              and deflection array (nda) */
 231           uiuc_2DdataFileReader(CYfada,
 232                                 CYfada_aArray,
 233                                 CYfada_daArray,
 234                                 CYfada_CYArray,
 235                                 CYfada_nAlphaArray,
 236                                 CYfada_nda);
 237           aeroSideforceParts -> storeCommands (*command_line);
 238           break;
 239         }
 240       case CYfbetadr_flag:
 241         {
 242           CYfbetadr = aircraft_directory + linetoken3;
 243           token4 >> token_value_convert1;
 244           token5 >> token_value_convert2;
 245           token6 >> token_value_convert3;
 246           convert_z = uiuc_convert(token_value_convert1);
 247           convert_x = uiuc_convert(token_value_convert2);
 248           convert_y = uiuc_convert(token_value_convert3);
 249           /* call 2D File Reader with file name (CYfbetadr) and
 250              conversion factors; function returns array of
 251              rudder deflections (drArray) and corresponding
 252              beta (betaArray) and delta CY (CYArray) values and
 253              max number of terms in beta arrays (nBetaArray)
 254              and deflection array (ndr) */
 255           uiuc_2DdataFileReader(CYfbetadr,
 256                                 CYfbetadr_betaArray,
 257                                 CYfbetadr_drArray,
 258                                 CYfbetadr_CYArray,
 259                                 CYfbetadr_nBetaArray,
 260                                 CYfbetadr_ndr);
 261           aeroSideforceParts -> storeCommands (*command_line);
 262           break;
 263         }
 264       case CYfabetaf_flag:
 265         {
 266           int CYfabetaf_index, i;
 267           string CYfabetaf_file;
 268           double flap_value;
 269           CYfabetaf_file = aircraft_directory + linetoken3;
 270           token4 >> CYfabetaf_index;
 271           if (CYfabetaf_index < 0 || CYfabetaf_index >= 30)
 272             uiuc_warnings_errors(1, *command_line);
 273           if (CYfabetaf_index > CYfabetaf_nf)
 274             CYfabetaf_nf = CYfabetaf_index;
 275           token5 >> flap_value;
 276           token6 >> token_value_convert1;
 277           token7 >> token_value_convert2;
 278           token8 >> token_value_convert3;
 279           token9 >> token_value_convert4;
 280           token10 >> CYfabetaf_nice;
 281           convert_z = uiuc_convert(token_value_convert1);
 282           convert_x = uiuc_convert(token_value_convert2);
 283           convert_y = uiuc_convert(token_value_convert3);
 284           convert_f = uiuc_convert(token_value_convert4);
 285           CYfabetaf_fArray[CYfabetaf_index] = flap_value * convert_f;
 286           /* call 2D File Reader with file name (CYfabetaf_file) and
 287              conversion factors; function returns array of
 288              elevator deflections (deArray) and corresponding
 289              alpha (aArray) and delta CZ (CZArray) values and
 290              max number of terms in alpha arrays (nAlphaArray)
 291              and delfection array (nde) */
 292           uiuc_2DdataFileReader(CYfabetaf_file,
 293                                 datafile_xArray,
 294                                 datafile_yArray,
 295                                 datafile_zArray,
 296                                 datafile_nxArray,
 297                                 datafile_ny);
 298           d_2_to_3(datafile_xArray, CYfabetaf_aArray, CYfabetaf_index);
 299           d_1_to_2(datafile_yArray, CYfabetaf_betaArray, CYfabetaf_index);
 300           d_2_to_3(datafile_zArray, CYfabetaf_CYArray, CYfabetaf_index);
 301           i_1_to_2(datafile_nxArray, CYfabetaf_nAlphaArray, CYfabetaf_index);
 302           CYfabetaf_nbeta[CYfabetaf_index] = datafile_ny;
 303           if (CYfabetaf_first==true)
 304             {
 305               if (CYfabetaf_nice == 1)
 306                 {
 307                   CYfabetaf_na_nice = datafile_nxArray[1];
 308                   CYfabetaf_nb_nice = datafile_ny;
 309                   d_1_to_1(datafile_yArray, CYfabetaf_bArray_nice);
 310                   for (i=1; i<=CYfabetaf_na_nice; i++)
 311                     CYfabetaf_aArray_nice[i] = datafile_xArray[1][i];
 312                 }
 313               aeroSideforceParts -> storeCommands (*command_line);
 314               CYfabetaf_first=false;
 315             }
 316           break;
 317         }
 318       case CYfadaf_flag:
 319         {
 320           int CYfadaf_index, i;
 321           string CYfadaf_file;
 322           double flap_value;
 323           CYfadaf_file = aircraft_directory + linetoken3;
 324           token4 >> CYfadaf_index;
 325           if (CYfadaf_index < 0 || CYfadaf_index >= 30)
 326             uiuc_warnings_errors(1, *command_line);
 327           if (CYfadaf_index > CYfadaf_nf)
 328             CYfadaf_nf = CYfadaf_index;
 329           token5 >> flap_value;
 330           token6 >> token_value_convert1;
 331           token7 >> token_value_convert2;
 332           token8 >> token_value_convert3;
 333           token9 >> token_value_convert4;
 334           token10 >> CYfadaf_nice;
 335           convert_z = uiuc_convert(token_value_convert1);
 336           convert_x = uiuc_convert(token_value_convert2);
 337           convert_y = uiuc_convert(token_value_convert3);
 338           convert_f = uiuc_convert(token_value_convert4);
 339           CYfadaf_fArray[CYfadaf_index] = flap_value * convert_f;
 340           /* call 2D File Reader with file name (CYfadaf_file) and
 341              conversion factors; function returns array of
 342              elevator deflections (deArray) and corresponding
 343              alpha (aArray) and delta CZ (CZArray) values and
 344              max number of terms in alpha arrays (nAlphaArray)
 345              and delfection array (nde) */
 346           uiuc_2DdataFileReader(CYfadaf_file,
 347                                 datafile_xArray,
 348                                 datafile_yArray,
 349                                 datafile_zArray,
 350                                 datafile_nxArray,
 351                                 datafile_ny);
 352           d_2_to_3(datafile_xArray, CYfadaf_aArray, CYfadaf_index);
 353           d_1_to_2(datafile_yArray, CYfadaf_daArray, CYfadaf_index);
 354           d_2_to_3(datafile_zArray, CYfadaf_CYArray, CYfadaf_index);
 355           i_1_to_2(datafile_nxArray, CYfadaf_nAlphaArray, CYfadaf_index);
 356           CYfadaf_nda[CYfadaf_index] = datafile_ny;
 357           if (CYfadaf_first==true)
 358             {
 359               if (CYfadaf_nice == 1)
 360                 {
 361                   CYfadaf_na_nice = datafile_nxArray[1];
 362                   CYfadaf_nda_nice = datafile_ny;
 363                   d_1_to_1(datafile_yArray, CYfadaf_daArray_nice);
 364                   for (i=1; i<=CYfadaf_na_nice; i++)
 365                     CYfadaf_aArray_nice[i] = datafile_xArray[1][i];
 366                 }
 367               aeroSideforceParts -> storeCommands (*command_line);
 368               CYfadaf_first=false;
 369             }
 370           break;
 371         }
 372       case CYfadrf_flag:
 373         {
 374           int CYfadrf_index, i;
 375           string CYfadrf_file;
 376           double flap_value;
 377           CYfadrf_file = aircraft_directory + linetoken3;
 378           token4 >> CYfadrf_index;
 379           if (CYfadrf_index < 0 || CYfadrf_index >= 30)
 380             uiuc_warnings_errors(1, *command_line);
 381           if (CYfadrf_index > CYfadrf_nf)
 382             CYfadrf_nf = CYfadrf_index;
 383           token5 >> flap_value;
 384           token6 >> token_value_convert1;
 385           token7 >> token_value_convert2;
 386           token8 >> token_value_convert3;
 387           token9 >> token_value_convert4;
 388           token10 >> CYfadrf_nice;
 389           convert_z = uiuc_convert(token_value_convert1);
 390           convert_x = uiuc_convert(token_value_convert2);
 391           convert_y = uiuc_convert(token_value_convert3);
 392           convert_f = uiuc_convert(token_value_convert4);
 393           CYfadrf_fArray[CYfadrf_index] = flap_value * convert_f;
 394           /* call 2D File Reader with file name (CYfadrf_file) and
 395              conversion factors; function returns array of
 396              elevator deflections (deArray) and corresponding
 397              alpha (aArray) and delta CZ (CZArray) values and
 398              max number of terms in alpha arrays (nAlphaArray)
 399              and delfection array (nde) */
 400           uiuc_2DdataFileReader(CYfadrf_file,
 401                                 datafile_xArray,
 402                                 datafile_yArray,
 403                                 datafile_zArray,
 404                                 datafile_nxArray,
 405                                 datafile_ny);
 406           d_2_to_3(datafile_xArray, CYfadrf_aArray, CYfadrf_index);
 407           d_1_to_2(datafile_yArray, CYfadrf_drArray, CYfadrf_index);
 408           d_2_to_3(datafile_zArray, CYfadrf_CYArray, CYfadrf_index);
 409           i_1_to_2(datafile_nxArray, CYfadrf_nAlphaArray, CYfadrf_index);
 410           CYfadrf_ndr[CYfadrf_index] = datafile_ny;
 411           if (CYfadrf_first==true)
 412             {
 413               if (CYfadrf_nice == 1)
 414                 {
 415                   CYfadrf_na_nice = datafile_nxArray[1];
 416                   CYfadrf_ndr_nice = datafile_ny;
 417                   d_1_to_1(datafile_yArray, CYfadrf_drArray_nice);
 418                   for (i=1; i<=CYfadrf_na_nice; i++)
 419                     CYfadrf_aArray_nice[i] = datafile_xArray[1][i];
 420                 }
 421               aeroSideforceParts -> storeCommands (*command_line);
 422               CYfadrf_first=false;
 423             }
 424           break;
 425         }
 426       case CYfapf_flag:
 427         {
 428           int CYfapf_index, i;
 429           string CYfapf_file;
 430           double flap_value;
 431           CYfapf_file = aircraft_directory + linetoken3;
 432           token4 >> CYfapf_index;
 433           if (CYfapf_index < 0 || CYfapf_index >= 30)
 434             uiuc_warnings_errors(1, *command_line);
 435           if (CYfapf_index > CYfapf_nf)
 436             CYfapf_nf = CYfapf_index;
 437           token5 >> flap_value;
 438           token6 >> token_value_convert1;
 439           token7 >> token_value_convert2;
 440           token8 >> token_value_convert3;
 441           token9 >> token_value_convert4;
 442           token10 >> CYfapf_nice;
 443           convert_z = uiuc_convert(token_value_convert1);
 444           convert_x = uiuc_convert(token_value_convert2);
 445           convert_y = uiuc_convert(token_value_convert3);
 446           convert_f = uiuc_convert(token_value_convert4);
 447           CYfapf_fArray[CYfapf_index] = flap_value * convert_f;
 448           /* call 2D File Reader with file name (CYfapf_file) and
 449              conversion factors; function returns array of
 450              elevator deflections (deArray) and corresponding
 451              alpha (aArray) and delta CZ (CZArray) values and
 452              max number of terms in alpha arrays (nAlphaArray)
 453              and delfection array (nde) */
 454           uiuc_2DdataFileReader(CYfapf_file,
 455                                 datafile_xArray,
 456                                 datafile_yArray,
 457                                 datafile_zArray,
 458                                 datafile_nxArray,
 459                                 datafile_ny);
 460           d_2_to_3(datafile_xArray, CYfapf_aArray, CYfapf_index);
 461           d_1_to_2(datafile_yArray, CYfapf_pArray, CYfapf_index);
 462           d_2_to_3(datafile_zArray, CYfapf_CYArray, CYfapf_index);
 463           i_1_to_2(datafile_nxArray, CYfapf_nAlphaArray, CYfapf_index);
 464           CYfapf_np[CYfapf_index] = datafile_ny;
 465           if (CYfapf_first==true)
 466             {
 467               if (CYfapf_nice == 1)
 468                 {
 469                   CYfapf_na_nice = datafile_nxArray[1];
 470                   CYfapf_np_nice = datafile_ny;
 471                   d_1_to_1(datafile_yArray, CYfapf_pArray_nice);
 472                   for (i=1; i<=CYfapf_na_nice; i++)
 473                     CYfapf_aArray_nice[i] = datafile_xArray[1][i];
 474                 }
 475               aeroSideforceParts -> storeCommands (*command_line);
 476               CYfapf_first=false;
 477             }
 478           break;
 479         }
 480       case CYfarf_flag:
 481         {
 482           int CYfarf_index, i;
 483           string CYfarf_file;
 484           double flap_value;
 485           CYfarf_file = aircraft_directory + linetoken3;
 486           token4 >> CYfarf_index;
 487           if (CYfarf_index < 0 || CYfarf_index >= 30)
 488             uiuc_warnings_errors(1, *command_line);
 489           if (CYfarf_index > CYfarf_nf)
 490             CYfarf_nf = CYfarf_index;
 491           token5 >> flap_value;
 492           token6 >> token_value_convert1;
 493           token7 >> token_value_convert2;
 494           token8 >> token_value_convert3;
 495           token9 >> token_value_convert4;
 496           token10 >> CYfarf_nice;
 497           convert_z = uiuc_convert(token_value_convert1);
 498           convert_x = uiuc_convert(token_value_convert2);
 499           convert_y = uiuc_convert(token_value_convert3);
 500           convert_f = uiuc_convert(token_value_convert4);
 501           CYfarf_fArray[CYfarf_index] = flap_value * convert_f;
 502           /* call 2D File Reader with file name (CYfarf_file) and
 503              conversion factors; function returns array of
 504              elevator deflections (deArray) and corresponding
 505              alpha (aArray) and delta CZ (CZArray) values and
 506              max number of terms in alpha arrays (nAlphaArray)
 507              and delfection array (nde) */
 508           uiuc_2DdataFileReader(CYfarf_file,
 509                                 datafile_xArray,
 510                                 datafile_yArray,
 511                                 datafile_zArray,
 512                                 datafile_nxArray,
 513                                 datafile_ny);
 514           d_2_to_3(datafile_xArray, CYfarf_aArray, CYfarf_index);
 515           d_1_to_2(datafile_yArray, CYfarf_rArray, CYfarf_index);
 516           d_2_to_3(datafile_zArray, CYfarf_CYArray, CYfarf_index);
 517           i_1_to_2(datafile_nxArray, CYfarf_nAlphaArray, CYfarf_index);
 518           CYfarf_nr[CYfarf_index] = datafile_ny;
 519           if (CYfarf_first==true)
 520             {
 521               if (CYfarf_nice == 1)
 522                 {
 523                   CYfarf_na_nice = datafile_nxArray[1];
 524                   CYfarf_nr_nice = datafile_ny;
 525                   d_1_to_1(datafile_yArray, CYfarf_rArray_nice);
 526                   for (i=1; i<=CYfarf_na_nice; i++)
 527                     CYfarf_aArray_nice[i] = datafile_xArray[1][i];
 528                 }
 529               aeroSideforceParts -> storeCommands (*command_line);
 530               CYfarf_first=false;
 531             }
 532           break;
 533         }
 534       default:
 535         {
 536           if (ignore_unknown_keywords) {
 537             // do nothing
 538           } else {
 539             // print error message
 540             uiuc_warnings_errors(2, *command_line);
 541           }
 542           break;
 543         }
 544       };
 545 }