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