src/FDM/UIUCModel/uiuc_coef_lift.cpp

   1 /**********************************************************************
   2
   3  FILENAME:     uiuc_coef_lift.cpp
   4
   5 ----------------------------------------------------------------------
   6
   7  DESCRIPTION:  computes aggregated aerodynamic lift coefficient
   8
   9 ----------------------------------------------------------------------
  10
  11  STATUS:       alpha version
  12
  13 ----------------------------------------------------------------------
  14
  15  REFERENCES:   Roskam, Jan.  Airplane Flight Dynamics and Automatic
  16                Flight Controls, Part I.  Lawrence, KS: DARcorporation,
  17                1995.
  18
  19 ----------------------------------------------------------------------
  20
  21  HISTORY:      04/15/2000   initial release
  22                06/18/2001   (RD) Added CZfa
  23                10/25/2001   (RD) Added new variables needed for the non-
  24                             linear Twin Otter model at zero flaps
  25                             (CZfxxf0)
  26                11/12/2001   (RD) Added new variables needed for the non-
  27                             linear Twin Otter model with flaps
  28                             (CZfxxf).  Zero flap vairables removed.
  29                02/13/2002   (RD) Added variables so linear aero model
  30                             values can be recorded
  31                02/18/2002   (RD) Added uiuc_3Dinterp_quick() function
  32                             for a quicker 3D interpolation.  Takes
  33                             advantage of "nice" data.
  34
  35 ----------------------------------------------------------------------
  36
  37  AUTHOR(S):    Bipin Sehgal       <bsehgal@uiuc.edu>
  38                Jeff Scott         <jscott@mail.com>
  39                Robert Deters      <rdeters@uiuc.edu>
  40
  41 ----------------------------------------------------------------------
  42
  43  VARIABLES:
  44
  45 ----------------------------------------------------------------------
  46
  47  INPUTS:       -Alpha
  48                -elevator
  49                -lift coefficient components
  50                -icing parameters
  51                -cbar_2U multiplier
  52
  53 ----------------------------------------------------------------------
  54
  55  OUTPUTS:      -CL
  56
  57 ----------------------------------------------------------------------
  58
  59  CALLED BY:    uiuc_coefficients.cpp
  60
  61 ----------------------------------------------------------------------
  62
  63  CALLS TO:     uiuc_1Dinterpolation
  64                uiuc_2Dinterpolation
  65                uiuc_ice_filter
  66                uiuc_3Dinterpolation
  67                uiuc_3Dinterp_quick
  68
  69 ----------------------------------------------------------------------
  70
  71  COPYRIGHT:    (C) 2000 by Michael Selig
  72
  73  This program is free software; you can redistribute it and/or
  74  modify it under the terms of the GNU General Public License
  75  as published by the Free Software Foundation.
  76
  77  This program is distributed in the hope that it will be useful,
  78  but WITHOUT ANY WARRANTY; without even the implied warranty of
  79  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  80  GNU General Public License for more details.
  81
  82  You should have received a copy of the GNU General Public License
  83  along with this program; if not, write to the Free Software
  84  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  85
  86 **********************************************************************/
  87
  88 #include "uiuc_coef_lift.h"
  89
  90 void uiuc_coef_lift()
  91 {
  92   string linetoken1;
  93   string linetoken2;
  94   stack command_list;
  95
  96   double q_nondim;
  97
  98   command_list = aeroLiftParts -> getCommands();
  99
 100   for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
 101     {
 102       linetoken1 = aeroLiftParts -> getToken(*command_line, 1);
 103       linetoken2 = aeroLiftParts -> getToken(*command_line, 2);
 104
 105       switch (CL_map[linetoken2])
 106         {
 107         case CLo_flag:
 108           {
 109             if (ice_on)
 110               {
 111                 CLo = uiuc_ice_filter(CLo_clean,kCLo);
 112                 if (beta_model)
 113                   {
 114                     CLclean_wing += CLo_clean;
 115                     CLclean_tail += CLo_clean;
 116                     CLiced_wing += CLo;
 117                     CLiced_tail += CLo;
 118                   }
 119               }
 120             CLo_save = CLo;
 121             CL += CLo_save;
 122             break;
 123           }
 124         case CL_a_flag:
 125           {
 126             if (ice_on)
 127               {
 128                 CL_a = uiuc_ice_filter(CL_a_clean,kCL_a);
 129                 if (beta_model)
 130                   {
 131                     CLclean_wing += CL_a_clean * Std_Alpha;
 132                     CLclean_tail += CL_a_clean * Std_Alpha;
 133                     CLiced_wing += CL_a * Std_Alpha;
 134                     CLiced_tail += CL_a * Std_Alpha;
 135                   }
 136               }
 137             CL_a_save = CL_a * Std_Alpha;
 138             CL += CL_a_save;
 139             break;
 140           }
 141         case CL_adot_flag:
 142           {
 143             if (ice_on)
 144               {
 145                 CL_adot = uiuc_ice_filter(CL_adot_clean,kCL_adot);
 146                 if (beta_model)
 147                   {
 148                     CLclean_wing += CL_adot_clean * Std_Alpha_dot * cbar_2U;
 149                     CLclean_tail += CL_adot_clean * Std_Alpha_dot * ch_2U;
 150                     CLiced_wing += CL_adot * Std_Alpha_dot * cbar_2U;
 151                     CLiced_tail += CL_adot * Std_Alpha_dot * ch_2U;
 152                   }
 153               }
 154             /* CL_adot must be mulitplied by cbar/2U
 155                (see Roskam Control book, Part 1, pg. 147) */
 156             CL_adot_save = CL_adot * Std_Alpha_dot * cbar_2U;
 157             CL += CL_adot_save;
 158             break;
 159           }
 160         case CL_q_flag:
 161           {
 162             if (ice_on)
 163               {
 164                 CL_q = uiuc_ice_filter(CL_q_clean,kCL_q);
 165                 if (beta_model)
 166                   {
 167                     CLclean_wing += CL_q_clean * Theta_dot * cbar_2U;
 168                     CLclean_tail += CL_q_clean * Theta_dot * ch_2U;
 169                     CLiced_wing += CL_q * Theta_dot * cbar_2U;
 170                     CLiced_tail += CL_q * Theta_dot * ch_2U;
 171                   }
 172               }
 173             /* CL_q must be mulitplied by cbar/2U
 174                (see Roskam Control book, Part 1, pg. 147) */
 175             /* why multiply by Theta_dot instead of Q_body?
 176                that is what is done in c172_aero.c; assume it
 177                has something to do with axes systems */
 178             CL_q_save = CL_q * Theta_dot * cbar_2U;
 179             CL += CL_q_save;
 180             break;
 181           }
 182         case CL_ih_flag:
 183           {
 184             CL_ih_save = CL_ih * ih;
 185             CL += CL_ih_save;
 186             break;
 187           }
 188         case CL_de_flag:
 189           {
 190             if (ice_on)
 191               {
 192                 CL_de = uiuc_ice_filter(CL_de_clean,kCL_de);
 193                 if (beta_model)
 194                   {
 195                     CLclean_wing += CL_de_clean * elevator;
 196                     CLclean_tail += CL_de_clean * elevator;
 197                     CLiced_wing += CL_de * elevator;
 198                     CLiced_tail += CL_de * elevator;
 199                   }
 200               }
 201             CL_de_save = CL_de * elevator;
 202             CL += CL_de_save;
 203             break;
 204           }
 205         case CL_df_flag:
 206           {
 207             CL_df_save = CL_df * flap_pos;
 208             CL += CL_df_save;
 209             break;
 210           }
 211         case CL_ds_flag:
 212           {
 213             CL_ds_save = CL_ds * spoiler_pos;
 214             CL += CL_ds_save;
 215             break;
 216           }
 217         case CL_dg_flag:
 218           {
 219             CL_dg_save = CL_dg * gear_pos_norm;
 220             CL += CL_dg_save;
 221             break;
 222           }
 223         case CLfa_flag:
 224           {
 225             CLfaI = uiuc_1Dinterpolation(CLfa_aArray,
 226                                          CLfa_CLArray,
 227                                          CLfa_nAlpha,
 228                                          Std_Alpha);
 229             CL += CLfaI;
 230             break;
 231           }
 232         case CLfade_flag:
 233           {
 234             CLfadeI = uiuc_2Dinterpolation(CLfade_aArray,
 235                                            CLfade_deArray,
 236                                            CLfade_CLArray,
 237                                            CLfade_nAlphaArray,
 238                                            CLfade_nde,
 239                                            Std_Alpha,
 240                                            elevator);
 241             CL += CLfadeI;
 242             break;
 243           }
 244         case CLfdf_flag:
 245           {
 246             CLfdfI = uiuc_1Dinterpolation(CLfdf_dfArray,
 247                                           CLfdf_CLArray,
 248                                           CLfdf_ndf,
 249                                           flap_pos);
 250             CL += CLfdfI;
 251             break;
 252           }
 253         case CLfadf_flag:
 254           {
 255             CLfadfI = uiuc_2Dinterpolation(CLfadf_aArray,
 256                                            CLfadf_dfArray,
 257                                            CLfadf_CLArray,
 258                                            CLfadf_nAlphaArray,
 259                                            CLfadf_ndf,
 260                                            Std_Alpha,
 261                                            flap_pos);
 262             CL += CLfadfI;
 263             break;
 264           }
 265         case CZo_flag:
 266           {
 267             if (ice_on)
 268               {
 269                 CZo = uiuc_ice_filter(CZo_clean,kCZo);
 270                 if (beta_model)
 271                   {
 272                     CZclean_wing += CZo_clean;
 273                     CZclean_tail += CZo_clean;
 274                     CZiced_wing += CZo;
 275                     CZiced_tail += CZo;
 276                   }
 277               }
 278             CZo_save = CZo;
 279             CZ += CZo_save;
 280             break;
 281           }
 282         case CZ_a_flag:
 283           {
 284             if (ice_on)
 285               {
 286                 CZ_a = uiuc_ice_filter(CZ_a_clean,kCZ_a);
 287                 if (beta_model)
 288                   {
 289                     CZclean_wing += CZ_a_clean * Std_Alpha;
 290                     CZclean_tail += CZ_a_clean * Std_Alpha;
 291                     CZiced_wing += CZ_a * Std_Alpha;
 292                     CZiced_tail += CZ_a * Std_Alpha;
 293                   }
 294               }
 295             CZ_a_save = CZ_a * Std_Alpha;
 296             CZ += CZ_a_save;
 297             break;
 298           }
 299         case CZ_a2_flag:
 300           {
 301             if (ice_on)
 302               {
 303                 CZ_a2 = uiuc_ice_filter(CZ_a2_clean,kCZ_a2);
 304                 if (beta_model)
 305                   {
 306                     CZclean_wing += CZ_a2_clean * Std_Alpha * Std_Alpha;
 307                     CZclean_tail += CZ_a2_clean * Std_Alpha * Std_Alpha;
 308                     CZiced_wing += CZ_a2 * Std_Alpha * Std_Alpha;
 309                     CZiced_tail += CZ_a2 * Std_Alpha * Std_Alpha;
 310                   }
 311               }
 312             CZ_a2_save = CZ_a2 * Std_Alpha * Std_Alpha;
 313             CZ += CZ_a2_save;
 314             break;
 315           }
 316         case CZ_a3_flag:
 317           {
 318             if (ice_on)
 319               {
 320                 CZ_a3 = uiuc_ice_filter(CZ_a3_clean,kCZ_a3);
 321                 if (beta_model)
 322                   {
 323                     CZclean_wing += CZ_a3_clean * Std_Alpha * Std_Alpha * Std_Alpha;
 324                     CZclean_tail += CZ_a3_clean * Std_Alpha * Std_Alpha * Std_Alpha;
 325                     CZiced_wing += CZ_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
 326                     CZiced_tail += CZ_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
 327                   }
 328               }
 329             CZ_a3_save = CZ_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
 330             CZ += CZ_a3_save;
 331             break;
 332           }
 333         case CZ_adot_flag:
 334           {
 335             if (ice_on)
 336               {
 337                 CZ_adot = uiuc_ice_filter(CZ_adot_clean,kCZ_adot);
 338                 if (beta_model)
 339                   {
 340                     CZclean_wing += CZ_adot_clean * Std_Alpha_dot * cbar_2U;
 341                     CZclean_tail += CZ_adot_clean * Std_Alpha_dot * ch_2U;
 342                     CZiced_wing += CZ_adot * Std_Alpha_dot * cbar_2U;
 343                     CZiced_tail += CZ_adot * Std_Alpha_dot * ch_2U;
 344                   }
 345               }
 346             /* CZ_adot must be mulitplied by cbar/2U
 347                (see Roskam Control book, Part 1, pg. 147) */
 348             CZ_adot_save = CZ_adot * Std_Alpha_dot * cbar_2U;
 349             CZ += CZ_adot_save;
 350             break;
 351           }
 352         case CZ_q_flag:
 353           {
 354             if (ice_on)
 355               {
 356                 CZ_q = uiuc_ice_filter(CZ_q_clean,kCZ_q);
 357                 if (beta_model)
 358                   {
 359                     CZclean_wing += CZ_q_clean * Q_body * cbar_2U;
 360                     CZclean_tail += CZ_q_clean * Q_body * ch_2U;
 361                     CZiced_wing += CZ_q * Q_body * cbar_2U;
 362                     CZiced_tail += CZ_q * Q_body * ch_2U;
 363                   }
 364               }
 365             /* CZ_q must be mulitplied by cbar/2U
 366                (see Roskam Control book, Part 1, pg. 147) */
 367             CZ_q_save = CZ_q * Q_body * cbar_2U;
 368             CZ += CZ_q_save;
 369             break;
 370           }
 371         case CZ_de_flag:
 372           {
 373             if (ice_on)
 374               {
 375                 CZ_de = uiuc_ice_filter(CZ_de_clean,kCZ_de);
 376                 if (beta_model)
 377                   {
 378                     CZclean_wing += CZ_de_clean * elevator;
 379                     CZclean_tail += CZ_de_clean * elevator;
 380                     CZiced_wing += CZ_de * elevator;
 381                     CZiced_tail += CZ_de * elevator;
 382                   }
 383               }
 384             CZ_de_save = CZ_de * elevator;
 385             CZ += CZ_de_save;
 386             break;
 387           }
 388         case CZ_deb2_flag:
 389           {
 390             if (ice_on)
 391               {
 392                 CZ_deb2 = uiuc_ice_filter(CZ_deb2_clean,kCZ_deb2);
 393                 if (beta_model)
 394                   {
 395                     CZclean_wing += CZ_deb2_clean * elevator * Std_Beta * Std_Beta;
 396                     CZclean_tail += CZ_deb2_clean * elevator * Std_Beta * Std_Beta;
 397                     CZiced_wing += CZ_deb2 * elevator * Std_Beta * Std_Beta;
 398                     CZiced_tail += CZ_deb2 * elevator * Std_Beta * Std_Beta;
 399                   }
 400               }
 401             CZ_deb2_save = CZ_deb2 * elevator * Std_Beta * Std_Beta;
 402             CZ += CZ_deb2_save;
 403             break;
 404           }
 405         case CZ_df_flag:
 406           {
 407             if (ice_on)
 408               {
 409                 CZ_df = uiuc_ice_filter(CZ_df_clean,kCZ_df);
 410                 if (beta_model)
 411                   {
 412                     CZclean_wing += CZ_df_clean * flap_pos;
 413                     CZclean_tail += CZ_df_clean * flap_pos;
 414                     CZiced_wing += CZ_df * flap_pos;
 415                     CZiced_tail += CZ_df * flap_pos;
 416                   }
 417               }
 418             CZ_df_save = CZ_df * flap_pos;
 419             CZ += CZ_df_save;
 420             break;
 421           }
 422         case CZ_adf_flag:
 423           {
 424             if (ice_on)
 425               {
 426                 CZ_adf = uiuc_ice_filter(CZ_adf_clean,kCZ_adf);
 427                 if (beta_model)
 428                   {
 429                     CZclean_wing += CZ_adf_clean * Std_Alpha * flap_pos;
 430                     CZclean_tail += CZ_adf_clean * Std_Alpha * flap_pos;
 431                     CZiced_wing += CZ_adf * Std_Alpha * flap_pos;
 432                     CZiced_tail += CZ_adf * Std_Alpha * flap_pos;
 433                   }
 434               }
 435             CZ_adf_save = CZ_adf * Std_Alpha * flap_pos;
 436             CZ += CZ_adf_save;
 437             break;
 438           }
 439         case CZfa_flag:
 440           {
 441             CZfaI = uiuc_1Dinterpolation(CZfa_aArray,
 442                                          CZfa_CZArray,
 443                                          CZfa_nAlpha,
 444                                          Std_Alpha);
 445             CZ += CZfaI;
 446             break;
 447           }
 448         case CZfabetaf_flag:
 449           {
 450             if (CZfabetaf_nice == 1)
 451               CZfabetafI = uiuc_3Dinterp_quick(CZfabetaf_fArray,
 452                                                CZfabetaf_aArray_nice,
 453                                                CZfabetaf_bArray_nice,
 454                                                CZfabetaf_CZArray,
 455                                                CZfabetaf_na_nice,
 456                                                CZfabetaf_nb_nice,
 457                                                CZfabetaf_nf,
 458                                                flap_pos,
 459                                                Std_Alpha,
 460                                                Std_Beta);
 461             else
 462               CZfabetafI = uiuc_3Dinterpolation(CZfabetaf_fArray,
 463                                                 CZfabetaf_aArray,
 464                                                 CZfabetaf_betaArray,
 465                                                 CZfabetaf_CZArray,
 466                                                 CZfabetaf_nAlphaArray,
 467                                                 CZfabetaf_nbeta,
 468                                                 CZfabetaf_nf,
 469                                                 flap_pos,
 470                                                 Std_Alpha,
 471                                                 Std_Beta);
 472             CZ += CZfabetafI;
 473             break;
 474           }
 475         case CZfadef_flag:
 476           {
 477             if (CZfadef_nice == 1)
 478               CZfadefI = uiuc_3Dinterp_quick(CZfadef_fArray,
 479                                              CZfadef_aArray_nice,
 480                                              CZfadef_deArray_nice,
 481                                              CZfadef_CZArray,
 482                                              CZfadef_na_nice,
 483                                              CZfadef_nde_nice,
 484                                              CZfadef_nf,
 485                                              flap_pos,
 486                                              Std_Alpha,
 487                                              elevator);
 488             else
 489               CZfadefI = uiuc_3Dinterpolation(CZfadef_fArray,
 490                                               CZfadef_aArray,
 491                                               CZfadef_deArray,
 492                                               CZfadef_CZArray,
 493                                               CZfadef_nAlphaArray,
 494                                               CZfadef_nde,
 495                                               CZfadef_nf,
 496                                               flap_pos,
 497                                               Std_Alpha,
 498                                               elevator);
 499             CZ += CZfadefI;
 500             break;
 501           }
 502         case CZfaqf_flag:
 503           {
 504             q_nondim = Q_body * cbar_2U;
 505             if (CZfaqf_nice == 1)
 506               CZfaqfI = uiuc_3Dinterp_quick(CZfaqf_fArray,
 507                                             CZfaqf_aArray_nice,
 508                                             CZfaqf_qArray_nice,
 509                                             CZfaqf_CZArray,
 510                                             CZfaqf_na_nice,
 511                                             CZfaqf_nq_nice,
 512                                             CZfaqf_nf,
 513                                             flap_pos,
 514                                             Std_Alpha,
 515                                             q_nondim);
 516             else
 517               CZfaqfI = uiuc_3Dinterpolation(CZfaqf_fArray,
 518                                              CZfaqf_aArray,
 519                                              CZfaqf_qArray,
 520                                              CZfaqf_CZArray,
 521                                              CZfaqf_nAlphaArray,
 522                                              CZfaqf_nq,
 523                                              CZfaqf_nf,
 524                                              flap_pos,
 525                                              Std_Alpha,
 526                                              q_nondim);
 527             CZ += CZfaqfI;
 528             break;
 529           }
 530         };
 531     } // end CL map
 532
 533   return;
 534 }
 535
 536 // end uiuc_coef_lift.cpp