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