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                06/30/2003   (RD) replaced istrstream with istringstream
  22                             to get rid of the annoying warning about
  23                             using the strstream header
  24
  25 ----------------------------------------------------------------------
  26
  27  AUTHOR(S):    Robert Deters      <rdeters@uiuc.edu>
  28                Michael Selig      <m-selig@uiuc.edu>
  29
  30 ----------------------------------------------------------------------
  31
  32  VARIABLES:
  33
  34 ----------------------------------------------------------------------
  35
  36  INPUTS:       n/a
  37
  38 ----------------------------------------------------------------------
  39
  40  OUTPUTS:      n/a
  41
  42 ----------------------------------------------------------------------
  43
  44  CALLED BY:    uiuc_menu()
  45
  46 ----------------------------------------------------------------------
  47
  48  CALLS TO:     check_float() if needed
  49                d_2_to_3() if needed
  50                d_1_to_2() if needed
  51                i_1_to_2() if needed
  52                d_1_to_1() if needed
  53
  54  ----------------------------------------------------------------------
  55
  56  COPYRIGHT:    (C) 2003 by Michael Selig
  57
  58  This program is free software; you can redistribute it and/or
  59  modify it under the terms of the GNU General Public License
  60  as published by the Free Software Foundation.
  61
  62  This program is distributed in the hope that it will be useful,
  63  but WITHOUT ANY WARRANTY; without even the implied warranty of
  64  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  65  GNU General Public License for more details.
  66
  67  You should have received a copy of the GNU General Public License
  68  along with this program; if not, write to the Free Software
  69  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  70
  71 **********************************************************************/
  72
  73 #include <simgear/compiler.h>
  74
  75
  76 #include <cstdlib>
  77 #include <string>
  78 #include STL_IOSTREAM
  79
  80 #include "uiuc_menu_Cn.h"
  81
  82 SG_USING_STD(cerr);
  83 SG_USING_STD(cout);
  84 SG_USING_STD(endl);
  85
  86 #ifndef _MSC_VER
  87 SG_USING_STD(exit);
  88 #endif
  89
  90 void parse_Cn( const string& linetoken2, const string& linetoken3,
  91                const string& linetoken4, const string& linetoken5,
  92                const string& linetoken6, const string& linetoken7,
  93                const string& linetoken8, const string& linetoken9,
  94                const string& linetoken10, const string& aircraft_directory,
  95                LIST command_line ) {
  96     double token_value;
  97     int token_value_convert1, token_value_convert2, token_value_convert3;
  98     int token_value_convert4;
  99     double datafile_xArray[100][100], datafile_yArray[100];
 100     double datafile_zArray[100][100];
 101     double convert_f;
 102     int datafile_nxArray[100], datafile_ny;
 103     istringstream token3(linetoken3.c_str());
 104     istringstream token4(linetoken4.c_str());
 105     istringstream token5(linetoken5.c_str());
 106     istringstream token6(linetoken6.c_str());
 107     istringstream token7(linetoken7.c_str());
 108     istringstream token8(linetoken8.c_str());
 109     istringstream token9(linetoken9.c_str());
 110     istringstream token10(linetoken10.c_str());
 111
 112     static bool Cnfabetaf_first = true;
 113     static bool Cnfadaf_first = true;
 114     static bool Cnfadrf_first = true;
 115     static bool Cnfapf_first = true;
 116     static bool Cnfarf_first = true;
 117
 118     switch(Cn_map[linetoken2])
 119       {
 120       case Cno_flag:
 121         {
 122           if (check_float(linetoken3))
 123             token3 >> token_value;
 124           else
 125             uiuc_warnings_errors(1, *command_line);
 126
 127           Cno = token_value;
 128           Cno_clean = Cno;
 129           aeroYawParts -> storeCommands (*command_line);
 130           break;
 131         }
 132       case Cn_beta_flag:
 133         {
 134           if (check_float(linetoken3))
 135             token3 >> token_value;
 136           else
 137             uiuc_warnings_errors(1, *command_line);
 138
 139           Cn_beta = token_value;
 140           Cn_beta_clean = Cn_beta;
 141           aeroYawParts -> storeCommands (*command_line);
 142           break;
 143         }
 144       case Cn_p_flag:
 145         {
 146           if (check_float(linetoken3))
 147             token3 >> token_value;
 148           else
 149             uiuc_warnings_errors(1, *command_line);
 150
 151           Cn_p = token_value;
 152           Cn_p_clean = Cn_p;
 153           aeroYawParts -> storeCommands (*command_line);
 154           break;
 155         }
 156       case Cn_r_flag:
 157         {
 158           if (check_float(linetoken3))
 159             token3 >> token_value;
 160           else
 161             uiuc_warnings_errors(1, *command_line);
 162
 163           Cn_r = token_value;
 164           Cn_r_clean = Cn_r;
 165           aeroYawParts -> storeCommands (*command_line);
 166           break;
 167         }
 168       case Cn_da_flag:
 169         {
 170           if (check_float(linetoken3))
 171             token3 >> token_value;
 172           else
 173             uiuc_warnings_errors(1, *command_line);
 174
 175           Cn_da = token_value;
 176           Cn_da_clean = Cn_da;
 177           aeroYawParts -> storeCommands (*command_line);
 178           break;
 179         }
 180       case Cn_dr_flag:
 181         {
 182           if (check_float(linetoken3))
 183             token3 >> token_value;
 184           else
 185             uiuc_warnings_errors(1, *command_line);
 186
 187           Cn_dr = token_value;
 188           Cn_dr_clean = Cn_dr;
 189           aeroYawParts -> storeCommands (*command_line);
 190           break;
 191         }
 192       case Cn_q_flag:
 193         {
 194           if (check_float(linetoken3))
 195             token3 >> token_value;
 196           else
 197             uiuc_warnings_errors(1, *command_line);
 198
 199           Cn_q = token_value;
 200           Cn_q_clean = Cn_q;
 201           aeroYawParts -> storeCommands (*command_line);
 202           break;
 203         }
 204       case Cn_b3_flag:
 205         {
 206           if (check_float(linetoken3))
 207             token3 >> token_value;
 208           else
 209             uiuc_warnings_errors(1, *command_line);
 210
 211           Cn_b3 = token_value;
 212           Cn_b3_clean = Cn_b3;
 213           aeroYawParts -> storeCommands (*command_line);
 214           break;
 215         }
 216       case Cnfada_flag:
 217         {
 218           Cnfada = aircraft_directory + linetoken3;
 219           token4 >> token_value_convert1;
 220           token5 >> token_value_convert2;
 221           token6 >> token_value_convert3;
 222           convert_z = uiuc_convert(token_value_convert1);
 223           convert_x = uiuc_convert(token_value_convert2);
 224           convert_y = uiuc_convert(token_value_convert3);
 225           /* call 2D File Reader with file name (Cnfada) and
 226              conversion factors; function returns array of
 227              aileron deflections (daArray) and corresponding
 228              alpha (aArray) and delta Cn (CnArray) values and
 229              max number of terms in alpha arrays (nAlphaArray)
 230              and deflection array (nda) */
 231           uiuc_2DdataFileReader(Cnfada,
 232                                 Cnfada_aArray,
 233                                 Cnfada_daArray,
 234                                 Cnfada_CnArray,
 235                                 Cnfada_nAlphaArray,
 236                                 Cnfada_nda);
 237           aeroYawParts -> storeCommands (*command_line);
 238           break;
 239         }
 240       case Cnfbetadr_flag:
 241         {
 242           Cnfbetadr = aircraft_directory + linetoken3;
 243           token4 >> token_value_convert1;
 244           token5 >> token_value_convert2;
 245           token6 >> token_value_convert3;
 246           convert_z = uiuc_convert(token_value_convert1);
 247           convert_x = uiuc_convert(token_value_convert2);
 248           convert_y = uiuc_convert(token_value_convert3);
 249           /* call 2D File Reader with file name (Cnfbetadr) and
 250              conversion factors; function returns array of
 251              rudder deflections (drArray) and corresponding
 252              beta (betaArray) and delta Cn (CnArray) values and
 253              max number of terms in beta arrays (nBetaArray)
 254              and deflection array (ndr) */
 255           uiuc_2DdataFileReader(Cnfbetadr,
 256                                 Cnfbetadr_betaArray,
 257                                 Cnfbetadr_drArray,
 258                                 Cnfbetadr_CnArray,
 259                                 Cnfbetadr_nBetaArray,
 260                                 Cnfbetadr_ndr);
 261           aeroYawParts -> storeCommands (*command_line);
 262           break;
 263         }
 264       case Cnfabetaf_flag:
 265         {
 266           int Cnfabetaf_index, i;
 267           string Cnfabetaf_file;
 268           double flap_value;
 269           Cnfabetaf_file = aircraft_directory + linetoken3;
 270           token4 >> Cnfabetaf_index;
 271           if (Cnfabetaf_index < 0 || Cnfabetaf_index >= 100)
 272             uiuc_warnings_errors(1, *command_line);
 273           if (Cnfabetaf_index > Cnfabetaf_nf)
 274             Cnfabetaf_nf = Cnfabetaf_index;
 275           token5 >> flap_value;
 276           token6 >> token_value_convert1;
 277           token7 >> token_value_convert2;
 278           token8 >> token_value_convert3;
 279           token9 >> token_value_convert4;
 280           token10 >> Cnfabetaf_nice;
 281           convert_z = uiuc_convert(token_value_convert1);
 282           convert_x = uiuc_convert(token_value_convert2);
 283           convert_y = uiuc_convert(token_value_convert3);
 284           convert_f = uiuc_convert(token_value_convert4);
 285           Cnfabetaf_fArray[Cnfabetaf_index] = flap_value * convert_f;
 286           /* call 2D File Reader with file name (Cnfabetaf_file) and
 287              conversion factors; function returns array of
 288              elevator deflections (deArray) and corresponding
 289              alpha (aArray) and delta CZ (CZArray) values and
 290              max number of terms in alpha arrays (nAlphaArray)
 291              and delfection array (nde) */
 292           uiuc_2DdataFileReader(Cnfabetaf_file,
 293                                 datafile_xArray,
 294                                 datafile_yArray,
 295                                 datafile_zArray,
 296                                 datafile_nxArray,
 297                                 datafile_ny);
 298           d_2_to_3(datafile_xArray, Cnfabetaf_aArray, Cnfabetaf_index);
 299           d_1_to_2(datafile_yArray, Cnfabetaf_betaArray, Cnfabetaf_index);
 300           d_2_to_3(datafile_zArray, Cnfabetaf_CnArray, Cnfabetaf_index);
 301           i_1_to_2(datafile_nxArray, Cnfabetaf_nAlphaArray, Cnfabetaf_index);
 302           Cnfabetaf_nbeta[Cnfabetaf_index] = datafile_ny;
 303           if (Cnfabetaf_first==true)
 304             {
 305               if (Cnfabetaf_nice == 1)
 306                 {
 307                   Cnfabetaf_na_nice = datafile_nxArray[1];
 308                   Cnfabetaf_nb_nice = datafile_ny;
 309                   d_1_to_1(datafile_yArray, Cnfabetaf_bArray_nice);
 310                   for (i=1; i<=Cnfabetaf_na_nice; i++)
 311                     Cnfabetaf_aArray_nice[i] = datafile_xArray[1][i];
 312                 }
 313               aeroYawParts -> storeCommands (*command_line);
 314               Cnfabetaf_first=false;
 315             }
 316           break;
 317         }
 318       case Cnfadaf_flag:
 319         {
 320           int Cnfadaf_index, i;
 321           string Cnfadaf_file;
 322           double flap_value;
 323           Cnfadaf_file = aircraft_directory + linetoken3;
 324           token4 >> Cnfadaf_index;
 325           if (Cnfadaf_index < 0 || Cnfadaf_index >= 100)
 326             uiuc_warnings_errors(1, *command_line);
 327           if (Cnfadaf_index > Cnfadaf_nf)
 328             Cnfadaf_nf = Cnfadaf_index;
 329           token5 >> flap_value;
 330           token6 >> token_value_convert1;
 331           token7 >> token_value_convert2;
 332           token8 >> token_value_convert3;
 333           token9 >> token_value_convert4;
 334           token10 >> Cnfadaf_nice;
 335           convert_z = uiuc_convert(token_value_convert1);
 336           convert_x = uiuc_convert(token_value_convert2);
 337           convert_y = uiuc_convert(token_value_convert3);
 338           convert_f = uiuc_convert(token_value_convert4);
 339           Cnfadaf_fArray[Cnfadaf_index] = flap_value * convert_f;
 340           /* call 2D File Reader with file name (Cnfadaf_file) and
 341              conversion factors; function returns array of
 342              elevator deflections (deArray) and corresponding
 343              alpha (aArray) and delta CZ (CZArray) values and
 344              max number of terms in alpha arrays (nAlphaArray)
 345              and delfection array (nde) */
 346           uiuc_2DdataFileReader(Cnfadaf_file,
 347                                 datafile_xArray,
 348                                 datafile_yArray,
 349                                 datafile_zArray,
 350                                 datafile_nxArray,
 351                                 datafile_ny);
 352           d_2_to_3(datafile_xArray, Cnfadaf_aArray, Cnfadaf_index);
 353           d_1_to_2(datafile_yArray, Cnfadaf_daArray, Cnfadaf_index);
 354           d_2_to_3(datafile_zArray, Cnfadaf_CnArray, Cnfadaf_index);
 355           i_1_to_2(datafile_nxArray, Cnfadaf_nAlphaArray, Cnfadaf_index);
 356           Cnfadaf_nda[Cnfadaf_index] = datafile_ny;
 357           if (Cnfadaf_first==true)
 358             {
 359               if (Cnfadaf_nice == 1)
 360                 {
 361                   Cnfadaf_na_nice = datafile_nxArray[1];
 362                   Cnfadaf_nda_nice = datafile_ny;
 363                   d_1_to_1(datafile_yArray, Cnfadaf_daArray_nice);
 364                   for (i=1; i<=Cnfadaf_na_nice; i++)
 365                     Cnfadaf_aArray_nice[i] = datafile_xArray[1][i];
 366                 }
 367               aeroYawParts -> storeCommands (*command_line);
 368               Cnfadaf_first=false;
 369             }
 370           break;
 371         }
 372       case Cnfadrf_flag:
 373         {
 374           int Cnfadrf_index, i;
 375           string Cnfadrf_file;
 376           double flap_value;
 377           Cnfadrf_file = aircraft_directory + linetoken3;
 378           token4 >> Cnfadrf_index;
 379           if (Cnfadrf_index < 0 || Cnfadrf_index >= 100)
 380             uiuc_warnings_errors(1, *command_line);
 381           if (Cnfadrf_index > Cnfadrf_nf)
 382             Cnfadrf_nf = Cnfadrf_index;
 383           token5 >> flap_value;
 384           token6 >> token_value_convert1;
 385           token7 >> token_value_convert2;
 386           token8 >> token_value_convert3;
 387           token9 >> token_value_convert4;
 388           token10 >> Cnfadrf_nice;
 389           convert_z = uiuc_convert(token_value_convert1);
 390           convert_x = uiuc_convert(token_value_convert2);
 391           convert_y = uiuc_convert(token_value_convert3);
 392           convert_f = uiuc_convert(token_value_convert4);
 393           Cnfadrf_fArray[Cnfadrf_index] = flap_value * convert_f;
 394           /* call 2D File Reader with file name (Cnfadrf_file) and
 395              conversion factors; function returns array of
 396              elevator deflections (deArray) and corresponding
 397              alpha (aArray) and delta CZ (CZArray) values and
 398              max number of terms in alpha arrays (nAlphaArray)
 399              and delfection array (nde) */
 400           uiuc_2DdataFileReader(Cnfadrf_file,
 401                                 datafile_xArray,
 402                                 datafile_yArray,
 403                                 datafile_zArray,
 404                                 datafile_nxArray,
 405                                 datafile_ny);
 406           d_2_to_3(datafile_xArray, Cnfadrf_aArray, Cnfadrf_index);
 407           d_1_to_2(datafile_yArray, Cnfadrf_drArray, Cnfadrf_index);
 408           d_2_to_3(datafile_zArray, Cnfadrf_CnArray, Cnfadrf_index);
 409           i_1_to_2(datafile_nxArray, Cnfadrf_nAlphaArray, Cnfadrf_index);
 410           Cnfadrf_ndr[Cnfadrf_index] = datafile_ny;
 411           if (Cnfadrf_first==true)
 412             {
 413               if (Cnfadrf_nice == 1)
 414                 {
 415                   Cnfadrf_na_nice = datafile_nxArray[1];
 416                   Cnfadrf_ndr_nice = datafile_ny;
 417                   d_1_to_1(datafile_yArray, Cnfadrf_drArray_nice);
 418                   for (i=1; i<=Cnfadrf_na_nice; i++)
 419                     Cnfadrf_aArray_nice[i] = datafile_xArray[1][i];
 420                 }
 421               aeroYawParts -> storeCommands (*command_line);
 422               Cnfadrf_first=false;
 423             }
 424           break;
 425         }
 426       case Cnfapf_flag:
 427         {
 428           int Cnfapf_index, i;
 429           string Cnfapf_file;
 430           double flap_value;
 431           Cnfapf_file = aircraft_directory + linetoken3;
 432           token4 >> Cnfapf_index;
 433           if (Cnfapf_index < 0 || Cnfapf_index >= 100)
 434             uiuc_warnings_errors(1, *command_line);
 435           if (Cnfapf_index > Cnfapf_nf)
 436             Cnfapf_nf = Cnfapf_index;
 437           token5 >> flap_value;
 438           token6 >> token_value_convert1;
 439           token7 >> token_value_convert2;
 440           token8 >> token_value_convert3;
 441           token9 >> token_value_convert4;
 442           token10 >> Cnfapf_nice;
 443           convert_z = uiuc_convert(token_value_convert1);
 444           convert_x = uiuc_convert(token_value_convert2);
 445           convert_y = uiuc_convert(token_value_convert3);
 446           convert_f = uiuc_convert(token_value_convert4);
 447           Cnfapf_fArray[Cnfapf_index] = flap_value * convert_f;
 448           /* call 2D File Reader with file name (Cnfapf_file) and
 449              conversion factors; function returns array of
 450              elevator deflections (deArray) and corresponding
 451              alpha (aArray) and delta CZ (CZArray) values and
 452              max number of terms in alpha arrays (nAlphaArray)
 453              and delfection array (nde) */
 454           uiuc_2DdataFileReader(Cnfapf_file,
 455                                 datafile_xArray,
 456                                 datafile_yArray,
 457                                 datafile_zArray,
 458                                 datafile_nxArray,
 459                                 datafile_ny);
 460           d_2_to_3(datafile_xArray, Cnfapf_aArray, Cnfapf_index);
 461           d_1_to_2(datafile_yArray, Cnfapf_pArray, Cnfapf_index);
 462           d_2_to_3(datafile_zArray, Cnfapf_CnArray, Cnfapf_index);
 463           i_1_to_2(datafile_nxArray, Cnfapf_nAlphaArray, Cnfapf_index);
 464           Cnfapf_np[Cnfapf_index] = datafile_ny;
 465           if (Cnfapf_first==true)
 466             {
 467               if (Cnfapf_nice == 1)
 468                 {
 469                   Cnfapf_na_nice = datafile_nxArray[1];
 470                   Cnfapf_np_nice = datafile_ny;
 471                   d_1_to_1(datafile_yArray, Cnfapf_pArray_nice);
 472                   for (i=1; i<=Cnfapf_na_nice; i++)
 473                     Cnfapf_aArray_nice[i] = datafile_xArray[1][i];
 474                 }
 475               aeroYawParts -> storeCommands (*command_line);
 476               Cnfapf_first=false;
 477             }
 478           break;
 479         }
 480       case Cnfarf_flag:
 481         {
 482           int Cnfarf_index, i;
 483           string Cnfarf_file;
 484           double flap_value;
 485           Cnfarf_file = aircraft_directory + linetoken3;
 486           token4 >> Cnfarf_index;
 487           if (Cnfarf_index < 0 || Cnfarf_index >= 100)
 488             uiuc_warnings_errors(1, *command_line);
 489           if (Cnfarf_index > Cnfarf_nf)
 490             Cnfarf_nf = Cnfarf_index;
 491           token5 >> flap_value;
 492           token6 >> token_value_convert1;
 493           token7 >> token_value_convert2;
 494           token8 >> token_value_convert3;
 495           token9 >> token_value_convert4;
 496           token10 >> Cnfarf_nice;
 497           convert_z = uiuc_convert(token_value_convert1);
 498           convert_x = uiuc_convert(token_value_convert2);
 499           convert_y = uiuc_convert(token_value_convert3);
 500           convert_f = uiuc_convert(token_value_convert4);
 501           Cnfarf_fArray[Cnfarf_index] = flap_value * convert_f;
 502           /* call 2D File Reader with file name (Cnfarf_file) and
 503              conversion factors; function returns array of
 504              elevator deflections (deArray) and corresponding
 505              alpha (aArray) and delta CZ (CZArray) values and
 506              max number of terms in alpha arrays (nAlphaArray)
 507              and delfection array (nde) */
 508           uiuc_2DdataFileReader(Cnfarf_file,
 509                                 datafile_xArray,
 510                                 datafile_yArray,
 511                                 datafile_zArray,
 512                                 datafile_nxArray,
 513                                 datafile_ny);
 514           d_2_to_3(datafile_xArray, Cnfarf_aArray, Cnfarf_index);
 515           d_1_to_2(datafile_yArray, Cnfarf_rArray, Cnfarf_index);
 516           d_2_to_3(datafile_zArray, Cnfarf_CnArray, Cnfarf_index);
 517           i_1_to_2(datafile_nxArray, Cnfarf_nAlphaArray, Cnfarf_index);
 518           Cnfarf_nr[Cnfarf_index] = datafile_ny;
 519           if (Cnfarf_first==true)
 520             {
 521               if (Cnfarf_nice == 1)
 522                 {
 523                   Cnfarf_na_nice = datafile_nxArray[1];
 524                   Cnfarf_nr_nice = datafile_ny;
 525                   d_1_to_1(datafile_yArray, Cnfarf_rArray_nice);
 526                   for (i=1; i<=Cnfarf_na_nice; i++)
 527                     Cnfarf_aArray_nice[i] = datafile_xArray[1][i];
 528                 }
 529               aeroYawParts -> storeCommands (*command_line);
 530               Cnfarf_first=false;
 531             }
 532           break;
 533         }
 534       default:
 535         {
 536           if (ignore_unknown_keywords) {
 537             // do nothing
 538           } else {
 539             // print error message
 540             uiuc_warnings_errors(2, *command_line);
 541           }
 542           break;
 543         }
 544       };
 545 }