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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  85  USA or view http://www.gnu.org/copyleft/gpl.html.
  86
  87 **********************************************************************/
  88
  89 #include "uiuc_coef_lift.h"
  90
  91 void uiuc_coef_lift()
  92 {
  93   string linetoken1;
  94   string linetoken2;
  95   stack command_list;
  96
  97   double q_nondim;
  98
  99   command_list = aeroLiftParts -> getCommands();
 100
 101   for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
 102     {
 103       linetoken1 = aeroLiftParts -> getToken(*command_line, 1);
 104       linetoken2 = aeroLiftParts -> getToken(*command_line, 2);
 105
 106       switch (CL_map[linetoken2])
 107         {
 108         case CLo_flag:
 109           {
 110             if (ice_on)
 111               {
 112                 CLo = uiuc_ice_filter(CLo_clean,kCLo);
 113                 if (beta_model)
 114                   {
 115                     CLclean_wing += CLo_clean;
 116                     CLclean_tail += CLo_clean;
 117                     CLiced_wing += CLo;
 118                     CLiced_tail += CLo;
 119                   }
 120               }
 121             CLo_save = CLo;
 122             CL += CLo_save;
 123             break;
 124           }
 125         case CL_a_flag:
 126           {
 127             if (ice_on)
 128               {
 129                 CL_a = uiuc_ice_filter(CL_a_clean,kCL_a);
 130                 if (beta_model)
 131                   {
 132                     CLclean_wing += CL_a_clean * Std_Alpha;
 133                     CLclean_tail += CL_a_clean * Std_Alpha;
 134                     CLiced_wing += CL_a * Std_Alpha;
 135                     CLiced_tail += CL_a * Std_Alpha;
 136                   }
 137               }
 138             CL_a_save = CL_a * Std_Alpha;
 139             CL += CL_a_save;
 140             break;
 141           }
 142         case CL_adot_flag:
 143           {
 144             if (ice_on)
 145               {
 146                 CL_adot = uiuc_ice_filter(CL_adot_clean,kCL_adot);
 147                 if (beta_model)
 148                   {
 149                     CLclean_wing += CL_adot_clean * Std_Alpha_dot * cbar_2U;
 150                     CLclean_tail += CL_adot_clean * Std_Alpha_dot * ch_2U;
 151                     CLiced_wing += CL_adot * Std_Alpha_dot * cbar_2U;
 152                     CLiced_tail += CL_adot * Std_Alpha_dot * ch_2U;
 153                   }
 154               }
 155             /* CL_adot must be mulitplied by cbar/2U
 156                (see Roskam Control book, Part 1, pg. 147) */
 157             CL_adot_save = CL_adot * Std_Alpha_dot * cbar_2U;
 158             CL += CL_adot_save;
 159             break;
 160           }
 161         case CL_q_flag:
 162           {
 163             if (ice_on)
 164               {
 165                 CL_q = uiuc_ice_filter(CL_q_clean,kCL_q);
 166                 if (beta_model)
 167                   {
 168                     CLclean_wing += CL_q_clean * Theta_dot * cbar_2U;
 169                     CLclean_tail += CL_q_clean * Theta_dot * ch_2U;
 170                     CLiced_wing += CL_q * Theta_dot * cbar_2U;
 171                     CLiced_tail += CL_q * Theta_dot * ch_2U;
 172                   }
 173               }
 174             /* CL_q must be mulitplied by cbar/2U
 175                (see Roskam Control book, Part 1, pg. 147) */
 176             /* why multiply by Theta_dot instead of Q_body?
 177                that is what is done in c172_aero.c; assume it
 178                has something to do with axes systems */
 179             CL_q_save = CL_q * Theta_dot * cbar_2U;
 180             CL += CL_q_save;
 181             break;
 182           }
 183         case CL_ih_flag:
 184           {
 185             CL_ih_save = CL_ih * ih;
 186             CL += CL_ih_save;
 187             break;
 188           }
 189         case CL_de_flag:
 190           {
 191             if (ice_on)
 192               {
 193                 CL_de = uiuc_ice_filter(CL_de_clean,kCL_de);
 194                 if (beta_model)
 195                   {
 196                     CLclean_wing += CL_de_clean * elevator;
 197                     CLclean_tail += CL_de_clean * elevator;
 198                     CLiced_wing += CL_de * elevator;
 199                     CLiced_tail += CL_de * elevator;
 200                   }
 201               }
 202             CL_de_save = CL_de * elevator;
 203             CL += CL_de_save;
 204             break;
 205           }
 206         case CL_df_flag:
 207           {
 208             CL_df_save = CL_df * flap_pos;
 209             CL += CL_df_save;
 210             break;
 211           }
 212         case CL_ds_flag:
 213           {
 214             CL_ds_save = CL_ds * spoiler_pos;
 215             CL += CL_ds_save;
 216             break;
 217           }
 218         case CL_dg_flag:
 219           {
 220             CL_dg_save = CL_dg * gear_pos_norm;
 221             CL += CL_dg_save;
 222             break;
 223           }
 224         case CLfa_flag:
 225           {
 226             CLfaI = uiuc_1Dinterpolation(CLfa_aArray,
 227                                          CLfa_CLArray,
 228                                          CLfa_nAlpha,
 229                                          Std_Alpha);
 230             CL += CLfaI;
 231             break;
 232           }
 233         case CLfade_flag:
 234           {
 235             CLfadeI = uiuc_2Dinterpolation(CLfade_aArray,
 236                                            CLfade_deArray,
 237                                            CLfade_CLArray,
 238                                            CLfade_nAlphaArray,
 239                                            CLfade_nde,
 240                                            Std_Alpha,
 241                                            elevator);
 242             CL += CLfadeI;
 243             break;
 244           }
 245         case CLfdf_flag:
 246           {
 247             CLfdfI = uiuc_1Dinterpolation(CLfdf_dfArray,
 248                                           CLfdf_CLArray,
 249                                           CLfdf_ndf,
 250                                           flap_pos);
 251             CL += CLfdfI;
 252             break;
 253           }
 254         case CLfadf_flag:
 255           {
 256             CLfadfI = uiuc_2Dinterpolation(CLfadf_aArray,
 257                                            CLfadf_dfArray,
 258                                            CLfadf_CLArray,
 259                                            CLfadf_nAlphaArray,
 260                                            CLfadf_ndf,
 261                                            Std_Alpha,
 262                                            flap_pos);
 263             CL += CLfadfI;
 264             break;
 265           }
 266         case CZo_flag:
 267           {
 268             if (ice_on)
 269               {
 270                 CZo = uiuc_ice_filter(CZo_clean,kCZo);
 271                 if (beta_model)
 272                   {
 273                     CZclean_wing += CZo_clean;
 274                     CZclean_tail += CZo_clean;
 275                     CZiced_wing += CZo;
 276                     CZiced_tail += CZo;
 277                   }
 278               }
 279             CZo_save = CZo;
 280             CZ += CZo_save;
 281             break;
 282           }
 283         case CZ_a_flag:
 284           {
 285             if (ice_on)
 286               {
 287                 CZ_a = uiuc_ice_filter(CZ_a_clean,kCZ_a);
 288                 if (beta_model)
 289                   {
 290                     CZclean_wing += CZ_a_clean * Std_Alpha;
 291                     CZclean_tail += CZ_a_clean * Std_Alpha;
 292                     CZiced_wing += CZ_a * Std_Alpha;
 293                     CZiced_tail += CZ_a * Std_Alpha;
 294                   }
 295               }
 296             CZ_a_save = CZ_a * Std_Alpha;
 297             CZ += CZ_a_save;
 298             break;
 299           }
 300         case CZ_a2_flag:
 301           {
 302             if (ice_on)
 303               {
 304                 CZ_a2 = uiuc_ice_filter(CZ_a2_clean,kCZ_a2);
 305                 if (beta_model)
 306                   {
 307                     CZclean_wing += CZ_a2_clean * Std_Alpha * Std_Alpha;
 308                     CZclean_tail += CZ_a2_clean * Std_Alpha * Std_Alpha;
 309                     CZiced_wing += CZ_a2 * Std_Alpha * Std_Alpha;
 310                     CZiced_tail += CZ_a2 * Std_Alpha * Std_Alpha;
 311                   }
 312               }
 313             CZ_a2_save = CZ_a2 * Std_Alpha * Std_Alpha;
 314             CZ += CZ_a2_save;
 315             break;
 316           }
 317         case CZ_a3_flag:
 318           {
 319             if (ice_on)
 320               {
 321                 CZ_a3 = uiuc_ice_filter(CZ_a3_clean,kCZ_a3);
 322                 if (beta_model)
 323                   {
 324                     CZclean_wing += CZ_a3_clean * Std_Alpha * Std_Alpha * Std_Alpha;
 325                     CZclean_tail += CZ_a3_clean * Std_Alpha * Std_Alpha * Std_Alpha;
 326                     CZiced_wing += CZ_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
 327                     CZiced_tail += CZ_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
 328                   }
 329               }
 330             CZ_a3_save = CZ_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
 331             CZ += CZ_a3_save;
 332             break;
 333           }
 334         case CZ_adot_flag:
 335           {
 336             if (ice_on)
 337               {
 338                 CZ_adot = uiuc_ice_filter(CZ_adot_clean,kCZ_adot);
 339                 if (beta_model)
 340                   {
 341                     CZclean_wing += CZ_adot_clean * Std_Alpha_dot * cbar_2U;
 342                     CZclean_tail += CZ_adot_clean * Std_Alpha_dot * ch_2U;
 343                     CZiced_wing += CZ_adot * Std_Alpha_dot * cbar_2U;
 344                     CZiced_tail += CZ_adot * Std_Alpha_dot * ch_2U;
 345                   }
 346               }
 347             /* CZ_adot must be mulitplied by cbar/2U
 348                (see Roskam Control book, Part 1, pg. 147) */
 349             CZ_adot_save = CZ_adot * Std_Alpha_dot * cbar_2U;
 350             CZ += CZ_adot_save;
 351             break;
 352           }
 353         case CZ_q_flag:
 354           {
 355             if (ice_on)
 356               {
 357                 CZ_q = uiuc_ice_filter(CZ_q_clean,kCZ_q);
 358                 if (beta_model)
 359                   {
 360                     CZclean_wing += CZ_q_clean * Q_body * cbar_2U;
 361                     CZclean_tail += CZ_q_clean * Q_body * ch_2U;
 362                     CZiced_wing += CZ_q * Q_body * cbar_2U;
 363                     CZiced_tail += CZ_q * Q_body * ch_2U;
 364                   }
 365               }
 366             /* CZ_q must be mulitplied by cbar/2U
 367                (see Roskam Control book, Part 1, pg. 147) */
 368             CZ_q_save = CZ_q * Q_body * cbar_2U;
 369             CZ += CZ_q_save;
 370             break;
 371           }
 372         case CZ_de_flag:
 373           {
 374             if (ice_on)
 375               {
 376                 CZ_de = uiuc_ice_filter(CZ_de_clean,kCZ_de);
 377                 if (beta_model)
 378                   {
 379                     CZclean_wing += CZ_de_clean * elevator;
 380                     CZclean_tail += CZ_de_clean * elevator;
 381                     CZiced_wing += CZ_de * elevator;
 382                     CZiced_tail += CZ_de * elevator;
 383                   }
 384               }
 385             CZ_de_save = CZ_de * elevator;
 386             CZ += CZ_de_save;
 387             break;
 388           }
 389         case CZ_deb2_flag:
 390           {
 391             if (ice_on)
 392               {
 393                 CZ_deb2 = uiuc_ice_filter(CZ_deb2_clean,kCZ_deb2);
 394                 if (beta_model)
 395                   {
 396                     CZclean_wing += CZ_deb2_clean * elevator * Std_Beta * Std_Beta;
 397                     CZclean_tail += CZ_deb2_clean * elevator * Std_Beta * Std_Beta;
 398                     CZiced_wing += CZ_deb2 * elevator * Std_Beta * Std_Beta;
 399                     CZiced_tail += CZ_deb2 * elevator * Std_Beta * Std_Beta;
 400                   }
 401               }
 402             CZ_deb2_save = CZ_deb2 * elevator * Std_Beta * Std_Beta;
 403             CZ += CZ_deb2_save;
 404             break;
 405           }
 406         case CZ_df_flag:
 407           {
 408             if (ice_on)
 409               {
 410                 CZ_df = uiuc_ice_filter(CZ_df_clean,kCZ_df);
 411                 if (beta_model)
 412                   {
 413                     CZclean_wing += CZ_df_clean * flap_pos;
 414                     CZclean_tail += CZ_df_clean * flap_pos;
 415                     CZiced_wing += CZ_df * flap_pos;
 416                     CZiced_tail += CZ_df * flap_pos;
 417                   }
 418               }
 419             CZ_df_save = CZ_df * flap_pos;
 420             CZ += CZ_df_save;
 421             break;
 422           }
 423         case CZ_adf_flag:
 424           {
 425             if (ice_on)
 426               {
 427                 CZ_adf = uiuc_ice_filter(CZ_adf_clean,kCZ_adf);
 428                 if (beta_model)
 429                   {
 430                     CZclean_wing += CZ_adf_clean * Std_Alpha * flap_pos;
 431                     CZclean_tail += CZ_adf_clean * Std_Alpha * flap_pos;
 432                     CZiced_wing += CZ_adf * Std_Alpha * flap_pos;
 433                     CZiced_tail += CZ_adf * Std_Alpha * flap_pos;
 434                   }
 435               }
 436             CZ_adf_save = CZ_adf * Std_Alpha * flap_pos;
 437             CZ += CZ_adf_save;
 438             break;
 439           }
 440         case CZfa_flag:
 441           {
 442             CZfaI = uiuc_1Dinterpolation(CZfa_aArray,
 443                                          CZfa_CZArray,
 444                                          CZfa_nAlpha,
 445                                          Std_Alpha);
 446             CZ += CZfaI;
 447             break;
 448           }
 449         case CZfabetaf_flag:
 450           {
 451             if (CZfabetaf_nice == 1)
 452               CZfabetafI = uiuc_3Dinterp_quick(CZfabetaf_fArray,
 453                                                CZfabetaf_aArray_nice,
 454                                                CZfabetaf_bArray_nice,
 455                                                CZfabetaf_CZArray,
 456                                                CZfabetaf_na_nice,
 457                                                CZfabetaf_nb_nice,
 458                                                CZfabetaf_nf,
 459                                                flap_pos,
 460                                                Std_Alpha,
 461                                                Std_Beta);
 462             else
 463               CZfabetafI = uiuc_3Dinterpolation(CZfabetaf_fArray,
 464                                                 CZfabetaf_aArray,
 465                                                 CZfabetaf_betaArray,
 466                                                 CZfabetaf_CZArray,
 467                                                 CZfabetaf_nAlphaArray,
 468                                                 CZfabetaf_nbeta,
 469                                                 CZfabetaf_nf,
 470                                                 flap_pos,
 471                                                 Std_Alpha,
 472                                                 Std_Beta);
 473             CZ += CZfabetafI;
 474             break;
 475           }
 476         case CZfadef_flag:
 477           {
 478             if (CZfadef_nice == 1)
 479               CZfadefI = uiuc_3Dinterp_quick(CZfadef_fArray,
 480                                              CZfadef_aArray_nice,
 481                                              CZfadef_deArray_nice,
 482                                              CZfadef_CZArray,
 483                                              CZfadef_na_nice,
 484                                              CZfadef_nde_nice,
 485                                              CZfadef_nf,
 486                                              flap_pos,
 487                                              Std_Alpha,
 488                                              elevator);
 489             else
 490               CZfadefI = uiuc_3Dinterpolation(CZfadef_fArray,
 491                                               CZfadef_aArray,
 492                                               CZfadef_deArray,
 493                                               CZfadef_CZArray,
 494                                               CZfadef_nAlphaArray,
 495                                               CZfadef_nde,
 496                                               CZfadef_nf,
 497                                               flap_pos,
 498                                               Std_Alpha,
 499                                               elevator);
 500             CZ += CZfadefI;
 501             break;
 502           }
 503         case CZfaqf_flag:
 504           {
 505             q_nondim = Q_body * cbar_2U;
 506             if (CZfaqf_nice == 1)
 507               CZfaqfI = uiuc_3Dinterp_quick(CZfaqf_fArray,
 508                                             CZfaqf_aArray_nice,
 509                                             CZfaqf_qArray_nice,
 510                                             CZfaqf_CZArray,
 511                                             CZfaqf_na_nice,
 512                                             CZfaqf_nq_nice,
 513                                             CZfaqf_nf,
 514                                             flap_pos,
 515                                             Std_Alpha,
 516                                             q_nondim);
 517             else
 518               CZfaqfI = uiuc_3Dinterpolation(CZfaqf_fArray,
 519                                              CZfaqf_aArray,
 520                                              CZfaqf_qArray,
 521                                              CZfaqf_CZArray,
 522                                              CZfaqf_nAlphaArray,
 523                                              CZfaqf_nq,
 524                                              CZfaqf_nf,
 525                                              flap_pos,
 526                                              Std_Alpha,
 527                                              q_nondim);
 528             CZ += CZfaqfI;
 529             break;
 530           }
 531         };
 532     } // end CL map
 533
 534   return;
 535 }
 536
 537 // end uiuc_coef_lift.cpp