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