src/FDM/UIUCModel/uiuc_coef_drag.cpp

   1 /**********************************************************************
   2
   3  FILENAME:     uiuc_coef_drag.cpp
   4
   5 ----------------------------------------------------------------------
   6
   7  DESCRIPTION:  computes aggregated aerodynamic drag 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                10/25/2001   (RD) Added new variables needed for the non-
  23                             linear Twin Otter model at zero flaps
  24                             (CXfxxf0)
  25                11/12/2001   (RD) Added new variables needed for the non-
  26                             linear Twin Otter model with flaps
  27                             (CXfxxf).  Zero flap vairables removed.
  28                02/13/2002   (RD) Added variables so linear aero model
  29                             values can be recorded
  30                02/18/2002   (RD) Added uiuc_3Dinterp_quick() function
  31                             for a quicker 3D interpolation.  Takes
  32                             advantage of "nice" data.
  33
  34 ----------------------------------------------------------------------
  35
  36  AUTHOR(S):    Bipin Sehgal       <bsehgal@uiuc.edu>
  37                Jeff Scott         <jscott@mail.com>
  38                Robert Deters      <rdeters@uiuc.edu>
  39
  40 ----------------------------------------------------------------------
  41
  42  VARIABLES:
  43
  44 ----------------------------------------------------------------------
  45
  46  INPUTS:       -Alpha
  47                -elevator
  48                -drag coefficient components
  49                -icing parameters
  50
  51 ----------------------------------------------------------------------
  52
  53  OUTPUTS:      -CD
  54
  55 ----------------------------------------------------------------------
  56
  57  CALLED BY:    uiuc_coefficients.cpp
  58
  59 ----------------------------------------------------------------------
  60
  61  CALLS TO:     uiuc_1Dinterpolation
  62                uiuc_2Dinterpolation
  63                uiuc_ice_filter
  64                uiuc_3Dinterpolation
  65                uiuc_3Dinterp_quick
  66
  67 ----------------------------------------------------------------------
  68
  69  COPYRIGHT:    (C) 2000 by Michael Selig
  70
  71  This program is free software; you can redistribute it and/or
  72  modify it under the terms of the GNU General Public License
  73  as published by the Free Software Foundation.
  74
  75  This program is distributed in the hope that it will be useful,
  76  but WITHOUT ANY WARRANTY; without even the implied warranty of
  77  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  78  GNU General Public License for more details.
  79
  80  You should have received a copy of the GNU General Public License
  81  along with this program; if not, write to the Free Software
  82  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  83  USA or view http://www.gnu.org/copyleft/gpl.html.
  84
  85 **********************************************************************/
  86
  87 #include "uiuc_coef_drag.h"
  88 #include <math.h>
  89
  90 void uiuc_coef_drag()
  91 {
  92   string linetoken1;
  93   string linetoken2;
  94   stack command_list;
  95
  96   double q_nondim;
  97
  98   command_list = aeroDragParts -> getCommands();
  99
 100   for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
 101     {
 102       linetoken1 = aeroDragParts -> getToken(*command_line, 1);
 103       linetoken2 = aeroDragParts -> getToken(*command_line, 2);
 104
 105       switch (CD_map[linetoken2])
 106         {
 107         case CDo_flag:
 108           {
 109             if (ice_on)
 110               {
 111                 CDo = uiuc_ice_filter(CDo_clean,kCDo);
 112               }
 113             CDo_save = CDo;
 114             CD += CDo;
 115             break;
 116           }
 117         case CDK_flag:
 118           {
 119             if (ice_on)
 120               {
 121                 CDK = uiuc_ice_filter(CDK_clean,kCDK);
 122               }
 123             CDK_save = CDK * CL * CL;
 124             CD += CDK * CL * CL;
 125             break;
 126           }
 127         case CD_a_flag:
 128           {
 129             if (ice_on)
 130               {
 131                 CD_a = uiuc_ice_filter(CD_a_clean,kCD_a);
 132               }
 133             CD_a_save = CD_a * Alpha;
 134             CD += CD_a * Alpha;
 135             break;
 136           }
 137         case CD_adot_flag:
 138           {
 139             if (ice_on)
 140               {
 141                 CD_adot = uiuc_ice_filter(CD_adot_clean,kCD_adot);
 142               }
 143             /* CD_adot must be mulitplied by cbar/2U
 144                (see Roskam Control book, Part 1, pg. 147) */
 145             CD_adot_save = CD_adot * Alpha_dot * cbar_2U;
 146             CD += CD_adot * Alpha_dot * cbar_2U;
 147             break;
 148           }
 149         case CD_q_flag:
 150           {
 151             if (ice_on)
 152               {
 153                 CD_q = uiuc_ice_filter(CD_q_clean,kCD_q);
 154               }
 155             /* CD_q must be mulitplied by cbar/2U
 156                (see Roskam Control book, Part 1, pg. 147) */
 157             /* why multiply by Theta_dot instead of Q_body?
 158                see note in coef_lift.cpp */
 159             CD_q_save = CD_q * Theta_dot * cbar_2U;
 160             CD += CD_q * Theta_dot * cbar_2U;
 161             break;
 162           }
 163         case CD_ih_flag:
 164           {
 165             CD_ih_save = fabs(CD_ih * ih);
 166             CD += fabs(CD_ih * ih);
 167             break;
 168           }
 169         case CD_de_flag:
 170           {
 171             if (ice_on)
 172               {
 173                 CD_de = uiuc_ice_filter(CD_de_clean,kCD_de);
 174               }
 175             CD_de_save = fabs(CD_de * elevator);
 176             CD += fabs(CD_de * elevator);
 177             break;
 178           }
 179         case CDfa_flag:
 180           {
 181             CDfaI = uiuc_1Dinterpolation(CDfa_aArray,
 182                                          CDfa_CDArray,
 183                                          CDfa_nAlpha,
 184                                          Alpha);
 185             CD += CDfaI;
 186             break;
 187           }
 188         case CDfCL_flag:
 189           {
 190             CDfCLI = uiuc_1Dinterpolation(CDfCL_CLArray,
 191                                           CDfCL_CDArray,
 192                                           CDfCL_nCL,
 193                                           CL);
 194             CD += CDfCLI;
 195             break;
 196           }
 197         case CDfdf_flag:
 198           {
 199             CDfdfI = uiuc_1Dinterpolation(CDfdf_dfArray,
 200                                           CDfdf_CDArray,
 201                                           CDfdf_ndf,
 202                                           flap);
 203             CD += CDfdfI;
 204             break;
 205           }
 206         case CDfade_flag:
 207           {
 208             CDfadeI = uiuc_2Dinterpolation(CDfade_aArray,
 209                                            CDfade_deArray,
 210                                            CDfade_CDArray,
 211                                            CDfade_nAlphaArray,
 212                                            CDfade_nde,
 213                                            Alpha,
 214                                            elevator);
 215                   CD += CDfadeI;
 216                   break;
 217           }
 218         case CDfadf_flag:
 219           {
 220             CDfadfI = uiuc_2Dinterpolation(CDfadf_aArray,
 221                                            CDfadf_dfArray,
 222                                            CDfadf_CDArray,
 223                                            CDfadf_nAlphaArray,
 224                                            CDfadf_ndf,
 225                                            Alpha,
 226                                            flap);
 227             CD += CDfadfI;
 228             break;
 229           }
 230         case CXo_flag:
 231           {
 232             if (ice_on)
 233               {
 234                 CXo = uiuc_ice_filter(CXo_clean,kCXo);
 235                 if (beta_model)
 236                   {
 237                     CXclean_wing += CXo_clean;
 238                     CXclean_tail += CXo_clean;
 239                     CXiced_wing += CXo;
 240                     CXiced_tail += CXo;
 241                   }
 242               }
 243             CXo_save = CXo;
 244             CX += CXo;
 245             break;
 246           }
 247         case CXK_flag:
 248           {
 249             if (ice_on)
 250               {
 251                 CXK = uiuc_ice_filter(CXK_clean,kCXK);
 252                 if (beta_model)
 253                   {
 254                     CXclean_wing += CXK_clean * CLclean_wing * CLclean_wing;
 255                     CXclean_tail += CXK_clean * CLclean_tail * CLclean_tail;
 256                     CXiced_wing += CXK * CLiced_wing * CLiced_wing;
 257                     CXiced_tail += CXK * CLiced_tail * CLiced_tail;
 258                   }
 259               }
 260             CXK_save = CXK * CZ * CZ;
 261             CX += CXK * CZ * CZ;
 262             break;
 263           }
 264         case CX_a_flag:
 265           {
 266             if (ice_on)
 267               {
 268                 CX_a = uiuc_ice_filter(CX_a_clean,kCX_a);
 269                 if (beta_model)
 270                   {
 271                     CXclean_wing += CX_a_clean * Alpha;
 272                     CXclean_tail += CX_a_clean * Alpha;
 273                     CXiced_wing += CX_a * Alpha;
 274                     CXiced_tail += CX_a * Alpha;
 275                   }
 276               }
 277             CX_a_save = CX_a * Alpha;
 278             CX += CX_a * Alpha;
 279             break;
 280           }
 281         case CX_a2_flag:
 282           {
 283             if (ice_on)
 284               {
 285                 CX_a2 = uiuc_ice_filter(CX_a2_clean,kCX_a2);
 286                 if (beta_model)
 287                   {
 288                     CXclean_wing += CX_a2_clean * Alpha * Alpha;
 289                     CXclean_tail += CX_a2_clean * Alpha * Alpha;
 290                     CXiced_wing += CX_a2 * Alpha * Alpha;
 291                     CXiced_tail += CX_a2 * Alpha * Alpha;
 292                   }
 293               }
 294             CX_a2_save = CX_a2 * Alpha * Alpha;
 295             CX += CX_a2 * Alpha * Alpha;
 296             break;
 297           }
 298         case CX_a3_flag:
 299           {
 300             if (ice_on)
 301               {
 302                 CX_a3 = uiuc_ice_filter(CX_a3_clean,kCX_a3);
 303                 if (beta_model)
 304                   {
 305                     CXclean_wing += CX_a3_clean * Alpha * Alpha * Alpha;
 306                     CXclean_tail += CX_a3_clean * Alpha * Alpha * Alpha;
 307                     CXiced_wing += CX_a3 * Alpha * Alpha * Alpha;
 308                     CXiced_tail += CX_a3 * Alpha * Alpha * Alpha;
 309                   }
 310               }
 311             CX_a3_save = CX_a3 * Alpha * Alpha * Alpha;
 312             CX += CX_a3 * Alpha * Alpha * Alpha;
 313             break;
 314           }
 315         case CX_adot_flag:
 316           {
 317             if (ice_on)
 318               {
 319                 CX_adot = uiuc_ice_filter(CX_adot_clean,kCX_adot);
 320                 if (beta_model)
 321                   {
 322                     CXclean_wing += CX_adot_clean * Alpha_dot * cbar_2U;
 323                     CXclean_tail += CX_adot_clean * Alpha_dot * ch_2U;
 324                     CXiced_wing += CX * Alpha_dot * cbar_2U;
 325                     CXiced_tail += CX * Alpha_dot * ch_2U;
 326                   }
 327               }
 328             /* CX_adot must be mulitplied by cbar/2U
 329                (see Roskam Control book, Part 1, pg. 147) */
 330             CX_adot_save = CX_adot * Alpha_dot * cbar_2U;
 331             CX += CX_adot * Alpha_dot * cbar_2U;
 332             break;
 333           }
 334         case CX_q_flag:
 335           {
 336             if (ice_on)
 337               {
 338                 CX_q = uiuc_ice_filter(CX_q_clean,kCX_q);
 339                 if (beta_model)
 340                   {
 341                     CXclean_wing += CX_q_clean * Q_body * cbar_2U;
 342                     CXclean_tail += CX_q_clean * Q_body * ch_2U;
 343                     CXiced_wing += CX_q * Q_body * cbar_2U;
 344                     CXiced_tail += CX_q * Q_body * ch_2U;
 345                   }
 346               }
 347             /* CX_q must be mulitplied by cbar/2U
 348                (see Roskam Control book, Part 1, pg. 147) */
 349             CX_q_save = CX_q * Q_body * cbar_2U;
 350             CX += CX_q * Q_body * cbar_2U;
 351             break;
 352           }
 353         case CX_de_flag:
 354           {
 355             if (ice_on)
 356               {
 357                 CX_de = uiuc_ice_filter(CX_de_clean,kCX_de);
 358                 if (beta_model)
 359                   {
 360                     CXclean_wing += CX_de_clean * elevator;
 361                     CXclean_tail += CX_de_clean * elevator;
 362                     CXiced_wing += CX_de * elevator;
 363                     CXiced_tail += CX_de * elevator;
 364                   }
 365               }
 366             CX_de_save = CX_de * elevator;
 367             CX += CX_de * elevator;
 368             break;
 369           }
 370         case CX_dr_flag:
 371           {
 372             if (ice_on)
 373               {
 374                 CX_dr = uiuc_ice_filter(CX_dr_clean,kCX_dr);
 375                 if (beta_model)
 376                   {
 377                     CXclean_wing += CX_dr_clean * rudder;
 378                     CXclean_tail += CX_dr_clean * rudder;
 379                     CXiced_wing += CX_dr * rudder;
 380                     CXiced_tail += CX_dr * rudder;
 381                   }
 382               }
 383             CX_dr_save = CX_dr * rudder;
 384             CX += CX_dr * rudder;
 385             break;
 386           }
 387         case CX_df_flag:
 388           {
 389             if (ice_on)
 390               {
 391                 CX_df = uiuc_ice_filter(CX_df_clean,kCX_df);
 392                 if (beta_model)
 393                   {
 394                     CXclean_wing += CX_df_clean * flap;
 395                     CXclean_tail += CX_df_clean * flap;
 396                     CXiced_wing += CX * flap;
 397                     CXiced_tail += CX * flap;
 398                   }
 399               }
 400             CX_df_save = CX_df * flap;
 401             CX += CX_df * flap;
 402             break;
 403           }
 404         case CX_adf_flag:
 405           {
 406             if (ice_on)
 407               {
 408                 CX_adf = uiuc_ice_filter(CX_adf_clean,kCX_adf);
 409                 if (beta_model)
 410                   {
 411                     CXclean_wing += CX_adf_clean * Alpha * flap;
 412                     CXclean_tail += CX_adf_clean * Alpha * flap;
 413                     CXiced_wing += CX_adf * Alpha * flap;
 414                     CXiced_tail += CX_adf * Alpha * flap;
 415                   }
 416               }
 417             CX_adf_save = CX_adf * Alpha * flap;
 418             CX += CX_adf * Alpha * flap;
 419             break;
 420           }
 421         case CXfabetaf_flag:
 422           {
 423             if (CXfabetaf_nice == 1)
 424               CXfabetafI = uiuc_3Dinterp_quick(CXfabetaf_fArray,
 425                                                CXfabetaf_aArray_nice,
 426                                                CXfabetaf_bArray_nice,
 427                                                CXfabetaf_CXArray,
 428                                                CXfabetaf_na_nice,
 429                                                CXfabetaf_nb_nice,
 430                                                CXfabetaf_nf,
 431                                                flap_pos,
 432                                                Alpha,
 433                                                Beta);
 434             else
 435               CXfabetafI = uiuc_3Dinterpolation(CXfabetaf_fArray,
 436                                                 CXfabetaf_aArray,
 437                                                 CXfabetaf_betaArray,
 438                                                 CXfabetaf_CXArray,
 439                                                 CXfabetaf_nAlphaArray,
 440                                                 CXfabetaf_nbeta,
 441                                                 CXfabetaf_nf,
 442                                                 flap_pos,
 443                                                 Alpha,
 444                                                 Beta);
 445             CX += CXfabetafI;
 446             break;
 447           }
 448         case CXfadef_flag:
 449           {
 450             if (CXfadef_nice == 1)
 451               CXfadefI = uiuc_3Dinterp_quick(CXfadef_fArray,
 452                                              CXfadef_aArray_nice,
 453                                              CXfadef_deArray_nice,
 454                                              CXfadef_CXArray,
 455                                              CXfadef_na_nice,
 456                                              CXfadef_nde_nice,
 457                                              CXfadef_nf,
 458                                              flap_pos,
 459                                              Alpha,
 460                                              elevator);
 461             else
 462               CXfadefI = uiuc_3Dinterpolation(CXfadef_fArray,
 463                                               CXfadef_aArray,
 464                                               CXfadef_deArray,
 465                                               CXfadef_CXArray,
 466                                               CXfadef_nAlphaArray,
 467                                               CXfadef_nde,
 468                                               CXfadef_nf,
 469                                               flap_pos,
 470                                               Alpha,
 471                                               elevator);
 472             CX += CXfadefI;
 473             break;
 474           }
 475         case CXfaqf_flag:
 476           {
 477             q_nondim = Q_body * cbar_2U;
 478             if (CXfaqf_nice == 1)
 479               CXfaqfI = uiuc_3Dinterp_quick(CXfaqf_fArray,
 480                                             CXfaqf_aArray_nice,
 481                                             CXfaqf_qArray_nice,
 482                                             CXfaqf_CXArray,
 483                                             CXfaqf_na_nice,
 484                                             CXfaqf_nq_nice,
 485                                             CXfaqf_nf,
 486                                             flap_pos,
 487                                             Alpha,
 488                                             q_nondim);
 489             else
 490               CXfaqfI = uiuc_3Dinterpolation(CXfaqf_fArray,
 491                                              CXfaqf_aArray,
 492                                              CXfaqf_qArray,
 493                                              CXfaqf_CXArray,
 494                                              CXfaqf_nAlphaArray,
 495                                              CXfaqf_nq,
 496                                              CXfaqf_nf,
 497                                              flap_pos,
 498                                              Alpha,
 499                                              q_nondim);
 500             CX += CXfaqfI;
 501             break;
 502           }
 503         };
 504     } // end CD map
 505
 506   return;
 507 }
 508
 509 // end uiuc_coef_drag.cpp