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               // temp until Jim's code works
 435               //CXo = uiuc_3Dinterp_quick(CXfabetaf_fArray,
 436               //                         CXfabetaf_aArray_nice,
 437               //                         CXfabetaf_bArray_nice,
 438               //                         CXfabetaf_CXArray,
 439               //                         CXfabetaf_na_nice,
 440               //                         CXfabetaf_nb_nice,
 441               //                         CXfabetaf_nf,
 442               //                         flap_pos,
 443               //                         0.0,
 444               //                         Beta);
 445             }
 446             else {
 447               CXfabetafI = uiuc_3Dinterpolation(CXfabetaf_fArray,
 448                                                 CXfabetaf_aArray,
 449                                                 CXfabetaf_betaArray,
 450                                                 CXfabetaf_CXArray,
 451                                                 CXfabetaf_nAlphaArray,
 452                                                 CXfabetaf_nbeta,
 453                                                 CXfabetaf_nf,
 454                                                 flap_pos,
 455                                                 Alpha,
 456                                                 Beta);
 457               // temp until Jim's code works
 458               //CXo = uiuc_3Dinterpolation(CXfabetaf_fArray,
 459               //                          CXfabetaf_aArray,
 460               //                          CXfabetaf_betaArray,
 461               //                          CXfabetaf_CXArray,
 462               //                          CXfabetaf_nAlphaArray,
 463               //                          CXfabetaf_nbeta,
 464               //                          CXfabetaf_nf,
 465               //                          flap_pos,
 466               //                          0.0,
 467               //                          Beta);
 468             }
 469             CX += CXfabetafI;
 470             break;
 471           }
 472         case CXfadef_flag:
 473           {
 474             if (CXfadef_nice == 1)
 475               CXfadefI = uiuc_3Dinterp_quick(CXfadef_fArray,
 476                                              CXfadef_aArray_nice,
 477                                              CXfadef_deArray_nice,
 478                                              CXfadef_CXArray,
 479                                              CXfadef_na_nice,
 480                                              CXfadef_nde_nice,
 481                                              CXfadef_nf,
 482                                              flap_pos,
 483                                              Alpha,
 484                                              elevator);
 485             else
 486               CXfadefI = uiuc_3Dinterpolation(CXfadef_fArray,
 487                                               CXfadef_aArray,
 488                                               CXfadef_deArray,
 489                                               CXfadef_CXArray,
 490                                               CXfadef_nAlphaArray,
 491                                               CXfadef_nde,
 492                                               CXfadef_nf,
 493                                               flap_pos,
 494                                               Alpha,
 495                                               elevator);
 496             CX += CXfadefI;
 497             break;
 498           }
 499         case CXfaqf_flag:
 500           {
 501             q_nondim = Q_body * cbar_2U;
 502             if (CXfaqf_nice == 1)
 503               CXfaqfI = uiuc_3Dinterp_quick(CXfaqf_fArray,
 504                                             CXfaqf_aArray_nice,
 505                                             CXfaqf_qArray_nice,
 506                                             CXfaqf_CXArray,
 507                                             CXfaqf_na_nice,
 508                                             CXfaqf_nq_nice,
 509                                             CXfaqf_nf,
 510                                             flap_pos,
 511                                             Alpha,
 512                                             q_nondim);
 513             else
 514               CXfaqfI = uiuc_3Dinterpolation(CXfaqf_fArray,
 515                                              CXfaqf_aArray,
 516                                              CXfaqf_qArray,
 517                                              CXfaqf_CXArray,
 518                                              CXfaqf_nAlphaArray,
 519                                              CXfaqf_nq,
 520                                              CXfaqf_nf,
 521                                              flap_pos,
 522                                              Alpha,
 523                                              q_nondim);
 524             CX += CXfaqfI;
 525             break;
 526           }
 527         };
 528     } // end CD map
 529
 530   return;
 531 }
 532
 533 // end uiuc_coef_drag.cpp