src/FDM/UIUCModel/uiuc_coef_lift.cpp

   1 /**********************************************************************
   2
   3  FILENAME:     uiuc_coef_lift.cpp
   4
   5 ----------------------------------------------------------------------
   6
   7  DESCRIPTION:  computes aggregated aerodynamic lift 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                -lift coefficient components
  37                -icing parameters
  38                -cbar_2U multiplier
  39
  40 ----------------------------------------------------------------------
  41
  42  OUTPUTS:      -CL
  43
  44 ----------------------------------------------------------------------
  45
  46  CALLED BY:    uiuc_coefficients.cpp
  47
  48 ----------------------------------------------------------------------
  49
  50  CALLS TO:     uiuc_1Dinterpolation
  51                uiuc_2Dinterpolation
  52                uiuc_ice_filter
  53
  54 ----------------------------------------------------------------------
  55
  56  COPYRIGHT:    (C) 2000 by Michael Selig
  57
  58  This program is free software; you can redistribute it and/or
  59  modify it under the terms of the GNU General Public License
  60  as published by the Free Software Foundation.
  61
  62  This program is distributed in the hope that it will be useful,
  63  but WITHOUT ANY WARRANTY; without even the implied warranty of
  64  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  65  GNU General Public License for more details.
  66
  67  You should have received a copy of the GNU General Public License
  68  along with this program; if not, write to the Free Software
  69  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  70  USA or view http://www.gnu.org/copyleft/gpl.html.
  71
  72 **********************************************************************/
  73
  74 #include "uiuc_coef_lift.h"
  75
  76
  77 void uiuc_coef_lift()
  78 {
  79   string linetoken1;
  80   string linetoken2;
  81   stack command_list;
  82
  83   command_list = aeroLiftParts -> getCommands();
  84
  85   for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
  86     {
  87       linetoken1 = aeroLiftParts -> getToken(*command_line, 1);
  88       linetoken2 = aeroLiftParts -> getToken(*command_line, 2);
  89
  90       switch (CL_map[linetoken2])
  91         {
  92         case CLo_flag:
  93           {
  94             if (ice_on)
  95               {
  96                 CLo = uiuc_ice_filter(CLo_clean,kCLo);
  97                 if (beta_model)
  98                   {
  99                     CLclean_wing += CLo_clean;
 100                     CLclean_tail += CLo_clean;
 101                     CLiced_wing += CLo;
 102                     CLiced_tail += CLo;
 103                   }
 104               }
 105             CL += CLo;
 106             break;
 107           }
 108         case CL_a_flag:
 109           {
 110             if (ice_on)
 111               {
 112                 CL_a = uiuc_ice_filter(CL_a_clean,kCL_a);
 113                 if (beta_model)
 114                   {
 115                     CLclean_wing += CL_a_clean * Alpha;
 116                     CLclean_tail += CL_a_clean * Alpha;
 117                     CLiced_wing += CL_a * Alpha;
 118                     CLiced_tail += CL_a * Alpha;
 119                   }
 120               }
 121             CL += CL_a * Alpha;
 122             break;
 123           }
 124         case CL_adot_flag:
 125           {
 126             if (ice_on)
 127               {
 128                 CL_adot = uiuc_ice_filter(CL_adot_clean,kCL_adot);
 129                 if (beta_model)
 130                   {
 131                     CLclean_wing += CL_adot_clean * Alpha_dot * cbar_2U;
 132                     CLclean_tail += CL_adot_clean * Alpha_dot * ch_2U;
 133                     CLiced_wing += CL_adot * Alpha_dot * cbar_2U;
 134                     CLiced_tail += CL_adot * Alpha_dot * ch_2U;
 135                   }
 136               }
 137             /* CL_adot must be mulitplied by cbar/2U
 138                (see Roskam Control book, Part 1, pg. 147) */
 139             CL += CL_adot * Alpha_dot * cbar_2U;
 140             break;
 141           }
 142         case CL_q_flag:
 143           {
 144             if (ice_on)
 145               {
 146                 CL_q = uiuc_ice_filter(CL_q_clean,kCL_q);
 147                 if (beta_model)
 148                   {
 149                     CLclean_wing += CL_q_clean * Theta_dot * cbar_2U;
 150                     CLclean_tail += CL_q_clean * Theta_dot * ch_2U;
 151                     CLiced_wing += CL_q * Theta_dot * cbar_2U;
 152                     CLiced_tail += CL_q * Theta_dot * ch_2U;
 153                   }
 154               }
 155             /* CL_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                that is what is done in c172_aero.c; assume it
 159                has something to do with axes systems */
 160             CL += CL_q * Theta_dot * cbar_2U;
 161             break;
 162           }
 163         case CL_ih_flag:
 164           {
 165             CL += CL_ih * ih;
 166             break;
 167           }
 168         case CL_de_flag:
 169           {
 170             if (ice_on)
 171               {
 172                 CL_de = uiuc_ice_filter(CL_de_clean,kCL_de);
 173                 if (beta_model)
 174                   {
 175                     CLclean_wing += CL_de_clean * elevator;
 176                     CLclean_tail += CL_de_clean * elevator;
 177                     CLiced_wing += CL_de * elevator;
 178                     CLiced_tail += CL_de * elevator;
 179                   }
 180               }
 181             CL += CL_de * elevator;
 182             break;
 183           }
 184         case CLfa_flag:
 185           {
 186             CLfaI = uiuc_1Dinterpolation(CLfa_aArray,
 187                                          CLfa_CLArray,
 188                                          CLfa_nAlpha,
 189                                          Alpha);
 190             CL += CLfaI;
 191             break;
 192           }
 193         case CLfade_flag:
 194           {
 195             CLfadeI = uiuc_2Dinterpolation(CLfade_aArray,
 196                                            CLfade_deArray,
 197                                            CLfade_CLArray,
 198                                            CLfade_nAlphaArray,
 199                                            CLfade_nde,
 200                                            Alpha,
 201                                            elevator);
 202             CL += CLfadeI;
 203             break;
 204           }
 205         case CLfdf_flag:
 206           {
 207             CLfdfI = uiuc_1Dinterpolation(CLfdf_dfArray,
 208                                           CLfdf_CLArray,
 209                                           CLfdf_ndf,
 210                                           flap);
 211             CL += CLfdfI;
 212             break;
 213           }
 214         case CLfadf_flag:
 215           {
 216             CLfadfI = uiuc_2Dinterpolation(CLfadf_aArray,
 217                                            CLfadf_dfArray,
 218                                            CLfadf_CLArray,
 219                                            CLfadf_nAlphaArray,
 220                                            CLfadf_ndf,
 221                                            Alpha,
 222                                            flap);
 223             CL += CLfadfI;
 224             break;
 225           }
 226         case CZo_flag:
 227           {
 228             if (ice_on)
 229               {
 230                 CZo = uiuc_ice_filter(CZo_clean,kCZo);
 231                 if (beta_model)
 232                   {
 233                     CZclean_wing += CZo_clean;
 234                     CZclean_tail += CZo_clean;
 235                     CZiced_wing += CZo;
 236                     CZiced_tail += CZo;
 237                   }
 238               }
 239             CZ += CZo;
 240             break;
 241           }
 242         case CZ_a_flag:
 243           {
 244             if (ice_on)
 245               {
 246                 CZ_a = uiuc_ice_filter(CZ_a_clean,kCZ_a);
 247                 if (beta_model)
 248                   {
 249                     CZclean_wing += CZ_a_clean * Alpha;
 250                     CZclean_tail += CZ_a_clean * Alpha;
 251                     CZiced_wing += CZ_a * Alpha;
 252                     CZiced_tail += CZ_a * Alpha;
 253                   }
 254               }
 255             CZ += CZ_a * Alpha;
 256             break;
 257           }
 258         case CZ_a2_flag:
 259           {
 260             if (ice_on)
 261               {
 262                 CZ_a2 = uiuc_ice_filter(CZ_a2_clean,kCZ_a2);
 263                 if (beta_model)
 264                   {
 265                     CZclean_wing += CZ_a2_clean * Alpha * Alpha;
 266                     CZclean_tail += CZ_a2_clean * Alpha * Alpha;
 267                     CZiced_wing += CZ_a2 * Alpha * Alpha;
 268                     CZiced_tail += CZ_a2 * Alpha * Alpha;
 269                   }
 270               }
 271             CZ += CZ_a2 * Alpha * Alpha;
 272             break;
 273           }
 274         case CZ_a3_flag:
 275           {
 276             if (ice_on)
 277               {
 278                 CZ_a3 = uiuc_ice_filter(CZ_a3_clean,kCZ_a3);
 279                 if (beta_model)
 280                   {
 281                     CZclean_wing += CZ_a3_clean * Alpha * Alpha * Alpha;
 282                     CZclean_tail += CZ_a3_clean * Alpha * Alpha * Alpha;
 283                     CZiced_wing += CZ_a3 * Alpha * Alpha * Alpha;
 284                     CZiced_tail += CZ_a3 * Alpha * Alpha * Alpha;
 285                   }
 286               }
 287             CZ += CZ_a3 * Alpha * Alpha * Alpha;
 288             break;
 289           }
 290         case CZ_adot_flag:
 291           {
 292             if (ice_on)
 293               {
 294                 CZ_adot = uiuc_ice_filter(CZ_adot_clean,kCZ_adot);
 295                 if (beta_model)
 296                   {
 297                     CZclean_wing += CZ_adot_clean * Alpha_dot * cbar_2U;
 298                     CZclean_tail += CZ_adot_clean * Alpha_dot * ch_2U;
 299                     CZiced_wing += CZ_adot * Alpha_dot * cbar_2U;
 300                     CZiced_tail += CZ_adot * Alpha_dot * ch_2U;
 301                   }
 302               }
 303             /* CZ_adot must be mulitplied by cbar/2U
 304                (see Roskam Control book, Part 1, pg. 147) */
 305             CZ += CZ_adot * Alpha_dot * cbar_2U;
 306             break;
 307           }
 308         case CZ_q_flag:
 309           {
 310             if (ice_on)
 311               {
 312                 CZ_q = uiuc_ice_filter(CZ_q_clean,kCZ_q);
 313                 if (beta_model)
 314                   {
 315                     CZclean_wing += CZ_q_clean * Q_body * cbar_2U;
 316                     CZclean_tail += CZ_q_clean * Q_body * ch_2U;
 317                     CZiced_wing += CZ_q * Q_body * cbar_2U;
 318                     CZiced_tail += CZ_q * Q_body * ch_2U;
 319                   }
 320               }
 321             /* CZ_q must be mulitplied by cbar/2U
 322                (see Roskam Control book, Part 1, pg. 147) */
 323             CZ += CZ_q * Q_body * cbar_2U;
 324             break;
 325           }
 326         case CZ_de_flag:
 327           {
 328             if (ice_on)
 329               {
 330                 CZ_de = uiuc_ice_filter(CZ_de_clean,kCZ_de);
 331                 if (beta_model)
 332                   {
 333                     CZclean_wing += CZ_de_clean * elevator;
 334                     CZclean_tail += CZ_de_clean * elevator;
 335                     CZiced_wing += CZ_de * elevator;
 336                     CZiced_tail += CZ_de * elevator;
 337                   }
 338               }
 339             CZ += CZ_de * elevator;
 340             break;
 341           }
 342         case CZ_deb2_flag:
 343           {
 344             if (ice_on)
 345               {
 346                 CZ_deb2 = uiuc_ice_filter(CZ_deb2_clean,kCZ_deb2);
 347                 if (beta_model)
 348                   {
 349                     CZclean_wing += CZ_deb2_clean * elevator * Beta * Beta;
 350                     CZclean_tail += CZ_deb2_clean * elevator * Beta * Beta;
 351                     CZiced_wing += CZ_deb2 * elevator * Beta * Beta;
 352                     CZiced_tail += CZ_deb2 * elevator * Beta * Beta;
 353                   }
 354               }
 355             CZ += CZ_deb2 * elevator * Beta * Beta;
 356             break;
 357           }
 358         case CZ_df_flag:
 359           {
 360             if (ice_on)
 361               {
 362                 CZ_df = uiuc_ice_filter(CZ_df_clean,kCZ_df);
 363                 if (beta_model)
 364                   {
 365                     CZclean_wing += CZ_df_clean * flap;
 366                     CZclean_tail += CZ_df_clean * flap;
 367                     CZiced_wing += CZ_df * flap;
 368                     CZiced_tail += CZ_df * flap;
 369                   }
 370               }
 371             CZ += CZ_df * flap;
 372             break;
 373           }
 374         case CZ_adf_flag:
 375           {
 376             if (ice_on)
 377               {
 378                 CZ_adf = uiuc_ice_filter(CZ_adf_clean,kCZ_adf);
 379                 if (beta_model)
 380                   {
 381                     CZclean_wing += CZ_adf_clean * Alpha * flap;
 382                     CZclean_tail += CZ_adf_clean * Alpha * flap;
 383                     CZiced_wing += CZ_adf * Alpha * flap;
 384                     CZiced_tail += CZ_adf * Alpha * flap;
 385                   }
 386               }
 387             CZ += CZ_adf * Alpha * flap;
 388             break;
 389           }
 390         };
 391     } // end CL map
 392
 393   return;
 394 }
 395
 396 // end uiuc_coef_lift.cpp