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;
 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 * Alpha;
 133                     CLclean_tail += CL_a_clean * Alpha;
 134                     CLiced_wing += CL_a * Alpha;
 135                     CLiced_tail += CL_a * Alpha;
 136                   }
 137               }
 138             CL_a_save = CL_a * Alpha;
 139             CL += CL_a * Alpha;
 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 * Alpha_dot * cbar_2U;
 150                     CLclean_tail += CL_adot_clean * Alpha_dot * ch_2U;
 151                     CLiced_wing += CL_adot * Alpha_dot * cbar_2U;
 152                     CLiced_tail += CL_adot * 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 * Alpha_dot * cbar_2U;
 158             CL += CL_adot * Alpha_dot * cbar_2U;
 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 * Theta_dot * cbar_2U;
 181             break;
 182           }
 183         case CL_ih_flag:
 184           {
 185             CL_ih_save = CL_ih * ih;
 186             CL += CL_ih * ih;
 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 * elevator;
 204             break;
 205           }
 206         case CLfa_flag:
 207           {
 208             CLfaI = uiuc_1Dinterpolation(CLfa_aArray,
 209                                          CLfa_CLArray,
 210                                          CLfa_nAlpha,
 211                                          Alpha);
 212             CL += CLfaI;
 213             break;
 214           }
 215         case CLfade_flag:
 216           {
 217             CLfadeI = uiuc_2Dinterpolation(CLfade_aArray,
 218                                            CLfade_deArray,
 219                                            CLfade_CLArray,
 220                                            CLfade_nAlphaArray,
 221                                            CLfade_nde,
 222                                            Alpha,
 223                                            elevator);
 224             CL += CLfadeI;
 225             break;
 226           }
 227         case CLfdf_flag:
 228           {
 229             CLfdfI = uiuc_1Dinterpolation(CLfdf_dfArray,
 230                                           CLfdf_CLArray,
 231                                           CLfdf_ndf,
 232                                           flap);
 233             CL += CLfdfI;
 234             break;
 235           }
 236         case CLfadf_flag:
 237           {
 238             CLfadfI = uiuc_2Dinterpolation(CLfadf_aArray,
 239                                            CLfadf_dfArray,
 240                                            CLfadf_CLArray,
 241                                            CLfadf_nAlphaArray,
 242                                            CLfadf_ndf,
 243                                            Alpha,
 244                                            flap);
 245             CL += CLfadfI;
 246             break;
 247           }
 248         case CZo_flag:
 249           {
 250             if (ice_on)
 251               {
 252                 CZo = uiuc_ice_filter(CZo_clean,kCZo);
 253                 if (beta_model)
 254                   {
 255                     CZclean_wing += CZo_clean;
 256                     CZclean_tail += CZo_clean;
 257                     CZiced_wing += CZo;
 258                     CZiced_tail += CZo;
 259                   }
 260               }
 261             CZo_save = CZo;
 262             CZ += CZo;
 263             break;
 264           }
 265         case CZ_a_flag:
 266           {
 267             if (ice_on)
 268               {
 269                 CZ_a = uiuc_ice_filter(CZ_a_clean,kCZ_a);
 270                 if (beta_model)
 271                   {
 272                     CZclean_wing += CZ_a_clean * Alpha;
 273                     CZclean_tail += CZ_a_clean * Alpha;
 274                     CZiced_wing += CZ_a * Alpha;
 275                     CZiced_tail += CZ_a * Alpha;
 276                   }
 277               }
 278             CZ_a_save = CZ_a * Alpha;
 279             CZ += CZ_a * Alpha;
 280             break;
 281           }
 282         case CZ_a2_flag:
 283           {
 284             if (ice_on)
 285               {
 286                 CZ_a2 = uiuc_ice_filter(CZ_a2_clean,kCZ_a2);
 287                 if (beta_model)
 288                   {
 289                     CZclean_wing += CZ_a2_clean * Alpha * Alpha;
 290                     CZclean_tail += CZ_a2_clean * Alpha * Alpha;
 291                     CZiced_wing += CZ_a2 * Alpha * Alpha;
 292                     CZiced_tail += CZ_a2 * Alpha * Alpha;
 293                   }
 294               }
 295             CZ_a2_save = CZ_a2 * Alpha * Alpha;
 296             CZ += CZ_a2 * Alpha * Alpha;
 297             break;
 298           }
 299         case CZ_a3_flag:
 300           {
 301             if (ice_on)
 302               {
 303                 CZ_a3 = uiuc_ice_filter(CZ_a3_clean,kCZ_a3);
 304                 if (beta_model)
 305                   {
 306                     CZclean_wing += CZ_a3_clean * Alpha * Alpha * Alpha;
 307                     CZclean_tail += CZ_a3_clean * Alpha * Alpha * Alpha;
 308                     CZiced_wing += CZ_a3 * Alpha * Alpha * Alpha;
 309                     CZiced_tail += CZ_a3 * Alpha * Alpha * Alpha;
 310                   }
 311               }
 312             CZ_a3_save = CZ_a3 * Alpha * Alpha * Alpha;
 313             CZ += CZ_a3 * Alpha * Alpha * Alpha;
 314             break;
 315           }
 316         case CZ_adot_flag:
 317           {
 318             if (ice_on)
 319               {
 320                 CZ_adot = uiuc_ice_filter(CZ_adot_clean,kCZ_adot);
 321                 if (beta_model)
 322                   {
 323                     CZclean_wing += CZ_adot_clean * Alpha_dot * cbar_2U;
 324                     CZclean_tail += CZ_adot_clean * Alpha_dot * ch_2U;
 325                     CZiced_wing += CZ_adot * Alpha_dot * cbar_2U;
 326                     CZiced_tail += CZ_adot * Alpha_dot * ch_2U;
 327                   }
 328               }
 329             /* CZ_adot must be mulitplied by cbar/2U
 330                (see Roskam Control book, Part 1, pg. 147) */
 331             CZ_adot_save = CZ_adot * Alpha_dot * cbar_2U;
 332             CZ += CZ_adot * Alpha_dot * cbar_2U;
 333             break;
 334           }
 335         case CZ_q_flag:
 336           {
 337             if (ice_on)
 338               {
 339                 CZ_q = uiuc_ice_filter(CZ_q_clean,kCZ_q);
 340                 if (beta_model)
 341                   {
 342                     CZclean_wing += CZ_q_clean * Q_body * cbar_2U;
 343                     CZclean_tail += CZ_q_clean * Q_body * ch_2U;
 344                     CZiced_wing += CZ_q * Q_body * cbar_2U;
 345                     CZiced_tail += CZ_q * Q_body * ch_2U;
 346                   }
 347               }
 348             /* CZ_q must be mulitplied by cbar/2U
 349                (see Roskam Control book, Part 1, pg. 147) */
 350             CZ_q_save = CZ_q * Q_body * cbar_2U;
 351             CZ += CZ_q * Q_body * cbar_2U;
 352             break;
 353           }
 354         case CZ_de_flag:
 355           {
 356             if (ice_on)
 357               {
 358                 CZ_de = uiuc_ice_filter(CZ_de_clean,kCZ_de);
 359                 if (beta_model)
 360                   {
 361                     CZclean_wing += CZ_de_clean * elevator;
 362                     CZclean_tail += CZ_de_clean * elevator;
 363                     CZiced_wing += CZ_de * elevator;
 364                     CZiced_tail += CZ_de * elevator;
 365                   }
 366               }
 367             CZ_de_save = CZ_de * elevator;
 368             CZ += CZ_de * elevator;
 369             break;
 370           }
 371         case CZ_deb2_flag:
 372           {
 373             if (ice_on)
 374               {
 375                 CZ_deb2 = uiuc_ice_filter(CZ_deb2_clean,kCZ_deb2);
 376                 if (beta_model)
 377                   {
 378                     CZclean_wing += CZ_deb2_clean * elevator * Beta * Beta;
 379                     CZclean_tail += CZ_deb2_clean * elevator * Beta * Beta;
 380                     CZiced_wing += CZ_deb2 * elevator * Beta * Beta;
 381                     CZiced_tail += CZ_deb2 * elevator * Beta * Beta;
 382                   }
 383               }
 384             CZ_deb2_save = CZ_deb2 * elevator * Beta * Beta;
 385             CZ += CZ_deb2 * elevator * Beta * Beta;
 386             break;
 387           }
 388         case CZ_df_flag:
 389           {
 390             if (ice_on)
 391               {
 392                 CZ_df = uiuc_ice_filter(CZ_df_clean,kCZ_df);
 393                 if (beta_model)
 394                   {
 395                     CZclean_wing += CZ_df_clean * flap;
 396                     CZclean_tail += CZ_df_clean * flap;
 397                     CZiced_wing += CZ_df * flap;
 398                     CZiced_tail += CZ_df * flap;
 399                   }
 400               }
 401             CZ_df_save = CZ_df * flap;
 402             CZ += CZ_df * flap;
 403             break;
 404           }
 405         case CZ_adf_flag:
 406           {
 407             if (ice_on)
 408               {
 409                 CZ_adf = uiuc_ice_filter(CZ_adf_clean,kCZ_adf);
 410                 if (beta_model)
 411                   {
 412                     CZclean_wing += CZ_adf_clean * Alpha * flap;
 413                     CZclean_tail += CZ_adf_clean * Alpha * flap;
 414                     CZiced_wing += CZ_adf * Alpha * flap;
 415                     CZiced_tail += CZ_adf * Alpha * flap;
 416                   }
 417               }
 418             CZ_adf_save = CZ_adf * Alpha * flap;
 419             CZ += CZ_adf * Alpha * flap;
 420             break;
 421           }
 422         case CZfa_flag:
 423           {
 424             CZfaI = uiuc_1Dinterpolation(CZfa_aArray,
 425                                          CZfa_CZArray,
 426                                          CZfa_nAlpha,
 427                                          Alpha);
 428             CZ += CZfaI;
 429             break;
 430           }
 431         case CZfabetaf_flag:
 432           {
 433             if (CZfabetaf_nice == 1)
 434               CZfabetafI = uiuc_3Dinterp_quick(CZfabetaf_fArray,
 435                                                CZfabetaf_aArray_nice,
 436                                                CZfabetaf_bArray_nice,
 437                                                CZfabetaf_CZArray,
 438                                                CZfabetaf_na_nice,
 439                                                CZfabetaf_nb_nice,
 440                                                CZfabetaf_nf,
 441                                                flap_pos,
 442                                                Alpha,
 443                                                Beta);
 444             else
 445               CZfabetafI = uiuc_3Dinterpolation(CZfabetaf_fArray,
 446                                                 CZfabetaf_aArray,
 447                                                 CZfabetaf_betaArray,
 448                                                 CZfabetaf_CZArray,
 449                                                 CZfabetaf_nAlphaArray,
 450                                                 CZfabetaf_nbeta,
 451                                                 CZfabetaf_nf,
 452                                                 flap_pos,
 453                                                 Alpha,
 454                                                 Beta);
 455             CZ += CZfabetafI;
 456             break;
 457           }
 458         case CZfadef_flag:
 459           {
 460             if (CZfadef_nice == 1)
 461               CZfadefI = uiuc_3Dinterp_quick(CZfadef_fArray,
 462                                              CZfadef_aArray_nice,
 463                                              CZfadef_deArray_nice,
 464                                              CZfadef_CZArray,
 465                                              CZfadef_na_nice,
 466                                              CZfadef_nde_nice,
 467                                              CZfadef_nf,
 468                                              flap_pos,
 469                                              Alpha,
 470                                              elevator);
 471             else
 472               CZfadefI = uiuc_3Dinterpolation(CZfadef_fArray,
 473                                               CZfadef_aArray,
 474                                               CZfadef_deArray,
 475                                               CZfadef_CZArray,
 476                                               CZfadef_nAlphaArray,
 477                                               CZfadef_nde,
 478                                               CZfadef_nf,
 479                                               flap_pos,
 480                                               Alpha,
 481                                               elevator);
 482             CZ += CZfadefI;
 483             break;
 484           }
 485         case CZfaqf_flag:
 486           {
 487             q_nondim = Q_body * cbar_2U;
 488             if (CZfaqf_nice == 1)
 489               CZfaqfI = uiuc_3Dinterp_quick(CZfaqf_fArray,
 490                                             CZfaqf_aArray_nice,
 491                                             CZfaqf_qArray_nice,
 492                                             CZfaqf_CZArray,
 493                                             CZfaqf_na_nice,
 494                                             CZfaqf_nq_nice,
 495                                             CZfaqf_nf,
 496                                             flap_pos,
 497                                             Alpha,
 498                                             q_nondim);
 499             else
 500               CZfaqfI = uiuc_3Dinterpolation(CZfaqf_fArray,
 501                                              CZfaqf_aArray,
 502                                              CZfaqf_qArray,
 503                                              CZfaqf_CZArray,
 504                                              CZfaqf_nAlphaArray,
 505                                              CZfaqf_nq,
 506                                              CZfaqf_nf,
 507                                              flap_pos,
 508                                              Alpha,
 509                                              q_nondim);
 510             CZ += CZfaqfI;
 511             break;
 512           }
 513         };
 514     } // end CL map
 515
 516   return;
 517 }
 518
 519 // end uiuc_coef_lift.cpp