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         http://www.jeffscott.net/
  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  83
  84 **********************************************************************/
  85
  86 #include "uiuc_coef_drag.h"
  87 #include <math.h>
  88
  89 void uiuc_coef_drag()
  90 {
  91   string linetoken1;
  92   string linetoken2;
  93   stack command_list;
  94
  95   double q_nondim;
  96
  97   command_list = aeroDragParts -> getCommands();
  98
  99   for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
 100     {
 101       linetoken1 = aeroDragParts -> getToken(*command_line, 1);
 102       linetoken2 = aeroDragParts -> getToken(*command_line, 2);
 103
 104       switch (CD_map[linetoken2])
 105         {
 106         case CDo_flag:
 107           {
 108             if (ice_on)
 109               {
 110                 CDo = uiuc_ice_filter(CDo_clean,kCDo);
 111               }
 112             CDo_save = CDo;
 113             CD += CDo_save;
 114             break;
 115           }
 116         case CDK_flag:
 117           {
 118             if (ice_on)
 119               {
 120                 CDK = uiuc_ice_filter(CDK_clean,kCDK);
 121               }
 122             if (b_CLK)
 123               {
 124                 CDK_save = CDK * (CL - CLK) * (CL - CLK);
 125               }
 126             else
 127               {
 128                 CDK_save = CDK * CL * CL;
 129               }
 130             CD += CDK_save;
 131             break;
 132           }
 133         case CD_a_flag:
 134           {
 135             if (ice_on)
 136               {
 137                 CD_a = uiuc_ice_filter(CD_a_clean,kCD_a);
 138               }
 139             CD_a_save = CD_a * Std_Alpha;
 140             CD += CD_a_save;
 141             break;
 142           }
 143         case CD_adot_flag:
 144           {
 145             if (ice_on)
 146               {
 147                 CD_adot = uiuc_ice_filter(CD_adot_clean,kCD_adot);
 148               }
 149             /* CD_adot must be mulitplied by cbar/2U
 150                (see Roskam Control book, Part 1, pg. 147) */
 151             CD_adot_save = CD_adot * Std_Alpha_dot * cbar_2U;
 152             CD += CD_adot_save;
 153             break;
 154           }
 155         case CD_q_flag:
 156           {
 157             if (ice_on)
 158               {
 159                 CD_q = uiuc_ice_filter(CD_q_clean,kCD_q);
 160               }
 161             /* CD_q must be mulitplied by cbar/2U
 162                (see Roskam Control book, Part 1, pg. 147) */
 163             /* why multiply by Theta_dot instead of Q_body?
 164                see note in coef_lift.cpp */
 165             CD_q_save = CD_q * Theta_dot * cbar_2U;
 166             CD += CD_q_save;
 167             break;
 168           }
 169         case CD_ih_flag:
 170           {
 171             CD_ih_save = fabs(CD_ih * ih);
 172             CD += CD_ih_save;
 173             break;
 174           }
 175         case CD_de_flag:
 176           {
 177             if (ice_on)
 178               {
 179                 CD_de = uiuc_ice_filter(CD_de_clean,kCD_de);
 180               }
 181             CD_de_save = fabs(CD_de * elevator);
 182             CD += CD_de_save;
 183             break;
 184           }
 185         case CD_dr_flag:
 186           {
 187             CD_dr_save = fabs(CD_dr * rudder);
 188             CD += CD_dr_save;
 189             break;
 190           }
 191         case CD_da_flag:
 192           {
 193             CD_da_save = fabs(CD_da * aileron);
 194             CD += CD_da_save;
 195             break;
 196           }
 197         case CD_beta_flag:
 198           {
 199             CD_beta_save = fabs(CD_beta * Std_Beta);
 200             CD += CD_beta_save;
 201             break;
 202           }
 203         case CD_df_flag:
 204           {
 205             CD_df_save = fabs(CD_df * flap_pos);
 206             CD += CD_df_save;
 207             break;
 208           }
 209         case CD_ds_flag:
 210           {
 211             CD_ds_save = fabs(CD_ds * spoiler_pos);
 212             CD += CD_ds_save;
 213             break;
 214           }
 215         case CD_dg_flag:
 216           {
 217             CD_dg_save = fabs(CD_dg * gear_pos_norm);
 218             CD += CD_dg_save;
 219             break;
 220           }
 221         case CDfa_flag:
 222           {
 223             CDfaI = uiuc_1Dinterpolation(CDfa_aArray,
 224                                          CDfa_CDArray,
 225                                          CDfa_nAlpha,
 226                                          Std_Alpha);
 227             CD += CDfaI;
 228             break;
 229           }
 230         case CDfCL_flag:
 231           {
 232             CDfCLI = uiuc_1Dinterpolation(CDfCL_CLArray,
 233                                           CDfCL_CDArray,
 234                                           CDfCL_nCL,
 235                                           CL);
 236             CD += CDfCLI;
 237             break;
 238           }
 239         case CDfdf_flag:
 240           {
 241             CDfdfI = uiuc_1Dinterpolation(CDfdf_dfArray,
 242                                           CDfdf_CDArray,
 243                                           CDfdf_ndf,
 244                                           flap_pos);
 245             CD += CDfdfI;
 246             break;
 247           }
 248         case CDfade_flag:
 249           {
 250             CDfadeI = uiuc_2Dinterpolation(CDfade_aArray,
 251                                            CDfade_deArray,
 252                                            CDfade_CDArray,
 253                                            CDfade_nAlphaArray,
 254                                            CDfade_nde,
 255                                            Std_Alpha,
 256                                            elevator);
 257                   CD += CDfadeI;
 258                   break;
 259           }
 260         case CDfadf_flag:
 261           {
 262             CDfadfI = uiuc_2Dinterpolation(CDfadf_aArray,
 263                                            CDfadf_dfArray,
 264                                            CDfadf_CDArray,
 265                                            CDfadf_nAlphaArray,
 266                                            CDfadf_ndf,
 267                                            Std_Alpha,
 268                                            flap_pos);
 269             CD += CDfadfI;
 270             break;
 271           }
 272         case CXo_flag:
 273           {
 274             if (ice_on)
 275               {
 276                 CXo = uiuc_ice_filter(CXo_clean,kCXo);
 277                 if (beta_model)
 278                   {
 279                     CXclean_wing += CXo_clean;
 280                     CXclean_tail += CXo_clean;
 281                     CXiced_wing += CXo;
 282                     CXiced_tail += CXo;
 283                   }
 284               }
 285             CXo_save = CXo;
 286             CX += CXo_save;
 287             break;
 288           }
 289         case CXK_flag:
 290           {
 291             if (ice_on)
 292               {
 293                 CXK = uiuc_ice_filter(CXK_clean,kCXK);
 294                 if (beta_model)
 295                   {
 296                     CXclean_wing += CXK_clean * CLclean_wing * CLclean_wing;
 297                     CXclean_tail += CXK_clean * CLclean_tail * CLclean_tail;
 298                     CXiced_wing += CXK * CLiced_wing * CLiced_wing;
 299                     CXiced_tail += CXK * CLiced_tail * CLiced_tail;
 300                   }
 301               }
 302             CXK_save = CXK * CZ * CZ;
 303             CX += CXK_save;
 304             break;
 305           }
 306         case CX_a_flag:
 307           {
 308             if (ice_on)
 309               {
 310                 CX_a = uiuc_ice_filter(CX_a_clean,kCX_a);
 311                 if (beta_model)
 312                   {
 313                     CXclean_wing += CX_a_clean * Std_Alpha;
 314                     CXclean_tail += CX_a_clean * Std_Alpha;
 315                     CXiced_wing += CX_a * Std_Alpha;
 316                     CXiced_tail += CX_a * Std_Alpha;
 317                   }
 318               }
 319             CX_a_save = CX_a * Std_Alpha;
 320             CX += CX_a_save;
 321             break;
 322           }
 323         case CX_a2_flag:
 324           {
 325             if (ice_on)
 326               {
 327                 CX_a2 = uiuc_ice_filter(CX_a2_clean,kCX_a2);
 328                 if (beta_model)
 329                   {
 330                     CXclean_wing += CX_a2_clean * Std_Alpha * Std_Alpha;
 331                     CXclean_tail += CX_a2_clean * Std_Alpha * Std_Alpha;
 332                     CXiced_wing += CX_a2 * Std_Alpha * Std_Alpha;
 333                     CXiced_tail += CX_a2 * Std_Alpha * Std_Alpha;
 334                   }
 335               }
 336             CX_a2_save = CX_a2 * Std_Alpha * Std_Alpha;
 337             CX += CX_a2_save;
 338             break;
 339           }
 340         case CX_a3_flag:
 341           {
 342             if (ice_on)
 343               {
 344                 CX_a3 = uiuc_ice_filter(CX_a3_clean,kCX_a3);
 345                 if (beta_model)
 346                   {
 347                     CXclean_wing += CX_a3_clean * Std_Alpha * Std_Alpha * Std_Alpha;
 348                     CXclean_tail += CX_a3_clean * Std_Alpha * Std_Alpha * Std_Alpha;
 349                     CXiced_wing += CX_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
 350                     CXiced_tail += CX_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
 351                   }
 352               }
 353             CX_a3_save = CX_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
 354             CX += CX_a3_save;
 355             break;
 356           }
 357         case CX_adot_flag:
 358           {
 359             if (ice_on)
 360               {
 361                 CX_adot = uiuc_ice_filter(CX_adot_clean,kCX_adot);
 362                 if (beta_model)
 363                   {
 364                     CXclean_wing += CX_adot_clean * Std_Alpha_dot * cbar_2U;
 365                     CXclean_tail += CX_adot_clean * Std_Alpha_dot * ch_2U;
 366                     CXiced_wing += CX * Std_Alpha_dot * cbar_2U;
 367                     CXiced_tail += CX * Std_Alpha_dot * ch_2U;
 368                   }
 369               }
 370             /* CX_adot must be mulitplied by cbar/2U
 371                (see Roskam Control book, Part 1, pg. 147) */
 372             CX_adot_save = CX_adot * Std_Alpha_dot * cbar_2U;
 373             CX += CX_adot_save;
 374             break;
 375           }
 376         case CX_q_flag:
 377           {
 378             if (ice_on)
 379               {
 380                 CX_q = uiuc_ice_filter(CX_q_clean,kCX_q);
 381                 if (beta_model)
 382                   {
 383                     CXclean_wing += CX_q_clean * Q_body * cbar_2U;
 384                     CXclean_tail += CX_q_clean * Q_body * ch_2U;
 385                     CXiced_wing += CX_q * Q_body * cbar_2U;
 386                     CXiced_tail += CX_q * Q_body * ch_2U;
 387                   }
 388               }
 389             /* CX_q must be mulitplied by cbar/2U
 390                (see Roskam Control book, Part 1, pg. 147) */
 391             CX_q_save = CX_q * Q_body * cbar_2U;
 392             CX += CX_q_save;
 393             break;
 394           }
 395         case CX_de_flag:
 396           {
 397             if (ice_on)
 398               {
 399                 CX_de = uiuc_ice_filter(CX_de_clean,kCX_de);
 400                 if (beta_model)
 401                   {
 402                     CXclean_wing += CX_de_clean * elevator;
 403                     CXclean_tail += CX_de_clean * elevator;
 404                     CXiced_wing += CX_de * elevator;
 405                     CXiced_tail += CX_de * elevator;
 406                   }
 407               }
 408             CX_de_save = CX_de * elevator;
 409             CX += CX_de_save;
 410             break;
 411           }
 412         case CX_dr_flag:
 413           {
 414             if (ice_on)
 415               {
 416                 CX_dr = uiuc_ice_filter(CX_dr_clean,kCX_dr);
 417                 if (beta_model)
 418                   {
 419                     CXclean_wing += CX_dr_clean * rudder;
 420                     CXclean_tail += CX_dr_clean * rudder;
 421                     CXiced_wing += CX_dr * rudder;
 422                     CXiced_tail += CX_dr * rudder;
 423                   }
 424               }
 425             CX_dr_save = CX_dr * rudder;
 426             CX += CX_dr_save;
 427             break;
 428           }
 429         case CX_df_flag:
 430           {
 431             if (ice_on)
 432               {
 433                 CX_df = uiuc_ice_filter(CX_df_clean,kCX_df);
 434                 if (beta_model)
 435                   {
 436                     CXclean_wing += CX_df_clean * flap_pos;
 437                     CXclean_tail += CX_df_clean * flap_pos;
 438                     CXiced_wing += CX * flap_pos;
 439                     CXiced_tail += CX * flap_pos;
 440                   }
 441               }
 442             CX_df_save = CX_df * flap_pos;
 443             CX += CX_df_save;
 444             break;
 445           }
 446         case CX_adf_flag:
 447           {
 448             if (ice_on)
 449               {
 450                 CX_adf = uiuc_ice_filter(CX_adf_clean,kCX_adf);
 451                 if (beta_model)
 452                   {
 453                     CXclean_wing += CX_adf_clean * Std_Alpha * flap_pos;
 454                     CXclean_tail += CX_adf_clean * Std_Alpha * flap_pos;
 455                     CXiced_wing += CX_adf * Std_Alpha * flap_pos;
 456                     CXiced_tail += CX_adf * Std_Alpha * flap_pos;
 457                   }
 458               }
 459             CX_adf_save = CX_adf * Std_Alpha * flap_pos;
 460             CX += CX_adf_save;
 461             break;
 462           }
 463         case CXfabetaf_flag:
 464           {
 465             if (CXfabetaf_nice == 1) {
 466               CXfabetafI = uiuc_3Dinterp_quick(CXfabetaf_fArray,
 467                                                CXfabetaf_aArray_nice,
 468                                                CXfabetaf_bArray_nice,
 469                                                CXfabetaf_CXArray,
 470                                                CXfabetaf_na_nice,
 471                                                CXfabetaf_nb_nice,
 472                                                CXfabetaf_nf,
 473                                                flap_pos,
 474                                                Std_Alpha,
 475                                                Std_Beta);
 476               // temp until Jim's code works
 477               //CXo = uiuc_3Dinterp_quick(CXfabetaf_fArray,
 478               //                         CXfabetaf_aArray_nice,
 479               //                         CXfabetaf_bArray_nice,
 480               //                         CXfabetaf_CXArray,
 481               //                         CXfabetaf_na_nice,
 482               //                         CXfabetaf_nb_nice,
 483               //                         CXfabetaf_nf,
 484               //                         flap_pos,
 485               //                         0.0,
 486               //                         Std_Beta);
 487             }
 488             else {
 489               CXfabetafI = uiuc_3Dinterpolation(CXfabetaf_fArray,
 490                                                 CXfabetaf_aArray,
 491                                                 CXfabetaf_betaArray,
 492                                                 CXfabetaf_CXArray,
 493                                                 CXfabetaf_nAlphaArray,
 494                                                 CXfabetaf_nbeta,
 495                                                 CXfabetaf_nf,
 496                                                 flap_pos,
 497                                                 Std_Alpha,
 498                                                 Std_Beta);
 499               // temp until Jim's code works
 500               //CXo = uiuc_3Dinterpolation(CXfabetaf_fArray,
 501               //                          CXfabetaf_aArray,
 502               //                          CXfabetaf_betaArray,
 503               //                          CXfabetaf_CXArray,
 504               //                          CXfabetaf_nAlphaArray,
 505               //                          CXfabetaf_nbeta,
 506               //                          CXfabetaf_nf,
 507               //                          flap_pos,
 508               //                          0.0,
 509               //                          Std_Beta);
 510             }
 511             CX += CXfabetafI;
 512             break;
 513           }
 514         case CXfadef_flag:
 515           {
 516             if (CXfadef_nice == 1)
 517               CXfadefI = uiuc_3Dinterp_quick(CXfadef_fArray,
 518                                              CXfadef_aArray_nice,
 519                                              CXfadef_deArray_nice,
 520                                              CXfadef_CXArray,
 521                                              CXfadef_na_nice,
 522                                              CXfadef_nde_nice,
 523                                              CXfadef_nf,
 524                                              flap_pos,
 525                                              Std_Alpha,
 526                                              elevator);
 527             else
 528               CXfadefI = uiuc_3Dinterpolation(CXfadef_fArray,
 529                                               CXfadef_aArray,
 530                                               CXfadef_deArray,
 531                                               CXfadef_CXArray,
 532                                               CXfadef_nAlphaArray,
 533                                               CXfadef_nde,
 534                                               CXfadef_nf,
 535                                               flap_pos,
 536                                               Std_Alpha,
 537                                               elevator);
 538             CX += CXfadefI;
 539             break;
 540           }
 541         case CXfaqf_flag:
 542           {
 543             q_nondim = Q_body * cbar_2U;
 544             if (CXfaqf_nice == 1)
 545               CXfaqfI = uiuc_3Dinterp_quick(CXfaqf_fArray,
 546                                             CXfaqf_aArray_nice,
 547                                             CXfaqf_qArray_nice,
 548                                             CXfaqf_CXArray,
 549                                             CXfaqf_na_nice,
 550                                             CXfaqf_nq_nice,
 551                                             CXfaqf_nf,
 552                                             flap_pos,
 553                                             Std_Alpha,
 554                                             q_nondim);
 555             else
 556               CXfaqfI = uiuc_3Dinterpolation(CXfaqf_fArray,
 557                                              CXfaqf_aArray,
 558                                              CXfaqf_qArray,
 559                                              CXfaqf_CXArray,
 560                                              CXfaqf_nAlphaArray,
 561                                              CXfaqf_nq,
 562                                              CXfaqf_nf,
 563                                              flap_pos,
 564                                              Std_Alpha,
 565                                              q_nondim);
 566             CX += CXfaqfI;
 567             break;
 568           }
 569         };
 570     } // end CD map
 571
 572   return;
 573 }
 574
 575 // end uiuc_coef_drag.cpp