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