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