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., 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_CY.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_CY( 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 CYfabetaf_first = true;
 119     static bool CYfadaf_first = true;
 120     static bool CYfadrf_first = true;
 121     static bool CYfapf_first = true;
 122     static bool CYfarf_first = true;
 123
 124     switch(CY_map[linetoken2])
 125       {
 126       case CYo_flag:
 127         {
 128           if (check_float(linetoken3))
 129             token3 >> token_value;
 130           else
 131             uiuc_warnings_errors(1, *command_line);
 132
 133           CYo = token_value;
 134           CYo_clean = CYo;
 135           aeroSideforceParts -> storeCommands (*command_line);
 136           break;
 137         }
 138       case CY_beta_flag:
 139         {
 140           if (check_float(linetoken3))
 141             token3 >> token_value;
 142           else
 143             uiuc_warnings_errors(1, *command_line);
 144
 145           CY_beta = token_value;
 146           CY_beta_clean = CY_beta;
 147           aeroSideforceParts -> storeCommands (*command_line);
 148           break;
 149         }
 150       case CY_p_flag:
 151         {
 152           if (check_float(linetoken3))
 153             token3 >> token_value;
 154           else
 155             uiuc_warnings_errors(1, *command_line);
 156
 157           CY_p = token_value;
 158           CY_p_clean = CY_p;
 159           aeroSideforceParts -> storeCommands (*command_line);
 160           break;
 161         }
 162       case CY_r_flag:
 163         {
 164           if (check_float(linetoken3))
 165             token3 >> token_value;
 166           else
 167             uiuc_warnings_errors(1, *command_line);
 168
 169           CY_r = token_value;
 170           CY_r_clean = CY_r;
 171           aeroSideforceParts -> storeCommands (*command_line);
 172           break;
 173         }
 174       case CY_da_flag:
 175         {
 176           if (check_float(linetoken3))
 177             token3 >> token_value;
 178           else
 179             uiuc_warnings_errors(1, *command_line);
 180
 181           CY_da = token_value;
 182           CY_da_clean = CY_da;
 183           aeroSideforceParts -> storeCommands (*command_line);
 184           break;
 185         }
 186       case CY_dr_flag:
 187         {
 188           if (check_float(linetoken3))
 189             token3 >> token_value;
 190           else
 191             uiuc_warnings_errors(2, *command_line);
 192
 193           CY_dr = token_value;
 194           CY_dr_clean = CY_dr;
 195           aeroSideforceParts -> storeCommands (*command_line);
 196           break;
 197         }
 198       case CY_dra_flag:
 199         {
 200           if (check_float(linetoken3))
 201             token3 >> token_value;
 202           else
 203             uiuc_warnings_errors(2, *command_line);
 204
 205           CY_dra = token_value;
 206           CY_dra_clean = CY_dra;
 207           aeroSideforceParts -> storeCommands (*command_line);
 208           break;
 209         }
 210       case CY_bdot_flag:
 211         {
 212           if (check_float(linetoken3))
 213             token3 >> token_value;
 214           else
 215             uiuc_warnings_errors(2, *command_line);
 216
 217           CY_bdot = token_value;
 218           CY_bdot_clean = CY_bdot;
 219           aeroSideforceParts -> storeCommands (*command_line);
 220           break;
 221         }
 222       case CYfada_flag:
 223         {
 224           CYfada = aircraft_directory + linetoken3;
 225           token4 >> token_value_convert1;
 226           token5 >> token_value_convert2;
 227           token6 >> token_value_convert3;
 228           convert_z = uiuc_convert(token_value_convert1);
 229           convert_x = uiuc_convert(token_value_convert2);
 230           convert_y = uiuc_convert(token_value_convert3);
 231           /* call 2D File Reader with file name (CYfada) and
 232              conversion factors; function returns array of
 233              aileron deflections (daArray) and corresponding
 234              alpha (aArray) and delta CY (CYArray) values and
 235              max number of terms in alpha arrays (nAlphaArray)
 236              and deflection array (nda) */
 237           uiuc_2DdataFileReader(CYfada,
 238                                 CYfada_aArray,
 239                                 CYfada_daArray,
 240                                 CYfada_CYArray,
 241                                 CYfada_nAlphaArray,
 242                                 CYfada_nda);
 243           aeroSideforceParts -> storeCommands (*command_line);
 244           break;
 245         }
 246       case CYfbetadr_flag:
 247         {
 248           CYfbetadr = aircraft_directory + linetoken3;
 249           token4 >> token_value_convert1;
 250           token5 >> token_value_convert2;
 251           token6 >> token_value_convert3;
 252           convert_z = uiuc_convert(token_value_convert1);
 253           convert_x = uiuc_convert(token_value_convert2);
 254           convert_y = uiuc_convert(token_value_convert3);
 255           /* call 2D File Reader with file name (CYfbetadr) and
 256              conversion factors; function returns array of
 257              rudder deflections (drArray) and corresponding
 258              beta (betaArray) and delta CY (CYArray) values and
 259              max number of terms in beta arrays (nBetaArray)
 260              and deflection array (ndr) */
 261           uiuc_2DdataFileReader(CYfbetadr,
 262                                 CYfbetadr_betaArray,
 263                                 CYfbetadr_drArray,
 264                                 CYfbetadr_CYArray,
 265                                 CYfbetadr_nBetaArray,
 266                                 CYfbetadr_ndr);
 267           aeroSideforceParts -> storeCommands (*command_line);
 268           break;
 269         }
 270       case CYfabetaf_flag:
 271         {
 272           int CYfabetaf_index, i;
 273           string CYfabetaf_file;
 274           double flap_value;
 275           CYfabetaf_file = aircraft_directory + linetoken3;
 276           token4 >> CYfabetaf_index;
 277           if (CYfabetaf_index < 0 || CYfabetaf_index >= 30)
 278             uiuc_warnings_errors(1, *command_line);
 279           if (CYfabetaf_index > CYfabetaf_nf)
 280             CYfabetaf_nf = CYfabetaf_index;
 281           token5 >> flap_value;
 282           token6 >> token_value_convert1;
 283           token7 >> token_value_convert2;
 284           token8 >> token_value_convert3;
 285           token9 >> token_value_convert4;
 286           token10 >> CYfabetaf_nice;
 287           convert_z = uiuc_convert(token_value_convert1);
 288           convert_x = uiuc_convert(token_value_convert2);
 289           convert_y = uiuc_convert(token_value_convert3);
 290           convert_f = uiuc_convert(token_value_convert4);
 291           CYfabetaf_fArray[CYfabetaf_index] = flap_value * convert_f;
 292           /* call 2D File Reader with file name (CYfabetaf_file) and
 293              conversion factors; function returns array of
 294              elevator deflections (deArray) and corresponding
 295              alpha (aArray) and delta CZ (CZArray) values and
 296              max number of terms in alpha arrays (nAlphaArray)
 297              and delfection array (nde) */
 298           uiuc_2DdataFileReader(CYfabetaf_file,
 299                                 datafile_xArray,
 300                                 datafile_yArray,
 301                                 datafile_zArray,
 302                                 datafile_nxArray,
 303                                 datafile_ny);
 304           d_2_to_3(datafile_xArray, CYfabetaf_aArray, CYfabetaf_index);
 305           d_1_to_2(datafile_yArray, CYfabetaf_betaArray, CYfabetaf_index);
 306           d_2_to_3(datafile_zArray, CYfabetaf_CYArray, CYfabetaf_index);
 307           i_1_to_2(datafile_nxArray, CYfabetaf_nAlphaArray, CYfabetaf_index);
 308           CYfabetaf_nbeta[CYfabetaf_index] = datafile_ny;
 309           if (CYfabetaf_first==true)
 310             {
 311               if (CYfabetaf_nice == 1)
 312                 {
 313                   CYfabetaf_na_nice = datafile_nxArray[1];
 314                   CYfabetaf_nb_nice = datafile_ny;
 315                   d_1_to_1(datafile_yArray, CYfabetaf_bArray_nice);
 316                   for (i=1; i<=CYfabetaf_na_nice; i++)
 317                     CYfabetaf_aArray_nice[i] = datafile_xArray[1][i];
 318                 }
 319               aeroSideforceParts -> storeCommands (*command_line);
 320               CYfabetaf_first=false;
 321             }
 322           break;
 323         }
 324       case CYfadaf_flag:
 325         {
 326           int CYfadaf_index, i;
 327           string CYfadaf_file;
 328           double flap_value;
 329           CYfadaf_file = aircraft_directory + linetoken3;
 330           token4 >> CYfadaf_index;
 331           if (CYfadaf_index < 0 || CYfadaf_index >= 30)
 332             uiuc_warnings_errors(1, *command_line);
 333           if (CYfadaf_index > CYfadaf_nf)
 334             CYfadaf_nf = CYfadaf_index;
 335           token5 >> flap_value;
 336           token6 >> token_value_convert1;
 337           token7 >> token_value_convert2;
 338           token8 >> token_value_convert3;
 339           token9 >> token_value_convert4;
 340           token10 >> CYfadaf_nice;
 341           convert_z = uiuc_convert(token_value_convert1);
 342           convert_x = uiuc_convert(token_value_convert2);
 343           convert_y = uiuc_convert(token_value_convert3);
 344           convert_f = uiuc_convert(token_value_convert4);
 345           CYfadaf_fArray[CYfadaf_index] = flap_value * convert_f;
 346           /* call 2D File Reader with file name (CYfadaf_file) and
 347              conversion factors; function returns array of
 348              elevator deflections (deArray) and corresponding
 349              alpha (aArray) and delta CZ (CZArray) values and
 350              max number of terms in alpha arrays (nAlphaArray)
 351              and delfection array (nde) */
 352           uiuc_2DdataFileReader(CYfadaf_file,
 353                                 datafile_xArray,
 354                                 datafile_yArray,
 355                                 datafile_zArray,
 356                                 datafile_nxArray,
 357                                 datafile_ny);
 358           d_2_to_3(datafile_xArray, CYfadaf_aArray, CYfadaf_index);
 359           d_1_to_2(datafile_yArray, CYfadaf_daArray, CYfadaf_index);
 360           d_2_to_3(datafile_zArray, CYfadaf_CYArray, CYfadaf_index);
 361           i_1_to_2(datafile_nxArray, CYfadaf_nAlphaArray, CYfadaf_index);
 362           CYfadaf_nda[CYfadaf_index] = datafile_ny;
 363           if (CYfadaf_first==true)
 364             {
 365               if (CYfadaf_nice == 1)
 366                 {
 367                   CYfadaf_na_nice = datafile_nxArray[1];
 368                   CYfadaf_nda_nice = datafile_ny;
 369                   d_1_to_1(datafile_yArray, CYfadaf_daArray_nice);
 370                   for (i=1; i<=CYfadaf_na_nice; i++)
 371                     CYfadaf_aArray_nice[i] = datafile_xArray[1][i];
 372                 }
 373               aeroSideforceParts -> storeCommands (*command_line);
 374               CYfadaf_first=false;
 375             }
 376           break;
 377         }
 378       case CYfadrf_flag:
 379         {
 380           int CYfadrf_index, i;
 381           string CYfadrf_file;
 382           double flap_value;
 383           CYfadrf_file = aircraft_directory + linetoken3;
 384           token4 >> CYfadrf_index;
 385           if (CYfadrf_index < 0 || CYfadrf_index >= 30)
 386             uiuc_warnings_errors(1, *command_line);
 387           if (CYfadrf_index > CYfadrf_nf)
 388             CYfadrf_nf = CYfadrf_index;
 389           token5 >> flap_value;
 390           token6 >> token_value_convert1;
 391           token7 >> token_value_convert2;
 392           token8 >> token_value_convert3;
 393           token9 >> token_value_convert4;
 394           token10 >> CYfadrf_nice;
 395           convert_z = uiuc_convert(token_value_convert1);
 396           convert_x = uiuc_convert(token_value_convert2);
 397           convert_y = uiuc_convert(token_value_convert3);
 398           convert_f = uiuc_convert(token_value_convert4);
 399           CYfadrf_fArray[CYfadrf_index] = flap_value * convert_f;
 400           /* call 2D File Reader with file name (CYfadrf_file) and
 401              conversion factors; function returns array of
 402              elevator deflections (deArray) and corresponding
 403              alpha (aArray) and delta CZ (CZArray) values and
 404              max number of terms in alpha arrays (nAlphaArray)
 405              and delfection array (nde) */
 406           uiuc_2DdataFileReader(CYfadrf_file,
 407                                 datafile_xArray,
 408                                 datafile_yArray,
 409                                 datafile_zArray,
 410                                 datafile_nxArray,
 411                                 datafile_ny);
 412           d_2_to_3(datafile_xArray, CYfadrf_aArray, CYfadrf_index);
 413           d_1_to_2(datafile_yArray, CYfadrf_drArray, CYfadrf_index);
 414           d_2_to_3(datafile_zArray, CYfadrf_CYArray, CYfadrf_index);
 415           i_1_to_2(datafile_nxArray, CYfadrf_nAlphaArray, CYfadrf_index);
 416           CYfadrf_ndr[CYfadrf_index] = datafile_ny;
 417           if (CYfadrf_first==true)
 418             {
 419               if (CYfadrf_nice == 1)
 420                 {
 421                   CYfadrf_na_nice = datafile_nxArray[1];
 422                   CYfadrf_ndr_nice = datafile_ny;
 423                   d_1_to_1(datafile_yArray, CYfadrf_drArray_nice);
 424                   for (i=1; i<=CYfadrf_na_nice; i++)
 425                     CYfadrf_aArray_nice[i] = datafile_xArray[1][i];
 426                 }
 427               aeroSideforceParts -> storeCommands (*command_line);
 428               CYfadrf_first=false;
 429             }
 430           break;
 431         }
 432       case CYfapf_flag:
 433         {
 434           int CYfapf_index, i;
 435           string CYfapf_file;
 436           double flap_value;
 437           CYfapf_file = aircraft_directory + linetoken3;
 438           token4 >> CYfapf_index;
 439           if (CYfapf_index < 0 || CYfapf_index >= 30)
 440             uiuc_warnings_errors(1, *command_line);
 441           if (CYfapf_index > CYfapf_nf)
 442             CYfapf_nf = CYfapf_index;
 443           token5 >> flap_value;
 444           token6 >> token_value_convert1;
 445           token7 >> token_value_convert2;
 446           token8 >> token_value_convert3;
 447           token9 >> token_value_convert4;
 448           token10 >> CYfapf_nice;
 449           convert_z = uiuc_convert(token_value_convert1);
 450           convert_x = uiuc_convert(token_value_convert2);
 451           convert_y = uiuc_convert(token_value_convert3);
 452           convert_f = uiuc_convert(token_value_convert4);
 453           CYfapf_fArray[CYfapf_index] = flap_value * convert_f;
 454           /* call 2D File Reader with file name (CYfapf_file) and
 455              conversion factors; function returns array of
 456              elevator deflections (deArray) and corresponding
 457              alpha (aArray) and delta CZ (CZArray) values and
 458              max number of terms in alpha arrays (nAlphaArray)
 459              and delfection array (nde) */
 460           uiuc_2DdataFileReader(CYfapf_file,
 461                                 datafile_xArray,
 462                                 datafile_yArray,
 463                                 datafile_zArray,
 464                                 datafile_nxArray,
 465                                 datafile_ny);
 466           d_2_to_3(datafile_xArray, CYfapf_aArray, CYfapf_index);
 467           d_1_to_2(datafile_yArray, CYfapf_pArray, CYfapf_index);
 468           d_2_to_3(datafile_zArray, CYfapf_CYArray, CYfapf_index);
 469           i_1_to_2(datafile_nxArray, CYfapf_nAlphaArray, CYfapf_index);
 470           CYfapf_np[CYfapf_index] = datafile_ny;
 471           if (CYfapf_first==true)
 472             {
 473               if (CYfapf_nice == 1)
 474                 {
 475                   CYfapf_na_nice = datafile_nxArray[1];
 476                   CYfapf_np_nice = datafile_ny;
 477                   d_1_to_1(datafile_yArray, CYfapf_pArray_nice);
 478                   for (i=1; i<=CYfapf_na_nice; i++)
 479                     CYfapf_aArray_nice[i] = datafile_xArray[1][i];
 480                 }
 481               aeroSideforceParts -> storeCommands (*command_line);
 482               CYfapf_first=false;
 483             }
 484           break;
 485         }
 486       case CYfarf_flag:
 487         {
 488           int CYfarf_index, i;
 489           string CYfarf_file;
 490           double flap_value;
 491           CYfarf_file = aircraft_directory + linetoken3;
 492           token4 >> CYfarf_index;
 493           if (CYfarf_index < 0 || CYfarf_index >= 30)
 494             uiuc_warnings_errors(1, *command_line);
 495           if (CYfarf_index > CYfarf_nf)
 496             CYfarf_nf = CYfarf_index;
 497           token5 >> flap_value;
 498           token6 >> token_value_convert1;
 499           token7 >> token_value_convert2;
 500           token8 >> token_value_convert3;
 501           token9 >> token_value_convert4;
 502           token10 >> CYfarf_nice;
 503           convert_z = uiuc_convert(token_value_convert1);
 504           convert_x = uiuc_convert(token_value_convert2);
 505           convert_y = uiuc_convert(token_value_convert3);
 506           convert_f = uiuc_convert(token_value_convert4);
 507           CYfarf_fArray[CYfarf_index] = flap_value * convert_f;
 508           /* call 2D File Reader with file name (CYfarf_file) and
 509              conversion factors; function returns array of
 510              elevator deflections (deArray) and corresponding
 511              alpha (aArray) and delta CZ (CZArray) values and
 512              max number of terms in alpha arrays (nAlphaArray)
 513              and delfection array (nde) */
 514           uiuc_2DdataFileReader(CYfarf_file,
 515                                 datafile_xArray,
 516                                 datafile_yArray,
 517                                 datafile_zArray,
 518                                 datafile_nxArray,
 519                                 datafile_ny);
 520           d_2_to_3(datafile_xArray, CYfarf_aArray, CYfarf_index);
 521           d_1_to_2(datafile_yArray, CYfarf_rArray, CYfarf_index);
 522           d_2_to_3(datafile_zArray, CYfarf_CYArray, CYfarf_index);
 523           i_1_to_2(datafile_nxArray, CYfarf_nAlphaArray, CYfarf_index);
 524           CYfarf_nr[CYfarf_index] = datafile_ny;
 525           if (CYfarf_first==true)
 526             {
 527               if (CYfarf_nice == 1)
 528                 {
 529                   CYfarf_na_nice = datafile_nxArray[1];
 530                   CYfarf_nr_nice = datafile_ny;
 531                   d_1_to_1(datafile_yArray, CYfarf_rArray_nice);
 532                   for (i=1; i<=CYfarf_na_nice; i++)
 533                     CYfarf_aArray_nice[i] = datafile_xArray[1][i];
 534                 }
 535               aeroSideforceParts -> storeCommands (*command_line);
 536               CYfarf_first=false;
 537             }
 538           break;
 539         }
 540       default:
 541         {
 542           if (ignore_unknown_keywords) {
 543             // do nothing
 544           } else {
 545             // print error message
 546             uiuc_warnings_errors(2, *command_line);
 547           }
 548           break;
 549         }
 550       };
 551 }