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
  23 ----------------------------------------------------------------------
  24
  25  AUTHOR(S):    Bipin Sehgal       <bsehgal@uiuc.edu>
  26                Jeff Scott         <jscott@mail.com>
  27
  28 ----------------------------------------------------------------------
  29
  30  VARIABLES:
  31
  32 ----------------------------------------------------------------------
  33
  34  INPUTS:       -Alpha
  35                -elevator
  36                -drag coefficient components
  37                -icing parameters
  38
  39 ----------------------------------------------------------------------
  40
  41  OUTPUTS:      -CD
  42
  43 ----------------------------------------------------------------------
  44
  45  CALLED BY:    uiuc_coefficients.cpp
  46
  47 ----------------------------------------------------------------------
  48
  49  CALLS TO:     uiuc_1Dinterpolation
  50                uiuc_2Dinterpolation
  51                uiuc_ice_filter
  52
  53 ----------------------------------------------------------------------
  54
  55  COPYRIGHT:    (C) 2000 by Michael Selig
  56
  57  This program is free software; you can redistribute it and/or
  58  modify it under the terms of the GNU General Public License
  59  as published by the Free Software Foundation.
  60
  61  This program is distributed in the hope that it will be useful,
  62  but WITHOUT ANY WARRANTY; without even the implied warranty of
  63  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  64  GNU General Public License for more details.
  65
  66  You should have received a copy of the GNU General Public License
  67  along with this program; if not, write to the Free Software
  68  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  69  USA or view http://www.gnu.org/copyleft/gpl.html.
  70
  71 **********************************************************************/
  72
  73 #include "uiuc_coef_drag.h"
  74
  75
  76 void uiuc_coef_drag()
  77 {
  78   string linetoken1;
  79   string linetoken2;
  80   stack command_list;
  81
  82   command_list = aeroDragParts -> getCommands();
  83
  84   for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
  85     {
  86       linetoken1 = aeroDragParts -> getToken(*command_line, 1);
  87       linetoken2 = aeroDragParts -> getToken(*command_line, 2);
  88
  89       switch (CD_map[linetoken2])
  90         {
  91         case CDo_flag:
  92           {
  93             if (ice_on)
  94               {
  95                 CDo = uiuc_ice_filter(CDo_clean,kCDo);
  96               }
  97             CD += CDo;
  98             break;
  99           }
 100         case CDK_flag:
 101           {
 102             if (ice_on)
 103               {
 104                 CDK = uiuc_ice_filter(CDK_clean,kCDK);
 105               }
 106             CD += CDK * CL * CL;
 107             break;
 108           }
 109         case CD_a_flag:
 110           {
 111             if (ice_on)
 112               {
 113                 CD_a = uiuc_ice_filter(CD_a_clean,kCD_a);
 114               }
 115             CD += CD_a * Alpha;
 116             break;
 117           }
 118         case CD_adot_flag:
 119           {
 120             if (ice_on)
 121               {
 122                 CD_adot = uiuc_ice_filter(CD_adot_clean,kCD_adot);
 123               }
 124             /* CD_adot must be mulitplied by cbar/2U
 125                (see Roskam Control book, Part 1, pg. 147) */
 126             CD += CD_adot * Alpha_dot * cbar_2U;
 127             break;
 128           }
 129         case CD_q_flag:
 130           {
 131             if (ice_on)
 132               {
 133                 CD_q = uiuc_ice_filter(CD_q_clean,kCD_q);
 134               }
 135             /* CD_q must be mulitplied by cbar/2U
 136                (see Roskam Control book, Part 1, pg. 147) */
 137             /* why multiply by Theta_dot instead of Q_body?
 138                see note in coef_lift.cpp */
 139             CD += CD_q * Theta_dot * cbar_2U;
 140             break;
 141           }
 142         case CD_ih_flag:
 143           {
 144             CD += CD_ih * ih;
 145             break;
 146           }
 147         case CD_de_flag:
 148           {
 149             if (ice_on)
 150               {
 151                 CD_de = uiuc_ice_filter(CD_de_clean,kCD_de);
 152               }
 153             CD += CD_de * elevator;
 154             break;
 155           }
 156         case CDfa_flag:
 157           {
 158             CDfaI = uiuc_1Dinterpolation(CDfa_aArray,
 159                                          CDfa_CDArray,
 160                                          CDfa_nAlpha,
 161                                          Alpha);
 162             CD += CDfaI;
 163             break;
 164           }
 165         case CDfCL_flag:
 166           {
 167             CDfCLI = uiuc_1Dinterpolation(CDfCL_CLArray,
 168                                           CDfCL_CDArray,
 169                                           CDfCL_nCL,
 170                                           CL);
 171             CD += CDfCLI;
 172             break;
 173           }
 174         case CDfdf_flag:
 175           {
 176             CDfdfI = uiuc_1Dinterpolation(CDfdf_dfArray,
 177                                           CDfdf_CDArray,
 178                                           CDfdf_ndf,
 179                                           flap);
 180             CD += CDfdfI;
 181             break;
 182           }
 183         case CDfade_flag:
 184           {
 185             CDfadeI = uiuc_2Dinterpolation(CDfade_aArray,
 186                                            CDfade_deArray,
 187                                            CDfade_CDArray,
 188                                            CDfade_nAlphaArray,
 189                                            CDfade_nde,
 190                                            Alpha,
 191                                            elevator);
 192                   CD += CDfadeI;
 193                   break;
 194           }
 195         case CDfadf_flag:
 196           {
 197             CDfadfI = uiuc_2Dinterpolation(CDfadf_aArray,
 198                                            CDfadf_dfArray,
 199                                            CDfadf_CDArray,
 200                                            CDfadf_nAlphaArray,
 201                                            CDfadf_ndf,
 202                                            Alpha,
 203                                            flap);
 204             CD += CDfadfI;
 205             break;
 206           }
 207         case CXo_flag:
 208           {
 209             if (ice_on)
 210               {
 211                 CXo = uiuc_ice_filter(CXo_clean,kCXo);
 212                 if (beta_model)
 213                   {
 214                     CXclean_wing += CXo_clean;
 215                     CXclean_tail += CXo_clean;
 216                     CXiced_wing += CXo;
 217                     CXiced_tail += CXo;
 218                   }
 219               }
 220             CX += CXo;
 221             break;
 222           }
 223         case CXK_flag:
 224           {
 225             if (ice_on)
 226               {
 227                 CXK = uiuc_ice_filter(CXK_clean,kCXK);
 228                 if (beta_model)
 229                   {
 230                     CXclean_wing += CXK_clean * CLclean_wing * CLclean_wing;
 231                     CXclean_tail += CXK_clean * CLclean_tail * CLclean_tail;
 232                     CXiced_wing += CXK * CLiced_wing * CLiced_wing;
 233                     CXiced_tail += CXK * CLiced_tail * CLiced_tail;
 234                   }
 235               }
 236             CX += CXK * CZ * CZ;
 237             break;
 238           }
 239         case CX_a_flag:
 240           {
 241             if (ice_on)
 242               {
 243                 CX_a = uiuc_ice_filter(CX_a_clean,kCX_a);
 244                 if (beta_model)
 245                   {
 246                     CXclean_wing += CX_a_clean * Alpha;
 247                     CXclean_tail += CX_a_clean * Alpha;
 248                     CXiced_wing += CX_a * Alpha;
 249                     CXiced_tail += CX_a * Alpha;
 250                   }
 251               }
 252             CX += CX_a * Alpha;
 253             break;
 254           }
 255         case CX_a2_flag:
 256           {
 257             if (ice_on)
 258               {
 259                 CX_a2 = uiuc_ice_filter(CX_a2_clean,kCX_a2);
 260                 if (beta_model)
 261                   {
 262                     CXclean_wing += CX_a2_clean * Alpha * Alpha;
 263                     CXclean_tail += CX_a2_clean * Alpha * Alpha;
 264                     CXiced_wing += CX_a2 * Alpha * Alpha;
 265                     CXiced_tail += CX_a2 * Alpha * Alpha;
 266                   }
 267               }
 268             CX += CX_a2 * Alpha * Alpha;
 269             break;
 270           }
 271         case CX_a3_flag:
 272           {
 273             if (ice_on)
 274               {
 275                 CX_a3 = uiuc_ice_filter(CX_a3_clean,kCX_a3);
 276                 if (beta_model)
 277                   {
 278                     CXclean_wing += CX_a3_clean * Alpha * Alpha * Alpha;
 279                     CXclean_tail += CX_a3_clean * Alpha * Alpha * Alpha;
 280                     CXiced_wing += CX_a3 * Alpha * Alpha * Alpha;
 281                     CXiced_tail += CX_a3 * Alpha * Alpha * Alpha;
 282                   }
 283               }
 284             CX += CX_a3 * Alpha * Alpha * Alpha;
 285             break;
 286           }
 287         case CX_adot_flag:
 288           {
 289             if (ice_on)
 290               {
 291                 CX_adot = uiuc_ice_filter(CX_adot_clean,kCX_adot);
 292                 if (beta_model)
 293                   {
 294                     CXclean_wing += CX_adot_clean * Alpha_dot * cbar_2U;
 295                     CXclean_tail += CX_adot_clean * Alpha_dot * ch_2U;
 296                     CXiced_wing += CX * Alpha_dot * cbar_2U;
 297                     CXiced_tail += CX * Alpha_dot * ch_2U;
 298                   }
 299               }
 300             /* CX_adot must be mulitplied by cbar/2U
 301                (see Roskam Control book, Part 1, pg. 147) */
 302             CX += CX_adot * Alpha_dot * cbar_2U;
 303             break;
 304           }
 305         case CX_q_flag:
 306           {
 307             if (ice_on)
 308               {
 309                 CX_q = uiuc_ice_filter(CX_q_clean,kCX_q);
 310                 if (beta_model)
 311                   {
 312                     CXclean_wing += CX_q_clean * Q_body * cbar_2U;
 313                     CXclean_tail += CX_q_clean * Q_body * ch_2U;
 314                     CXiced_wing += CX_q * Q_body * cbar_2U;
 315                     CXiced_tail += CX_q * Q_body * ch_2U;
 316                   }
 317               }
 318             /* CX_q must be mulitplied by cbar/2U
 319                (see Roskam Control book, Part 1, pg. 147) */
 320             CX += CX_q * Q_body * cbar_2U;
 321             break;
 322           }
 323         case CX_de_flag:
 324           {
 325             if (ice_on)
 326               {
 327                 CX_de = uiuc_ice_filter(CX_de_clean,kCX_de);
 328                 if (beta_model)
 329                   {
 330                     CXclean_wing += CX_de_clean * elevator;
 331                     CXclean_tail += CX_de_clean * elevator;
 332                     CXiced_wing += CX_de * elevator;
 333                     CXiced_tail += CX_de * elevator;
 334                   }
 335               }
 336             CX += CX_de * elevator;
 337             break;
 338           }
 339         case CX_dr_flag:
 340           {
 341             if (ice_on)
 342               {
 343                 CX_dr = uiuc_ice_filter(CX_dr_clean,kCX_dr);
 344                 if (beta_model)
 345                   {
 346                     CXclean_wing += CX_dr_clean * rudder;
 347                     CXclean_tail += CX_dr_clean * rudder;
 348                     CXiced_wing += CX_dr * rudder;
 349                     CXiced_tail += CX_dr * rudder;
 350                   }
 351               }
 352             CX += CX_dr * rudder;
 353             break;
 354           }
 355         case CX_df_flag:
 356           {
 357             if (ice_on)
 358               {
 359                 CX_df = uiuc_ice_filter(CX_df_clean,kCX_df);
 360                 if (beta_model)
 361                   {
 362                     CXclean_wing += CX_df_clean * flap;
 363                     CXclean_tail += CX_df_clean * flap;
 364                     CXiced_wing += CX * flap;
 365                     CXiced_tail += CX * flap;
 366                   }
 367               }
 368             CX += CX_df * flap;
 369             break;
 370           }
 371         case CX_adf_flag:
 372           {
 373             if (ice_on)
 374               {
 375                 CX_adf = uiuc_ice_filter(CX_adf_clean,kCX_adf);
 376                 if (beta_model)
 377                   {
 378                     CXclean_wing += CX_adf_clean * Alpha * flap;
 379                     CXclean_tail += CX_adf_clean * Alpha * flap;
 380                     CXiced_wing += CX_adf * Alpha * flap;
 381                     CXiced_tail += CX_adf * Alpha * flap;
 382                   }
 383               }
 384             CX += CX_adf * Alpha * flap;
 385             break;
 386           }
 387         };
 388     } // end CD map
 389
 390   return;
 391 }
 392
 393 // end uiuc_coef_drag.cpp