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
  22 ----------------------------------------------------------------------
  23
  24  AUTHOR(S):    Robert Deters      <rdeters@uiuc.edu>
  25                Michael Selig      <m-selig@uiuc.edu>
  26
  27 ----------------------------------------------------------------------
  28
  29  VARIABLES:
  30
  31 ----------------------------------------------------------------------
  32
  33  INPUTS:       n/a
  34
  35 ----------------------------------------------------------------------
  36
  37  OUTPUTS:      n/a
  38
  39 ----------------------------------------------------------------------
  40
  41  CALLED BY:    uiuc_menu()
  42
  43 ----------------------------------------------------------------------
  44
  45  CALLS TO:     check_float() if needed
  46                d_2_to_3() if needed
  47                d_1_to_2() if needed
  48                i_1_to_2() if needed
  49                d_1_to_1() if needed
  50
  51  ----------------------------------------------------------------------
  52
  53  COPYRIGHT:    (C) 2003 by Michael Selig
  54
  55  This program is free software; you can redistribute it and/or
  56  modify it under the terms of the GNU General Public License
  57  as published by the Free Software Foundation.
  58
  59  This program is distributed in the hope that it will be useful,
  60  but WITHOUT ANY WARRANTY; without even the implied warranty of
  61  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  62  GNU General Public License for more details.
  63
  64  You should have received a copy of the GNU General Public License
  65  along with this program; if not, write to the Free Software
  66  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  67  USA or view http://www.gnu.org/copyleft/gpl.html.
  68
  69 **********************************************************************/
  70
  71 #include <simgear/compiler.h>
  72
  73 #if defined( __MWERKS__ )
  74 // -dw- optimizer chokes (big-time) trying to optimize humongous
  75 // loop/switch statements
  76 #pragma optimization_level 0
  77 #endif
  78
  79 #include <cstdlib>
  80 #include <string>
  81 #include STL_IOSTREAM
  82
  83 #include "uiuc_menu_Croll.h"
  84
  85 SG_USING_STD(cerr);
  86 SG_USING_STD(cout);
  87 SG_USING_STD(endl);
  88
  89 #ifndef _MSC_VER
  90 SG_USING_STD(exit);
  91 #endif
  92
  93 void parse_Cl( const string& linetoken2, const string& linetoken3,
  94                const string& linetoken4, const string& linetoken5,
  95                const string& linetoken6, const string& linetoken7,
  96                const string& linetoken8, const string& linetoken9,
  97                const string& linetoken10, const string& aircraft_directory,
  98                LIST command_line ) {
  99     double token_value;
 100     int token_value_convert1, token_value_convert2, token_value_convert3;
 101     int token_value_convert4;
 102     double datafile_xArray[100][100], datafile_yArray[100];
 103     double datafile_zArray[100][100];
 104     double convert_f;
 105     int datafile_nxArray[100], datafile_ny;
 106     istrstream token3(linetoken3.c_str());
 107     istrstream token4(linetoken4.c_str());
 108     istrstream token5(linetoken5.c_str());
 109     istrstream token6(linetoken6.c_str());
 110     istrstream token7(linetoken7.c_str());
 111     istrstream token8(linetoken8.c_str());
 112     istrstream token9(linetoken9.c_str());
 113     istrstream token10(linetoken10.c_str());
 114
 115     static bool Clfabetaf_first = true;
 116     static bool Clfadaf_first = true;
 117     static bool Clfadrf_first = true;
 118     static bool Clfapf_first = true;
 119     static bool Clfarf_first = true;
 120
 121     switch(Cl_map[linetoken2])
 122       {
 123       case Clo_flag:
 124         {
 125           if (check_float(linetoken3))
 126             token3 >> token_value;
 127           else
 128             uiuc_warnings_errors(1, *command_line);
 129
 130           Clo = token_value;
 131           Clo_clean = Clo;
 132           aeroRollParts -> storeCommands (*command_line);
 133           break;
 134         }
 135       case Cl_beta_flag:
 136         {
 137           if (check_float(linetoken3))
 138             token3 >> token_value;
 139           else
 140             uiuc_warnings_errors(1, *command_line);
 141
 142           Cl_beta = token_value;
 143           Cl_beta_clean = Cl_beta;
 144           aeroRollParts -> storeCommands (*command_line);
 145           break;
 146         }
 147       case Cl_p_flag:
 148         {
 149           if (check_float(linetoken3))
 150             token3 >> token_value;
 151           else
 152             uiuc_warnings_errors(1, *command_line);
 153
 154           Cl_p = token_value;
 155           Cl_p_clean = Cl_p;
 156           aeroRollParts -> storeCommands (*command_line);
 157           break;
 158         }
 159       case Cl_r_flag:
 160         {
 161           if (check_float(linetoken3))
 162             token3 >> token_value;
 163           else
 164             uiuc_warnings_errors(1, *command_line);
 165
 166           Cl_r = token_value;
 167           Cl_r_clean = Cl_r;
 168           aeroRollParts -> storeCommands (*command_line);
 169           break;
 170         }
 171       case Cl_da_flag:
 172         {
 173           if (check_float(linetoken3))
 174             token3 >> token_value;
 175           else
 176             uiuc_warnings_errors(1, *command_line);
 177
 178           Cl_da = token_value;
 179           Cl_da_clean = Cl_da;
 180           aeroRollParts -> storeCommands (*command_line);
 181           break;
 182         }
 183       case Cl_dr_flag:
 184         {
 185           if (check_float(linetoken3))
 186             token3 >> token_value;
 187           else
 188             uiuc_warnings_errors(1, *command_line);
 189
 190           Cl_dr = token_value;
 191           Cl_dr_clean = Cl_dr;
 192           aeroRollParts -> storeCommands (*command_line);
 193           break;
 194         }
 195       case Cl_daa_flag:
 196         {
 197           if (check_float(linetoken3))
 198             token3 >> token_value;
 199           else
 200             uiuc_warnings_errors(1, *command_line);
 201
 202           Cl_daa = token_value;
 203           Cl_daa_clean = Cl_daa;
 204           aeroRollParts -> storeCommands (*command_line);
 205           break;
 206         }
 207       case Clfada_flag:
 208         {
 209           Clfada = aircraft_directory + linetoken3;
 210           token4 >> token_value_convert1;
 211           token5 >> token_value_convert2;
 212           token6 >> token_value_convert3;
 213           convert_z = uiuc_convert(token_value_convert1);
 214           convert_x = uiuc_convert(token_value_convert2);
 215           convert_y = uiuc_convert(token_value_convert3);
 216           /* call 2D File Reader with file name (Clfada) and
 217              conversion factors; function returns array of
 218              aileron deflections (daArray) and corresponding
 219              alpha (aArray) and delta Cl (ClArray) values and
 220              max number of terms in alpha arrays (nAlphaArray)
 221              and deflection array (nda) */
 222           uiuc_2DdataFileReader(Clfada,
 223                                 Clfada_aArray,
 224                                 Clfada_daArray,
 225                                 Clfada_ClArray,
 226                                 Clfada_nAlphaArray,
 227                                 Clfada_nda);
 228           aeroRollParts -> storeCommands (*command_line);
 229           break;
 230         }
 231       case Clfbetadr_flag:
 232         {
 233           Clfbetadr = aircraft_directory + linetoken3;
 234           token4 >> token_value_convert1;
 235           token5 >> token_value_convert2;
 236           token6 >> token_value_convert3;
 237           convert_z = uiuc_convert(token_value_convert1);
 238           convert_x = uiuc_convert(token_value_convert2);
 239           convert_y = uiuc_convert(token_value_convert3);
 240           /* call 2D File Reader with file name (Clfbetadr) and
 241              conversion factors; function returns array of
 242              rudder deflections (drArray) and corresponding
 243              beta (betaArray) and delta Cl (ClArray) values and
 244              max number of terms in beta arrays (nBetaArray)
 245              and deflection array (ndr) */
 246           uiuc_2DdataFileReader(Clfbetadr,
 247                                 Clfbetadr_betaArray,
 248                                 Clfbetadr_drArray,
 249                                 Clfbetadr_ClArray,
 250                                 Clfbetadr_nBetaArray,
 251                                 Clfbetadr_ndr);
 252           aeroRollParts -> storeCommands (*command_line);
 253           break;
 254         }
 255       case Clfabetaf_flag:
 256         {
 257           int Clfabetaf_index, i;
 258           string Clfabetaf_file;
 259           double flap_value;
 260           Clfabetaf_file = aircraft_directory + linetoken3;
 261           token4 >> Clfabetaf_index;
 262           if (Clfabetaf_index < 0 || Clfabetaf_index >= 100)
 263             uiuc_warnings_errors(1, *command_line);
 264           if (Clfabetaf_index > Clfabetaf_nf)
 265             Clfabetaf_nf = Clfabetaf_index;
 266           token5 >> flap_value;
 267           token6 >> token_value_convert1;
 268           token7 >> token_value_convert2;
 269           token8 >> token_value_convert3;
 270           token9 >> token_value_convert4;
 271           token10 >> Clfabetaf_nice;
 272           convert_z = uiuc_convert(token_value_convert1);
 273           convert_x = uiuc_convert(token_value_convert2);
 274           convert_y = uiuc_convert(token_value_convert3);
 275           convert_f = uiuc_convert(token_value_convert4);
 276           Clfabetaf_fArray[Clfabetaf_index] = flap_value * convert_f;
 277           /* call 2D File Reader with file name (Clfabetaf_file) and
 278              conversion factors; function returns array of
 279              elevator deflections (deArray) and corresponding
 280              alpha (aArray) and delta CZ (CZArray) values and
 281              max number of terms in alpha arrays (nAlphaArray)
 282              and delfection array (nde) */
 283           uiuc_2DdataFileReader(Clfabetaf_file,
 284                                 datafile_xArray,
 285                                 datafile_yArray,
 286                                 datafile_zArray,
 287                                 datafile_nxArray,
 288                                 datafile_ny);
 289           d_2_to_3(datafile_xArray, Clfabetaf_aArray, Clfabetaf_index);
 290           d_1_to_2(datafile_yArray, Clfabetaf_betaArray, Clfabetaf_index);
 291           d_2_to_3(datafile_zArray, Clfabetaf_ClArray, Clfabetaf_index);
 292           i_1_to_2(datafile_nxArray, Clfabetaf_nAlphaArray, Clfabetaf_index);
 293           Clfabetaf_nbeta[Clfabetaf_index] = datafile_ny;
 294           if (Clfabetaf_first==true)
 295             {
 296               if (Clfabetaf_nice == 1)
 297                 {
 298                   Clfabetaf_na_nice = datafile_nxArray[1];
 299                   Clfabetaf_nb_nice = datafile_ny;
 300                   d_1_to_1(datafile_yArray, Clfabetaf_bArray_nice);
 301                   for (i=1; i<=Clfabetaf_na_nice; i++)
 302                     Clfabetaf_aArray_nice[i] = datafile_xArray[1][i];
 303                 }
 304               aeroRollParts -> storeCommands (*command_line);
 305               Clfabetaf_first=false;
 306             }
 307           break;
 308         }
 309       case Clfadaf_flag:
 310         {
 311           int Clfadaf_index, i;
 312           string Clfadaf_file;
 313           double flap_value;
 314           Clfadaf_file = aircraft_directory + linetoken3;
 315           token4 >> Clfadaf_index;
 316           if (Clfadaf_index < 0 || Clfadaf_index >= 100)
 317             uiuc_warnings_errors(1, *command_line);
 318           if (Clfadaf_index > Clfadaf_nf)
 319             Clfadaf_nf = Clfadaf_index;
 320           token5 >> flap_value;
 321           token6 >> token_value_convert1;
 322           token7 >> token_value_convert2;
 323           token8 >> token_value_convert3;
 324           token9 >> token_value_convert4;
 325           token10 >> Clfadaf_nice;
 326           convert_z = uiuc_convert(token_value_convert1);
 327           convert_x = uiuc_convert(token_value_convert2);
 328           convert_y = uiuc_convert(token_value_convert3);
 329           convert_f = uiuc_convert(token_value_convert4);
 330           Clfadaf_fArray[Clfadaf_index] = flap_value * convert_f;
 331           /* call 2D File Reader with file name (Clfadaf_file) and
 332              conversion factors; function returns array of
 333              elevator deflections (deArray) and corresponding
 334              alpha (aArray) and delta CZ (CZArray) values and
 335              max number of terms in alpha arrays (nAlphaArray)
 336              and delfection array (nde) */
 337           uiuc_2DdataFileReader(Clfadaf_file,
 338                                 datafile_xArray,
 339                                 datafile_yArray,
 340                                 datafile_zArray,
 341                                 datafile_nxArray,
 342                                 datafile_ny);
 343           d_2_to_3(datafile_xArray, Clfadaf_aArray, Clfadaf_index);
 344           d_1_to_2(datafile_yArray, Clfadaf_daArray, Clfadaf_index);
 345           d_2_to_3(datafile_zArray, Clfadaf_ClArray, Clfadaf_index);
 346           i_1_to_2(datafile_nxArray, Clfadaf_nAlphaArray, Clfadaf_index);
 347           Clfadaf_nda[Clfadaf_index] = datafile_ny;
 348           if (Clfadaf_first==true)
 349             {
 350               if (Clfadaf_nice == 1)
 351                 {
 352                   Clfadaf_na_nice = datafile_nxArray[1];
 353                   Clfadaf_nda_nice = datafile_ny;
 354                   d_1_to_1(datafile_yArray, Clfadaf_daArray_nice);
 355                   for (i=1; i<=Clfadaf_na_nice; i++)
 356                     Clfadaf_aArray_nice[i] = datafile_xArray[1][i];
 357                 }
 358               aeroRollParts -> storeCommands (*command_line);
 359               Clfadaf_first=false;
 360             }
 361           break;
 362         }
 363       case Clfadrf_flag:
 364         {
 365           int Clfadrf_index, i;
 366           string Clfadrf_file;
 367           double flap_value;
 368           Clfadrf_file = aircraft_directory + linetoken3;
 369           token4 >> Clfadrf_index;
 370           if (Clfadrf_index < 0 || Clfadrf_index >= 100)
 371             uiuc_warnings_errors(1, *command_line);
 372           if (Clfadrf_index > Clfadrf_nf)
 373             Clfadrf_nf = Clfadrf_index;
 374           token5 >> flap_value;
 375           token6 >> token_value_convert1;
 376           token7 >> token_value_convert2;
 377           token8 >> token_value_convert3;
 378           token9 >> token_value_convert4;
 379           token10 >> Clfadrf_nice;
 380           convert_z = uiuc_convert(token_value_convert1);
 381           convert_x = uiuc_convert(token_value_convert2);
 382           convert_y = uiuc_convert(token_value_convert3);
 383           convert_f = uiuc_convert(token_value_convert4);
 384           Clfadrf_fArray[Clfadrf_index] = flap_value * convert_f;
 385           /* call 2D File Reader with file name (Clfadrf_file) and
 386              conversion factors; function returns array of
 387              elevator deflections (deArray) and corresponding
 388              alpha (aArray) and delta CZ (CZArray) values and
 389              max number of terms in alpha arrays (nAlphaArray)
 390              and delfection array (nde) */
 391           uiuc_2DdataFileReader(Clfadrf_file,
 392                                 datafile_xArray,
 393                                 datafile_yArray,
 394                                 datafile_zArray,
 395                                 datafile_nxArray,
 396                                 datafile_ny);
 397           d_2_to_3(datafile_xArray, Clfadrf_aArray, Clfadrf_index);
 398           d_1_to_2(datafile_yArray, Clfadrf_drArray, Clfadrf_index);
 399           d_2_to_3(datafile_zArray, Clfadrf_ClArray, Clfadrf_index);
 400           i_1_to_2(datafile_nxArray, Clfadrf_nAlphaArray, Clfadrf_index);
 401           Clfadrf_ndr[Clfadrf_index] = datafile_ny;
 402           if (Clfadrf_first==true)
 403             {
 404               if (Clfadrf_nice == 1)
 405                 {
 406                   Clfadrf_na_nice = datafile_nxArray[1];
 407                   Clfadrf_ndr_nice = datafile_ny;
 408                   d_1_to_1(datafile_yArray, Clfadrf_drArray_nice);
 409                   for (i=1; i<=Clfadrf_na_nice; i++)
 410                     Clfadrf_aArray_nice[i] = datafile_xArray[1][i];
 411                 }
 412               aeroRollParts -> storeCommands (*command_line);
 413               Clfadrf_first=false;
 414             }
 415           break;
 416         }
 417       case Clfapf_flag:
 418         {
 419           int Clfapf_index, i;
 420           string Clfapf_file;
 421           double flap_value;
 422           Clfapf_file = aircraft_directory + linetoken3;
 423           token4 >> Clfapf_index;
 424           if (Clfapf_index < 0 || Clfapf_index >= 100)
 425             uiuc_warnings_errors(1, *command_line);
 426           if (Clfapf_index > Clfapf_nf)
 427             Clfapf_nf = Clfapf_index;
 428           token5 >> flap_value;
 429           token6 >> token_value_convert1;
 430           token7 >> token_value_convert2;
 431           token8 >> token_value_convert3;
 432           token9 >> token_value_convert4;
 433           token10 >> Clfapf_nice;
 434           convert_z = uiuc_convert(token_value_convert1);
 435           convert_x = uiuc_convert(token_value_convert2);
 436           convert_y = uiuc_convert(token_value_convert3);
 437           convert_f = uiuc_convert(token_value_convert4);
 438           Clfapf_fArray[Clfapf_index] = flap_value * convert_f;
 439           /* call 2D File Reader with file name (Clfapf_file) and
 440              conversion factors; function returns array of
 441              elevator deflections (deArray) and corresponding
 442              alpha (aArray) and delta CZ (CZArray) values and
 443              max number of terms in alpha arrays (nAlphaArray)
 444              and delfection array (nde) */
 445           uiuc_2DdataFileReader(Clfapf_file,
 446                                 datafile_xArray,
 447                                 datafile_yArray,
 448                                 datafile_zArray,
 449                                 datafile_nxArray,
 450                                 datafile_ny);
 451           d_2_to_3(datafile_xArray, Clfapf_aArray, Clfapf_index);
 452           d_1_to_2(datafile_yArray, Clfapf_pArray, Clfapf_index);
 453           d_2_to_3(datafile_zArray, Clfapf_ClArray, Clfapf_index);
 454           i_1_to_2(datafile_nxArray, Clfapf_nAlphaArray, Clfapf_index);
 455           Clfapf_np[Clfapf_index] = datafile_ny;
 456           if (Clfapf_first==true)
 457             {
 458               if (Clfapf_nice == 1)
 459                 {
 460                   Clfapf_na_nice = datafile_nxArray[1];
 461                   Clfapf_np_nice = datafile_ny;
 462                   d_1_to_1(datafile_yArray, Clfapf_pArray_nice);
 463                   for (i=1; i<=Clfapf_na_nice; i++)
 464                     Clfapf_aArray_nice[i] = datafile_xArray[1][i];
 465                 }
 466               aeroRollParts -> storeCommands (*command_line);
 467               Clfapf_first=false;
 468             }
 469           break;
 470         }
 471       case Clfarf_flag:
 472         {
 473           int Clfarf_index, i;
 474           string Clfarf_file;
 475           double flap_value;
 476           Clfarf_file = aircraft_directory + linetoken3;
 477           token4 >> Clfarf_index;
 478           if (Clfarf_index < 0 || Clfarf_index >= 100)
 479             uiuc_warnings_errors(1, *command_line);
 480           if (Clfarf_index > Clfarf_nf)
 481             Clfarf_nf = Clfarf_index;
 482           token5 >> flap_value;
 483           token6 >> token_value_convert1;
 484           token7 >> token_value_convert2;
 485           token8 >> token_value_convert3;
 486           token9 >> token_value_convert4;
 487           token10 >> Clfarf_nice;
 488           convert_z = uiuc_convert(token_value_convert1);
 489           convert_x = uiuc_convert(token_value_convert2);
 490           convert_y = uiuc_convert(token_value_convert3);
 491           convert_f = uiuc_convert(token_value_convert4);
 492           Clfarf_fArray[Clfarf_index] = flap_value * convert_f;
 493           /* call 2D File Reader with file name (Clfarf_file) and
 494              conversion factors; function returns array of
 495              elevator deflections (deArray) and corresponding
 496              alpha (aArray) and delta CZ (CZArray) values and
 497              max number of terms in alpha arrays (nAlphaArray)
 498              and delfection array (nde) */
 499           uiuc_2DdataFileReader(Clfarf_file,
 500                                 datafile_xArray,
 501                                 datafile_yArray,
 502                                 datafile_zArray,
 503                                 datafile_nxArray,
 504                                 datafile_ny);
 505           d_2_to_3(datafile_xArray, Clfarf_aArray, Clfarf_index);
 506           d_1_to_2(datafile_yArray, Clfarf_rArray, Clfarf_index);
 507           d_2_to_3(datafile_zArray, Clfarf_ClArray, Clfarf_index);
 508           i_1_to_2(datafile_nxArray, Clfarf_nAlphaArray, Clfarf_index);
 509           Clfarf_nr[Clfarf_index] = datafile_ny;
 510           if (Clfarf_first==true)
 511             {
 512               if (Clfarf_nice == 1)
 513                 {
 514                   Clfarf_na_nice = datafile_nxArray[1];
 515                   Clfarf_nr_nice = datafile_ny;
 516                   d_1_to_1(datafile_yArray, Clfarf_rArray_nice);
 517                   for (i=1; i<=Clfarf_na_nice; i++)
 518                     Clfarf_aArray_nice[i] = datafile_xArray[1][i];
 519                 }
 520               aeroRollParts -> storeCommands (*command_line);
 521               Clfarf_first=false;
 522             }
 523           break;
 524         }
 525       default:
 526         {
 527           if (ignore_unknown_keywords) {
 528             // do nothing
 529           } else {
 530             // print error message
 531             uiuc_warnings_errors(2, *command_line);
 532           }
 533           break;
 534         }
 535       };
 536 }