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