src/FDM/UIUCModel/uiuc_menu_Cn.cpp

   1 /**********************************************************************
   2
   3  FILENAME:     uiuc_menu_Cn.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_Cn.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_Cn( 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 Cnfabetaf_first = true;
 116     static bool Cnfadaf_first = true;
 117     static bool Cnfadrf_first = true;
 118     static bool Cnfapf_first = true;
 119     static bool Cnfarf_first = true;
 120
 121     switch(Cn_map[linetoken2])
 122       {
 123       case Cno_flag:
 124         {
 125           if (check_float(linetoken3))
 126             token3 >> token_value;
 127           else
 128             uiuc_warnings_errors(1, *command_line);
 129
 130           Cno = token_value;
 131           Cno_clean = Cno;
 132           aeroYawParts -> storeCommands (*command_line);
 133           break;
 134         }
 135       case Cn_beta_flag:
 136         {
 137           if (check_float(linetoken3))
 138             token3 >> token_value;
 139           else
 140             uiuc_warnings_errors(1, *command_line);
 141
 142           Cn_beta = token_value;
 143           Cn_beta_clean = Cn_beta;
 144           aeroYawParts -> storeCommands (*command_line);
 145           break;
 146         }
 147       case Cn_p_flag:
 148         {
 149           if (check_float(linetoken3))
 150             token3 >> token_value;
 151           else
 152             uiuc_warnings_errors(1, *command_line);
 153
 154           Cn_p = token_value;
 155           Cn_p_clean = Cn_p;
 156           aeroYawParts -> storeCommands (*command_line);
 157           break;
 158         }
 159       case Cn_r_flag:
 160         {
 161           if (check_float(linetoken3))
 162             token3 >> token_value;
 163           else
 164             uiuc_warnings_errors(1, *command_line);
 165
 166           Cn_r = token_value;
 167           Cn_r_clean = Cn_r;
 168           aeroYawParts -> storeCommands (*command_line);
 169           break;
 170         }
 171       case Cn_da_flag:
 172         {
 173           if (check_float(linetoken3))
 174             token3 >> token_value;
 175           else
 176             uiuc_warnings_errors(1, *command_line);
 177
 178           Cn_da = token_value;
 179           Cn_da_clean = Cn_da;
 180           aeroYawParts -> storeCommands (*command_line);
 181           break;
 182         }
 183       case Cn_dr_flag:
 184         {
 185           if (check_float(linetoken3))
 186             token3 >> token_value;
 187           else
 188             uiuc_warnings_errors(1, *command_line);
 189
 190           Cn_dr = token_value;
 191           Cn_dr_clean = Cn_dr;
 192           aeroYawParts -> storeCommands (*command_line);
 193           break;
 194         }
 195       case Cn_q_flag:
 196         {
 197           if (check_float(linetoken3))
 198             token3 >> token_value;
 199           else
 200             uiuc_warnings_errors(1, *command_line);
 201
 202           Cn_q = token_value;
 203           Cn_q_clean = Cn_q;
 204           aeroYawParts -> storeCommands (*command_line);
 205           break;
 206         }
 207       case Cn_b3_flag:
 208         {
 209           if (check_float(linetoken3))
 210             token3 >> token_value;
 211           else
 212             uiuc_warnings_errors(1, *command_line);
 213
 214           Cn_b3 = token_value;
 215           Cn_b3_clean = Cn_b3;
 216           aeroYawParts -> storeCommands (*command_line);
 217           break;
 218         }
 219       case Cnfada_flag:
 220         {
 221           Cnfada = aircraft_directory + linetoken3;
 222           token4 >> token_value_convert1;
 223           token5 >> token_value_convert2;
 224           token6 >> token_value_convert3;
 225           convert_z = uiuc_convert(token_value_convert1);
 226           convert_x = uiuc_convert(token_value_convert2);
 227           convert_y = uiuc_convert(token_value_convert3);
 228           /* call 2D File Reader with file name (Cnfada) and
 229              conversion factors; function returns array of
 230              aileron deflections (daArray) and corresponding
 231              alpha (aArray) and delta Cn (CnArray) values and
 232              max number of terms in alpha arrays (nAlphaArray)
 233              and deflection array (nda) */
 234           uiuc_2DdataFileReader(Cnfada,
 235                                 Cnfada_aArray,
 236                                 Cnfada_daArray,
 237                                 Cnfada_CnArray,
 238                                 Cnfada_nAlphaArray,
 239                                 Cnfada_nda);
 240           aeroYawParts -> storeCommands (*command_line);
 241           break;
 242         }
 243       case Cnfbetadr_flag:
 244         {
 245           Cnfbetadr = aircraft_directory + linetoken3;
 246           token4 >> token_value_convert1;
 247           token5 >> token_value_convert2;
 248           token6 >> token_value_convert3;
 249           convert_z = uiuc_convert(token_value_convert1);
 250           convert_x = uiuc_convert(token_value_convert2);
 251           convert_y = uiuc_convert(token_value_convert3);
 252           /* call 2D File Reader with file name (Cnfbetadr) and
 253              conversion factors; function returns array of
 254              rudder deflections (drArray) and corresponding
 255              beta (betaArray) and delta Cn (CnArray) values and
 256              max number of terms in beta arrays (nBetaArray)
 257              and deflection array (ndr) */
 258           uiuc_2DdataFileReader(Cnfbetadr,
 259                                 Cnfbetadr_betaArray,
 260                                 Cnfbetadr_drArray,
 261                                 Cnfbetadr_CnArray,
 262                                 Cnfbetadr_nBetaArray,
 263                                 Cnfbetadr_ndr);
 264           aeroYawParts -> storeCommands (*command_line);
 265           break;
 266         }
 267       case Cnfabetaf_flag:
 268         {
 269           int Cnfabetaf_index, i;
 270           string Cnfabetaf_file;
 271           double flap_value;
 272           Cnfabetaf_file = aircraft_directory + linetoken3;
 273           token4 >> Cnfabetaf_index;
 274           if (Cnfabetaf_index < 0 || Cnfabetaf_index >= 100)
 275             uiuc_warnings_errors(1, *command_line);
 276           if (Cnfabetaf_index > Cnfabetaf_nf)
 277             Cnfabetaf_nf = Cnfabetaf_index;
 278           token5 >> flap_value;
 279           token6 >> token_value_convert1;
 280           token7 >> token_value_convert2;
 281           token8 >> token_value_convert3;
 282           token9 >> token_value_convert4;
 283           token10 >> Cnfabetaf_nice;
 284           convert_z = uiuc_convert(token_value_convert1);
 285           convert_x = uiuc_convert(token_value_convert2);
 286           convert_y = uiuc_convert(token_value_convert3);
 287           convert_f = uiuc_convert(token_value_convert4);
 288           Cnfabetaf_fArray[Cnfabetaf_index] = flap_value * convert_f;
 289           /* call 2D File Reader with file name (Cnfabetaf_file) and
 290              conversion factors; function returns array of
 291              elevator deflections (deArray) and corresponding
 292              alpha (aArray) and delta CZ (CZArray) values and
 293              max number of terms in alpha arrays (nAlphaArray)
 294              and delfection array (nde) */
 295           uiuc_2DdataFileReader(Cnfabetaf_file,
 296                                 datafile_xArray,
 297                                 datafile_yArray,
 298                                 datafile_zArray,
 299                                 datafile_nxArray,
 300                                 datafile_ny);
 301           d_2_to_3(datafile_xArray, Cnfabetaf_aArray, Cnfabetaf_index);
 302           d_1_to_2(datafile_yArray, Cnfabetaf_betaArray, Cnfabetaf_index);
 303           d_2_to_3(datafile_zArray, Cnfabetaf_CnArray, Cnfabetaf_index);
 304           i_1_to_2(datafile_nxArray, Cnfabetaf_nAlphaArray, Cnfabetaf_index);
 305           Cnfabetaf_nbeta[Cnfabetaf_index] = datafile_ny;
 306           if (Cnfabetaf_first==true)
 307             {
 308               if (Cnfabetaf_nice == 1)
 309                 {
 310                   Cnfabetaf_na_nice = datafile_nxArray[1];
 311                   Cnfabetaf_nb_nice = datafile_ny;
 312                   d_1_to_1(datafile_yArray, Cnfabetaf_bArray_nice);
 313                   for (i=1; i<=Cnfabetaf_na_nice; i++)
 314                     Cnfabetaf_aArray_nice[i] = datafile_xArray[1][i];
 315                 }
 316               aeroYawParts -> storeCommands (*command_line);
 317               Cnfabetaf_first=false;
 318             }
 319           break;
 320         }
 321       case Cnfadaf_flag:
 322         {
 323           int Cnfadaf_index, i;
 324           string Cnfadaf_file;
 325           double flap_value;
 326           Cnfadaf_file = aircraft_directory + linetoken3;
 327           token4 >> Cnfadaf_index;
 328           if (Cnfadaf_index < 0 || Cnfadaf_index >= 100)
 329             uiuc_warnings_errors(1, *command_line);
 330           if (Cnfadaf_index > Cnfadaf_nf)
 331             Cnfadaf_nf = Cnfadaf_index;
 332           token5 >> flap_value;
 333           token6 >> token_value_convert1;
 334           token7 >> token_value_convert2;
 335           token8 >> token_value_convert3;
 336           token9 >> token_value_convert4;
 337           token10 >> Cnfadaf_nice;
 338           convert_z = uiuc_convert(token_value_convert1);
 339           convert_x = uiuc_convert(token_value_convert2);
 340           convert_y = uiuc_convert(token_value_convert3);
 341           convert_f = uiuc_convert(token_value_convert4);
 342           Cnfadaf_fArray[Cnfadaf_index] = flap_value * convert_f;
 343           /* call 2D File Reader with file name (Cnfadaf_file) and
 344              conversion factors; function returns array of
 345              elevator deflections (deArray) and corresponding
 346              alpha (aArray) and delta CZ (CZArray) values and
 347              max number of terms in alpha arrays (nAlphaArray)
 348              and delfection array (nde) */
 349           uiuc_2DdataFileReader(Cnfadaf_file,
 350                                 datafile_xArray,
 351                                 datafile_yArray,
 352                                 datafile_zArray,
 353                                 datafile_nxArray,
 354                                 datafile_ny);
 355           d_2_to_3(datafile_xArray, Cnfadaf_aArray, Cnfadaf_index);
 356           d_1_to_2(datafile_yArray, Cnfadaf_daArray, Cnfadaf_index);
 357           d_2_to_3(datafile_zArray, Cnfadaf_CnArray, Cnfadaf_index);
 358           i_1_to_2(datafile_nxArray, Cnfadaf_nAlphaArray, Cnfadaf_index);
 359           Cnfadaf_nda[Cnfadaf_index] = datafile_ny;
 360           if (Cnfadaf_first==true)
 361             {
 362               if (Cnfadaf_nice == 1)
 363                 {
 364                   Cnfadaf_na_nice = datafile_nxArray[1];
 365                   Cnfadaf_nda_nice = datafile_ny;
 366                   d_1_to_1(datafile_yArray, Cnfadaf_daArray_nice);
 367                   for (i=1; i<=Cnfadaf_na_nice; i++)
 368                     Cnfadaf_aArray_nice[i] = datafile_xArray[1][i];
 369                 }
 370               aeroYawParts -> storeCommands (*command_line);
 371               Cnfadaf_first=false;
 372             }
 373           break;
 374         }
 375       case Cnfadrf_flag:
 376         {
 377           int Cnfadrf_index, i;
 378           string Cnfadrf_file;
 379           double flap_value;
 380           Cnfadrf_file = aircraft_directory + linetoken3;
 381           token4 >> Cnfadrf_index;
 382           if (Cnfadrf_index < 0 || Cnfadrf_index >= 100)
 383             uiuc_warnings_errors(1, *command_line);
 384           if (Cnfadrf_index > Cnfadrf_nf)
 385             Cnfadrf_nf = Cnfadrf_index;
 386           token5 >> flap_value;
 387           token6 >> token_value_convert1;
 388           token7 >> token_value_convert2;
 389           token8 >> token_value_convert3;
 390           token9 >> token_value_convert4;
 391           token10 >> Cnfadrf_nice;
 392           convert_z = uiuc_convert(token_value_convert1);
 393           convert_x = uiuc_convert(token_value_convert2);
 394           convert_y = uiuc_convert(token_value_convert3);
 395           convert_f = uiuc_convert(token_value_convert4);
 396           Cnfadrf_fArray[Cnfadrf_index] = flap_value * convert_f;
 397           /* call 2D File Reader with file name (Cnfadrf_file) and
 398              conversion factors; function returns array of
 399              elevator deflections (deArray) and corresponding
 400              alpha (aArray) and delta CZ (CZArray) values and
 401              max number of terms in alpha arrays (nAlphaArray)
 402              and delfection array (nde) */
 403           uiuc_2DdataFileReader(Cnfadrf_file,
 404                                 datafile_xArray,
 405                                 datafile_yArray,
 406                                 datafile_zArray,
 407                                 datafile_nxArray,
 408                                 datafile_ny);
 409           d_2_to_3(datafile_xArray, Cnfadrf_aArray, Cnfadrf_index);
 410           d_1_to_2(datafile_yArray, Cnfadrf_drArray, Cnfadrf_index);
 411           d_2_to_3(datafile_zArray, Cnfadrf_CnArray, Cnfadrf_index);
 412           i_1_to_2(datafile_nxArray, Cnfadrf_nAlphaArray, Cnfadrf_index);
 413           Cnfadrf_ndr[Cnfadrf_index] = datafile_ny;
 414           if (Cnfadrf_first==true)
 415             {
 416               if (Cnfadrf_nice == 1)
 417                 {
 418                   Cnfadrf_na_nice = datafile_nxArray[1];
 419                   Cnfadrf_ndr_nice = datafile_ny;
 420                   d_1_to_1(datafile_yArray, Cnfadrf_drArray_nice);
 421                   for (i=1; i<=Cnfadrf_na_nice; i++)
 422                     Cnfadrf_aArray_nice[i] = datafile_xArray[1][i];
 423                 }
 424               aeroYawParts -> storeCommands (*command_line);
 425               Cnfadrf_first=false;
 426             }
 427           break;
 428         }
 429       case Cnfapf_flag:
 430         {
 431           int Cnfapf_index, i;
 432           string Cnfapf_file;
 433           double flap_value;
 434           Cnfapf_file = aircraft_directory + linetoken3;
 435           token4 >> Cnfapf_index;
 436           if (Cnfapf_index < 0 || Cnfapf_index >= 100)
 437             uiuc_warnings_errors(1, *command_line);
 438           if (Cnfapf_index > Cnfapf_nf)
 439             Cnfapf_nf = Cnfapf_index;
 440           token5 >> flap_value;
 441           token6 >> token_value_convert1;
 442           token7 >> token_value_convert2;
 443           token8 >> token_value_convert3;
 444           token9 >> token_value_convert4;
 445           token10 >> Cnfapf_nice;
 446           convert_z = uiuc_convert(token_value_convert1);
 447           convert_x = uiuc_convert(token_value_convert2);
 448           convert_y = uiuc_convert(token_value_convert3);
 449           convert_f = uiuc_convert(token_value_convert4);
 450           Cnfapf_fArray[Cnfapf_index] = flap_value * convert_f;
 451           /* call 2D File Reader with file name (Cnfapf_file) and
 452              conversion factors; function returns array of
 453              elevator deflections (deArray) and corresponding
 454              alpha (aArray) and delta CZ (CZArray) values and
 455              max number of terms in alpha arrays (nAlphaArray)
 456              and delfection array (nde) */
 457           uiuc_2DdataFileReader(Cnfapf_file,
 458                                 datafile_xArray,
 459                                 datafile_yArray,
 460                                 datafile_zArray,
 461                                 datafile_nxArray,
 462                                 datafile_ny);
 463           d_2_to_3(datafile_xArray, Cnfapf_aArray, Cnfapf_index);
 464           d_1_to_2(datafile_yArray, Cnfapf_pArray, Cnfapf_index);
 465           d_2_to_3(datafile_zArray, Cnfapf_CnArray, Cnfapf_index);
 466           i_1_to_2(datafile_nxArray, Cnfapf_nAlphaArray, Cnfapf_index);
 467           Cnfapf_np[Cnfapf_index] = datafile_ny;
 468           if (Cnfapf_first==true)
 469             {
 470               if (Cnfapf_nice == 1)
 471                 {
 472                   Cnfapf_na_nice = datafile_nxArray[1];
 473                   Cnfapf_np_nice = datafile_ny;
 474                   d_1_to_1(datafile_yArray, Cnfapf_pArray_nice);
 475                   for (i=1; i<=Cnfapf_na_nice; i++)
 476                     Cnfapf_aArray_nice[i] = datafile_xArray[1][i];
 477                 }
 478               aeroYawParts -> storeCommands (*command_line);
 479               Cnfapf_first=false;
 480             }
 481           break;
 482         }
 483       case Cnfarf_flag:
 484         {
 485           int Cnfarf_index, i;
 486           string Cnfarf_file;
 487           double flap_value;
 488           Cnfarf_file = aircraft_directory + linetoken3;
 489           token4 >> Cnfarf_index;
 490           if (Cnfarf_index < 0 || Cnfarf_index >= 100)
 491             uiuc_warnings_errors(1, *command_line);
 492           if (Cnfarf_index > Cnfarf_nf)
 493             Cnfarf_nf = Cnfarf_index;
 494           token5 >> flap_value;
 495           token6 >> token_value_convert1;
 496           token7 >> token_value_convert2;
 497           token8 >> token_value_convert3;
 498           token9 >> token_value_convert4;
 499           token10 >> Cnfarf_nice;
 500           convert_z = uiuc_convert(token_value_convert1);
 501           convert_x = uiuc_convert(token_value_convert2);
 502           convert_y = uiuc_convert(token_value_convert3);
 503           convert_f = uiuc_convert(token_value_convert4);
 504           Cnfarf_fArray[Cnfarf_index] = flap_value * convert_f;
 505           /* call 2D File Reader with file name (Cnfarf_file) and
 506              conversion factors; function returns array of
 507              elevator deflections (deArray) and corresponding
 508              alpha (aArray) and delta CZ (CZArray) values and
 509              max number of terms in alpha arrays (nAlphaArray)
 510              and delfection array (nde) */
 511           uiuc_2DdataFileReader(Cnfarf_file,
 512                                 datafile_xArray,
 513                                 datafile_yArray,
 514                                 datafile_zArray,
 515                                 datafile_nxArray,
 516                                 datafile_ny);
 517           d_2_to_3(datafile_xArray, Cnfarf_aArray, Cnfarf_index);
 518           d_1_to_2(datafile_yArray, Cnfarf_rArray, Cnfarf_index);
 519           d_2_to_3(datafile_zArray, Cnfarf_CnArray, Cnfarf_index);
 520           i_1_to_2(datafile_nxArray, Cnfarf_nAlphaArray, Cnfarf_index);
 521           Cnfarf_nr[Cnfarf_index] = datafile_ny;
 522           if (Cnfarf_first==true)
 523             {
 524               if (Cnfarf_nice == 1)
 525                 {
 526                   Cnfarf_na_nice = datafile_nxArray[1];
 527                   Cnfarf_nr_nice = datafile_ny;
 528                   d_1_to_1(datafile_yArray, Cnfarf_rArray_nice);
 529                   for (i=1; i<=Cnfarf_na_nice; i++)
 530                     Cnfarf_aArray_nice[i] = datafile_xArray[1][i];
 531                 }
 532               aeroYawParts -> storeCommands (*command_line);
 533               Cnfarf_first=false;
 534             }
 535           break;
 536         }
 537       default:
 538         {
 539           if (ignore_unknown_keywords) {
 540             // do nothing
 541           } else {
 542             // print error message
 543             uiuc_warnings_errors(2, *command_line);
 544           }
 545           break;
 546         }
 547       };
 548 }