src/FDM/UIUCModel/uiuc_menu_Croll.cpp

   1 /**********************************************************************
   2
   3  FILENAME:     uiuc_menu_Croll.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_Croll.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_Cl( 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 Clfabetaf_first = true;
 113     static bool Clfadaf_first = true;
 114     static bool Clfadrf_first = true;
 115     static bool Clfapf_first = true;
 116     static bool Clfarf_first = true;
 117
 118     switch(Cl_map[linetoken2])
 119       {
 120       case Clo_flag:
 121         {
 122           if (check_float(linetoken3))
 123             token3 >> token_value;
 124           else
 125             uiuc_warnings_errors(1, *command_line);
 126
 127           Clo = token_value;
 128           Clo_clean = Clo;
 129           aeroRollParts -> storeCommands (*command_line);
 130           break;
 131         }
 132       case Cl_beta_flag:
 133         {
 134           if (check_float(linetoken3))
 135             token3 >> token_value;
 136           else
 137             uiuc_warnings_errors(1, *command_line);
 138
 139           Cl_beta = token_value;
 140           Cl_beta_clean = Cl_beta;
 141           aeroRollParts -> storeCommands (*command_line);
 142           break;
 143         }
 144       case Cl_p_flag:
 145         {
 146           if (check_float(linetoken3))
 147             token3 >> token_value;
 148           else
 149             uiuc_warnings_errors(1, *command_line);
 150
 151           Cl_p = token_value;
 152           Cl_p_clean = Cl_p;
 153           aeroRollParts -> storeCommands (*command_line);
 154           break;
 155         }
 156       case Cl_r_flag:
 157         {
 158           if (check_float(linetoken3))
 159             token3 >> token_value;
 160           else
 161             uiuc_warnings_errors(1, *command_line);
 162
 163           Cl_r = token_value;
 164           Cl_r_clean = Cl_r;
 165           aeroRollParts -> storeCommands (*command_line);
 166           break;
 167         }
 168       case Cl_da_flag:
 169         {
 170           if (check_float(linetoken3))
 171             token3 >> token_value;
 172           else
 173             uiuc_warnings_errors(1, *command_line);
 174
 175           Cl_da = token_value;
 176           Cl_da_clean = Cl_da;
 177           aeroRollParts -> storeCommands (*command_line);
 178           break;
 179         }
 180       case Cl_dr_flag:
 181         {
 182           if (check_float(linetoken3))
 183             token3 >> token_value;
 184           else
 185             uiuc_warnings_errors(1, *command_line);
 186
 187           Cl_dr = token_value;
 188           Cl_dr_clean = Cl_dr;
 189           aeroRollParts -> storeCommands (*command_line);
 190           break;
 191         }
 192       case Cl_daa_flag:
 193         {
 194           if (check_float(linetoken3))
 195             token3 >> token_value;
 196           else
 197             uiuc_warnings_errors(1, *command_line);
 198
 199           Cl_daa = token_value;
 200           Cl_daa_clean = Cl_daa;
 201           aeroRollParts -> storeCommands (*command_line);
 202           break;
 203         }
 204       case Clfada_flag:
 205         {
 206           Clfada = aircraft_directory + linetoken3;
 207           token4 >> token_value_convert1;
 208           token5 >> token_value_convert2;
 209           token6 >> token_value_convert3;
 210           convert_z = uiuc_convert(token_value_convert1);
 211           convert_x = uiuc_convert(token_value_convert2);
 212           convert_y = uiuc_convert(token_value_convert3);
 213           /* call 2D File Reader with file name (Clfada) and
 214              conversion factors; function returns array of
 215              aileron deflections (daArray) and corresponding
 216              alpha (aArray) and delta Cl (ClArray) values and
 217              max number of terms in alpha arrays (nAlphaArray)
 218              and deflection array (nda) */
 219           uiuc_2DdataFileReader(Clfada,
 220                                 Clfada_aArray,
 221                                 Clfada_daArray,
 222                                 Clfada_ClArray,
 223                                 Clfada_nAlphaArray,
 224                                 Clfada_nda);
 225           aeroRollParts -> storeCommands (*command_line);
 226           break;
 227         }
 228       case Clfbetadr_flag:
 229         {
 230           Clfbetadr = aircraft_directory + linetoken3;
 231           token4 >> token_value_convert1;
 232           token5 >> token_value_convert2;
 233           token6 >> token_value_convert3;
 234           convert_z = uiuc_convert(token_value_convert1);
 235           convert_x = uiuc_convert(token_value_convert2);
 236           convert_y = uiuc_convert(token_value_convert3);
 237           /* call 2D File Reader with file name (Clfbetadr) and
 238              conversion factors; function returns array of
 239              rudder deflections (drArray) and corresponding
 240              beta (betaArray) and delta Cl (ClArray) values and
 241              max number of terms in beta arrays (nBetaArray)
 242              and deflection array (ndr) */
 243           uiuc_2DdataFileReader(Clfbetadr,
 244                                 Clfbetadr_betaArray,
 245                                 Clfbetadr_drArray,
 246                                 Clfbetadr_ClArray,
 247                                 Clfbetadr_nBetaArray,
 248                                 Clfbetadr_ndr);
 249           aeroRollParts -> storeCommands (*command_line);
 250           break;
 251         }
 252       case Clfabetaf_flag:
 253         {
 254           int Clfabetaf_index, i;
 255           string Clfabetaf_file;
 256           double flap_value;
 257           Clfabetaf_file = aircraft_directory + linetoken3;
 258           token4 >> Clfabetaf_index;
 259           if (Clfabetaf_index < 0 || Clfabetaf_index >= 100)
 260             uiuc_warnings_errors(1, *command_line);
 261           if (Clfabetaf_index > Clfabetaf_nf)
 262             Clfabetaf_nf = Clfabetaf_index;
 263           token5 >> flap_value;
 264           token6 >> token_value_convert1;
 265           token7 >> token_value_convert2;
 266           token8 >> token_value_convert3;
 267           token9 >> token_value_convert4;
 268           token10 >> Clfabetaf_nice;
 269           convert_z = uiuc_convert(token_value_convert1);
 270           convert_x = uiuc_convert(token_value_convert2);
 271           convert_y = uiuc_convert(token_value_convert3);
 272           convert_f = uiuc_convert(token_value_convert4);
 273           Clfabetaf_fArray[Clfabetaf_index] = flap_value * convert_f;
 274           /* call 2D File Reader with file name (Clfabetaf_file) and
 275              conversion factors; function returns array of
 276              elevator deflections (deArray) and corresponding
 277              alpha (aArray) and delta CZ (CZArray) values and
 278              max number of terms in alpha arrays (nAlphaArray)
 279              and delfection array (nde) */
 280           uiuc_2DdataFileReader(Clfabetaf_file,
 281                                 datafile_xArray,
 282                                 datafile_yArray,
 283                                 datafile_zArray,
 284                                 datafile_nxArray,
 285                                 datafile_ny);
 286           d_2_to_3(datafile_xArray, Clfabetaf_aArray, Clfabetaf_index);
 287           d_1_to_2(datafile_yArray, Clfabetaf_betaArray, Clfabetaf_index);
 288           d_2_to_3(datafile_zArray, Clfabetaf_ClArray, Clfabetaf_index);
 289           i_1_to_2(datafile_nxArray, Clfabetaf_nAlphaArray, Clfabetaf_index);
 290           Clfabetaf_nbeta[Clfabetaf_index] = datafile_ny;
 291           if (Clfabetaf_first==true)
 292             {
 293               if (Clfabetaf_nice == 1)
 294                 {
 295                   Clfabetaf_na_nice = datafile_nxArray[1];
 296                   Clfabetaf_nb_nice = datafile_ny;
 297                   d_1_to_1(datafile_yArray, Clfabetaf_bArray_nice);
 298                   for (i=1; i<=Clfabetaf_na_nice; i++)
 299                     Clfabetaf_aArray_nice[i] = datafile_xArray[1][i];
 300                 }
 301               aeroRollParts -> storeCommands (*command_line);
 302               Clfabetaf_first=false;
 303             }
 304           break;
 305         }
 306       case Clfadaf_flag:
 307         {
 308           int Clfadaf_index, i;
 309           string Clfadaf_file;
 310           double flap_value;
 311           Clfadaf_file = aircraft_directory + linetoken3;
 312           token4 >> Clfadaf_index;
 313           if (Clfadaf_index < 0 || Clfadaf_index >= 100)
 314             uiuc_warnings_errors(1, *command_line);
 315           if (Clfadaf_index > Clfadaf_nf)
 316             Clfadaf_nf = Clfadaf_index;
 317           token5 >> flap_value;
 318           token6 >> token_value_convert1;
 319           token7 >> token_value_convert2;
 320           token8 >> token_value_convert3;
 321           token9 >> token_value_convert4;
 322           token10 >> Clfadaf_nice;
 323           convert_z = uiuc_convert(token_value_convert1);
 324           convert_x = uiuc_convert(token_value_convert2);
 325           convert_y = uiuc_convert(token_value_convert3);
 326           convert_f = uiuc_convert(token_value_convert4);
 327           Clfadaf_fArray[Clfadaf_index] = flap_value * convert_f;
 328           /* call 2D File Reader with file name (Clfadaf_file) and
 329              conversion factors; function returns array of
 330              elevator deflections (deArray) and corresponding
 331              alpha (aArray) and delta CZ (CZArray) values and
 332              max number of terms in alpha arrays (nAlphaArray)
 333              and delfection array (nde) */
 334           uiuc_2DdataFileReader(Clfadaf_file,
 335                                 datafile_xArray,
 336                                 datafile_yArray,
 337                                 datafile_zArray,
 338                                 datafile_nxArray,
 339                                 datafile_ny);
 340           d_2_to_3(datafile_xArray, Clfadaf_aArray, Clfadaf_index);
 341           d_1_to_2(datafile_yArray, Clfadaf_daArray, Clfadaf_index);
 342           d_2_to_3(datafile_zArray, Clfadaf_ClArray, Clfadaf_index);
 343           i_1_to_2(datafile_nxArray, Clfadaf_nAlphaArray, Clfadaf_index);
 344           Clfadaf_nda[Clfadaf_index] = datafile_ny;
 345           if (Clfadaf_first==true)
 346             {
 347               if (Clfadaf_nice == 1)
 348                 {
 349                   Clfadaf_na_nice = datafile_nxArray[1];
 350                   Clfadaf_nda_nice = datafile_ny;
 351                   d_1_to_1(datafile_yArray, Clfadaf_daArray_nice);
 352                   for (i=1; i<=Clfadaf_na_nice; i++)
 353                     Clfadaf_aArray_nice[i] = datafile_xArray[1][i];
 354                 }
 355               aeroRollParts -> storeCommands (*command_line);
 356               Clfadaf_first=false;
 357             }
 358           break;
 359         }
 360       case Clfadrf_flag:
 361         {
 362           int Clfadrf_index, i;
 363           string Clfadrf_file;
 364           double flap_value;
 365           Clfadrf_file = aircraft_directory + linetoken3;
 366           token4 >> Clfadrf_index;
 367           if (Clfadrf_index < 0 || Clfadrf_index >= 100)
 368             uiuc_warnings_errors(1, *command_line);
 369           if (Clfadrf_index > Clfadrf_nf)
 370             Clfadrf_nf = Clfadrf_index;
 371           token5 >> flap_value;
 372           token6 >> token_value_convert1;
 373           token7 >> token_value_convert2;
 374           token8 >> token_value_convert3;
 375           token9 >> token_value_convert4;
 376           token10 >> Clfadrf_nice;
 377           convert_z = uiuc_convert(token_value_convert1);
 378           convert_x = uiuc_convert(token_value_convert2);
 379           convert_y = uiuc_convert(token_value_convert3);
 380           convert_f = uiuc_convert(token_value_convert4);
 381           Clfadrf_fArray[Clfadrf_index] = flap_value * convert_f;
 382           /* call 2D File Reader with file name (Clfadrf_file) and
 383              conversion factors; function returns array of
 384              elevator deflections (deArray) and corresponding
 385              alpha (aArray) and delta CZ (CZArray) values and
 386              max number of terms in alpha arrays (nAlphaArray)
 387              and delfection array (nde) */
 388           uiuc_2DdataFileReader(Clfadrf_file,
 389                                 datafile_xArray,
 390                                 datafile_yArray,
 391                                 datafile_zArray,
 392                                 datafile_nxArray,
 393                                 datafile_ny);
 394           d_2_to_3(datafile_xArray, Clfadrf_aArray, Clfadrf_index);
 395           d_1_to_2(datafile_yArray, Clfadrf_drArray, Clfadrf_index);
 396           d_2_to_3(datafile_zArray, Clfadrf_ClArray, Clfadrf_index);
 397           i_1_to_2(datafile_nxArray, Clfadrf_nAlphaArray, Clfadrf_index);
 398           Clfadrf_ndr[Clfadrf_index] = datafile_ny;
 399           if (Clfadrf_first==true)
 400             {
 401               if (Clfadrf_nice == 1)
 402                 {
 403                   Clfadrf_na_nice = datafile_nxArray[1];
 404                   Clfadrf_ndr_nice = datafile_ny;
 405                   d_1_to_1(datafile_yArray, Clfadrf_drArray_nice);
 406                   for (i=1; i<=Clfadrf_na_nice; i++)
 407                     Clfadrf_aArray_nice[i] = datafile_xArray[1][i];
 408                 }
 409               aeroRollParts -> storeCommands (*command_line);
 410               Clfadrf_first=false;
 411             }
 412           break;
 413         }
 414       case Clfapf_flag:
 415         {
 416           int Clfapf_index, i;
 417           string Clfapf_file;
 418           double flap_value;
 419           Clfapf_file = aircraft_directory + linetoken3;
 420           token4 >> Clfapf_index;
 421           if (Clfapf_index < 0 || Clfapf_index >= 100)
 422             uiuc_warnings_errors(1, *command_line);
 423           if (Clfapf_index > Clfapf_nf)
 424             Clfapf_nf = Clfapf_index;
 425           token5 >> flap_value;
 426           token6 >> token_value_convert1;
 427           token7 >> token_value_convert2;
 428           token8 >> token_value_convert3;
 429           token9 >> token_value_convert4;
 430           token10 >> Clfapf_nice;
 431           convert_z = uiuc_convert(token_value_convert1);
 432           convert_x = uiuc_convert(token_value_convert2);
 433           convert_y = uiuc_convert(token_value_convert3);
 434           convert_f = uiuc_convert(token_value_convert4);
 435           Clfapf_fArray[Clfapf_index] = flap_value * convert_f;
 436           /* call 2D File Reader with file name (Clfapf_file) and
 437              conversion factors; function returns array of
 438              elevator deflections (deArray) and corresponding
 439              alpha (aArray) and delta CZ (CZArray) values and
 440              max number of terms in alpha arrays (nAlphaArray)
 441              and delfection array (nde) */
 442           uiuc_2DdataFileReader(Clfapf_file,
 443                                 datafile_xArray,
 444                                 datafile_yArray,
 445                                 datafile_zArray,
 446                                 datafile_nxArray,
 447                                 datafile_ny);
 448           d_2_to_3(datafile_xArray, Clfapf_aArray, Clfapf_index);
 449           d_1_to_2(datafile_yArray, Clfapf_pArray, Clfapf_index);
 450           d_2_to_3(datafile_zArray, Clfapf_ClArray, Clfapf_index);
 451           i_1_to_2(datafile_nxArray, Clfapf_nAlphaArray, Clfapf_index);
 452           Clfapf_np[Clfapf_index] = datafile_ny;
 453           if (Clfapf_first==true)
 454             {
 455               if (Clfapf_nice == 1)
 456                 {
 457                   Clfapf_na_nice = datafile_nxArray[1];
 458                   Clfapf_np_nice = datafile_ny;
 459                   d_1_to_1(datafile_yArray, Clfapf_pArray_nice);
 460                   for (i=1; i<=Clfapf_na_nice; i++)
 461                     Clfapf_aArray_nice[i] = datafile_xArray[1][i];
 462                 }
 463               aeroRollParts -> storeCommands (*command_line);
 464               Clfapf_first=false;
 465             }
 466           break;
 467         }
 468       case Clfarf_flag:
 469         {
 470           int Clfarf_index, i;
 471           string Clfarf_file;
 472           double flap_value;
 473           Clfarf_file = aircraft_directory + linetoken3;
 474           token4 >> Clfarf_index;
 475           if (Clfarf_index < 0 || Clfarf_index >= 100)
 476             uiuc_warnings_errors(1, *command_line);
 477           if (Clfarf_index > Clfarf_nf)
 478             Clfarf_nf = Clfarf_index;
 479           token5 >> flap_value;
 480           token6 >> token_value_convert1;
 481           token7 >> token_value_convert2;
 482           token8 >> token_value_convert3;
 483           token9 >> token_value_convert4;
 484           token10 >> Clfarf_nice;
 485           convert_z = uiuc_convert(token_value_convert1);
 486           convert_x = uiuc_convert(token_value_convert2);
 487           convert_y = uiuc_convert(token_value_convert3);
 488           convert_f = uiuc_convert(token_value_convert4);
 489           Clfarf_fArray[Clfarf_index] = flap_value * convert_f;
 490           /* call 2D File Reader with file name (Clfarf_file) and
 491              conversion factors; function returns array of
 492              elevator deflections (deArray) and corresponding
 493              alpha (aArray) and delta CZ (CZArray) values and
 494              max number of terms in alpha arrays (nAlphaArray)
 495              and delfection array (nde) */
 496           uiuc_2DdataFileReader(Clfarf_file,
 497                                 datafile_xArray,
 498                                 datafile_yArray,
 499                                 datafile_zArray,
 500                                 datafile_nxArray,
 501                                 datafile_ny);
 502           d_2_to_3(datafile_xArray, Clfarf_aArray, Clfarf_index);
 503           d_1_to_2(datafile_yArray, Clfarf_rArray, Clfarf_index);
 504           d_2_to_3(datafile_zArray, Clfarf_ClArray, Clfarf_index);
 505           i_1_to_2(datafile_nxArray, Clfarf_nAlphaArray, Clfarf_index);
 506           Clfarf_nr[Clfarf_index] = datafile_ny;
 507           if (Clfarf_first==true)
 508             {
 509               if (Clfarf_nice == 1)
 510                 {
 511                   Clfarf_na_nice = datafile_nxArray[1];
 512                   Clfarf_nr_nice = datafile_ny;
 513                   d_1_to_1(datafile_yArray, Clfarf_rArray_nice);
 514                   for (i=1; i<=Clfarf_na_nice; i++)
 515                     Clfarf_aArray_nice[i] = datafile_xArray[1][i];
 516                 }
 517               aeroRollParts -> storeCommands (*command_line);
 518               Clfarf_first=false;
 519             }
 520           break;
 521         }
 522       default:
 523         {
 524           if (ignore_unknown_keywords) {
 525             // do nothing
 526           } else {
 527             // print error message
 528             uiuc_warnings_errors(2, *command_line);
 529           }
 530           break;
 531         }
 532       };
 533 }