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