src/FDM/UIUCModel/uiuc_coef_pitch.cpp

   1 /**********************************************************************
   2
   3  FILENAME:     uiuc_coef_pitch.cpp
   4
   5 ----------------------------------------------------------------------
   6
   7  DESCRIPTION:  computes aggregated aerodynamic pitch 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                             (Cmfxxf0)
  25                11/12/2001   (RD) Added new variables needed for the non-
  26                             linear Twin Otter model with flaps
  27                             (Cmfxxf).  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                -pitch coefficient components
  49                -icing parameters
  50                -cbar_2U multiplier
  51
  52 ----------------------------------------------------------------------
  53
  54  OUTPUTS:      -Cm
  55
  56 ----------------------------------------------------------------------
  57
  58  CALLED BY:    uiuc_coefficients.cpp
  59
  60 ----------------------------------------------------------------------
  61
  62  CALLS TO:     uiuc_1Dinterpolation
  63                uiuc_2Dinterpolation
  64                uiuc_ice_filter
  65                uiuc_3Dinterpolation
  66                uiuc_3Dinterp_quick
  67
  68 ----------------------------------------------------------------------
  69
  70  COPYRIGHT:    (C) 2000 by Michael Selig
  71
  72  This program is free software; you can redistribute it and/or
  73  modify it under the terms of the GNU General Public License
  74  as published by the Free Software Foundation.
  75
  76  This program is distributed in the hope that it will be useful,
  77  but WITHOUT ANY WARRANTY; without even the implied warranty of
  78  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  79  GNU General Public License for more details.
  80
  81  You should have received a copy of the GNU General Public License
  82  along with this program; if not, write to the Free Software
  83  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  84  USA or view http://www.gnu.org/copyleft/gpl.html.
  85
  86 **********************************************************************/
  87
  88 #include "uiuc_coef_pitch.h"
  89
  90
  91 void uiuc_coef_pitch()
  92 {
  93   string linetoken1;
  94   string linetoken2;
  95   stack command_list;
  96
  97   double q_nondim;
  98
  99   command_list = aeroPitchParts -> getCommands();
 100
 101   for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
 102     {
 103       linetoken1 = aeroPitchParts -> getToken(*command_line, 1);
 104       linetoken2 = aeroPitchParts -> getToken(*command_line, 2);
 105
 106       switch(Cm_map[linetoken2])
 107         {
 108         case Cmo_flag:
 109           {
 110             if (ice_on)
 111               {
 112                 Cmo = uiuc_ice_filter(Cmo_clean,kCmo);
 113               }
 114             Cmo_save = Cmo;
 115             Cm += Cmo;
 116             break;
 117           }
 118         case Cm_a_flag:
 119           {
 120             if (ice_on)
 121               {
 122                 Cm_a = uiuc_ice_filter(Cm_a_clean,kCm_a);
 123               }
 124             Cm_a_save = Cm_a * Alpha;
 125             Cm += Cm_a * Alpha;
 126             break;
 127           }
 128         case Cm_a2_flag:
 129           {
 130             if (ice_on)
 131               {
 132                 Cm_a2 = uiuc_ice_filter(Cm_a2_clean,kCm_a2);
 133               }
 134             Cm_a2_save = Cm_a2 * Alpha * Alpha;
 135             Cm += Cm_a2 * Alpha * Alpha;
 136             break;
 137           }
 138         case Cm_adot_flag:
 139           {
 140             if (ice_on)
 141               {
 142                 Cm_adot = uiuc_ice_filter(Cm_adot_clean,kCm_adot);
 143               }
 144             /* Cm_adot must be mulitplied by cbar/2U
 145                (see Roskam Control book, Part 1, pg. 147) */
 146             Cm_adot_save = Cm_adot * Alpha_dot * cbar_2U;
 147             //Cm        += Cm_adot * Alpha_dot * cbar_2U;
 148             if (eta_q_Cm_adot_fac)
 149               {
 150                 Cm += Cm_adot_save * eta_q_Cm_adot_fac;
 151               }
 152             else
 153               {
 154                 Cm += Cm_adot_save;
 155               }
 156             break;
 157           }
 158         case Cm_q_flag:
 159           {
 160             if (ice_on)
 161               {
 162                 Cm_q = uiuc_ice_filter(Cm_q_clean,kCm_q);
 163               }
 164             /* Cm_q must be mulitplied by cbar/2U
 165                (see Roskam Control book, Part 1, pg. 147) */
 166             Cm_q_save = Cm_q * Q_body * cbar_2U;
 167             // Cm    += Cm_q * Q_body * cbar_2U;
 168             if (eta_q_Cm_q_fac)
 169               {
 170                 Cm += Cm_q_save * eta_q_Cm_q_fac;
 171               }
 172             else
 173               {
 174                 Cm += Cm_q_save;
 175               }
 176             break;
 177           }
 178         case Cm_ih_flag:
 179           {
 180             Cm_ih_save = Cm_ih * ih;
 181             Cm += Cm_ih * ih;
 182             break;
 183           }
 184         case Cm_de_flag:
 185           {
 186             if (ice_on)
 187               {
 188                 Cm_de = uiuc_ice_filter(Cm_de_clean,kCm_de);
 189               }
 190             Cm_de_save = Cm_de * elevator;
 191             Cm += Cm_de * elevator;
 192             break;
 193           }
 194         case Cm_b2_flag:
 195           {
 196             if (ice_on)
 197               {
 198                 Cm_b2 = uiuc_ice_filter(Cm_b2_clean,kCm_b2);
 199               }
 200             Cm_b2_save = Cm_b2 * Beta * Beta;
 201             Cm += Cm_b2 * Beta * Beta;
 202             break;
 203           }
 204         case Cm_r_flag:
 205           {
 206             if (ice_on)
 207               {
 208                 Cm_r = uiuc_ice_filter(Cm_r_clean,kCm_r);
 209               }
 210             Cm_r_save = Cm_r * R_body * b_2U;
 211             Cm += Cm_r * R_body * b_2U;
 212             break;
 213           }
 214         case Cm_df_flag:
 215           {
 216             if (ice_on)
 217               {
 218                 Cm_df = uiuc_ice_filter(Cm_df_clean,kCm_df);
 219               }
 220             Cm_df_save = Cm_df * flap;
 221             Cm += Cm_df * flap;
 222             break;
 223           }
 224         case Cmfa_flag:
 225           {
 226             CmfaI = uiuc_1Dinterpolation(Cmfa_aArray,
 227                                          Cmfa_CmArray,
 228                                          Cmfa_nAlpha,
 229                                          Alpha);
 230             Cm += CmfaI;
 231             break;
 232           }
 233         case Cmfade_flag:
 234           {
 235             if(b_downwashMode)
 236               {
 237                 // compute the induced velocity on the tail to account for tail downwash
 238                 switch(downwashMode)
 239                   {
 240                   case 100:
 241                     if (V_rel_wind < dyn_on_speed)
 242                       {
 243                         alphaTail = Alpha;
 244                       }
 245                     else
 246                       {
 247                         gammaWing = V_rel_wind * Sw * CL / (2.0 * bw);
 248                         // printf("gammaWing = %.4f\n", (gammaWing));
 249                         downwash  = downwashCoef * gammaWing;
 250                         downwashAngle = atan(downwash/V_rel_wind);
 251                         alphaTail = Alpha - downwashAngle;
 252                       }
 253                     CmfadeI = uiuc_2Dinterpolation(Cmfade_aArray,
 254                                                    Cmfade_deArray,
 255                                                    Cmfade_CmArray,
 256                                                    Cmfade_nAlphaArray,
 257                                                    Cmfade_nde,
 258                                                    alphaTail,
 259                                                    elevator);
 260                     break;
 261                   }
 262               }
 263             else
 264               {
 265                 CmfadeI = uiuc_2Dinterpolation(Cmfade_aArray,
 266                                                Cmfade_deArray,
 267                                                Cmfade_CmArray,
 268                                                Cmfade_nAlphaArray,
 269                                                Cmfade_nde,
 270                                                Alpha,
 271                                                elevator);
 272               }
 273             if (eta_q_Cmfade_fac)
 274               {
 275                 Cm += CmfadeI * eta_q_Cmfade_fac;
 276               }
 277             else
 278               {
 279                 Cm += CmfadeI;
 280               }
 281             break;
 282           }
 283         case Cmfdf_flag:
 284           {
 285             CmfdfI = uiuc_1Dinterpolation(Cmfdf_dfArray,
 286                                           Cmfdf_CmArray,
 287                                           Cmfdf_ndf,
 288                                           flap);
 289             Cm += CmfdfI;
 290             break;
 291           }
 292         case Cmfadf_flag:
 293           {
 294             CmfadfI = uiuc_2Dinterpolation(Cmfadf_aArray,
 295                                            Cmfadf_dfArray,
 296                                            Cmfadf_CmArray,
 297                                            Cmfadf_nAlphaArray,
 298                                            Cmfadf_ndf,
 299                                            Alpha,
 300                                            flap);
 301             Cm += CmfadfI;
 302             break;
 303           }
 304         case Cmfabetaf_flag:
 305           {
 306             if (Cmfabetaf_nice == 1)
 307               CmfabetafI = uiuc_3Dinterp_quick(Cmfabetaf_fArray,
 308                                                Cmfabetaf_aArray_nice,
 309                                                Cmfabetaf_bArray_nice,
 310                                                Cmfabetaf_CmArray,
 311                                                Cmfabetaf_na_nice,
 312                                                Cmfabetaf_nb_nice,
 313                                                Cmfabetaf_nf,
 314                                                flap_pos,
 315                                                Alpha,
 316                                                Beta);
 317             else
 318               CmfabetafI = uiuc_3Dinterpolation(Cmfabetaf_fArray,
 319                                                 Cmfabetaf_aArray,
 320                                                 Cmfabetaf_betaArray,
 321                                                 Cmfabetaf_CmArray,
 322                                                 Cmfabetaf_nAlphaArray,
 323                                                 Cmfabetaf_nbeta,
 324                                                 Cmfabetaf_nf,
 325                                                 flap_pos,
 326                                                 Alpha,
 327                                                 Beta);
 328             Cm += CmfabetafI;
 329             break;
 330           }
 331         case Cmfadef_flag:
 332           {
 333             if (Cmfadef_nice == 1)
 334               CmfadefI = uiuc_3Dinterp_quick(Cmfadef_fArray,
 335                                              Cmfadef_aArray_nice,
 336                                              Cmfadef_deArray_nice,
 337                                              Cmfadef_CmArray,
 338                                              Cmfadef_na_nice,
 339                                              Cmfadef_nde_nice,
 340                                              Cmfadef_nf,
 341                                              flap_pos,
 342                                              Alpha,
 343                                              elevator);
 344             else
 345               CmfadefI = uiuc_3Dinterpolation(Cmfadef_fArray,
 346                                               Cmfadef_aArray,
 347                                               Cmfadef_deArray,
 348                                               Cmfadef_CmArray,
 349                                               Cmfadef_nAlphaArray,
 350                                               Cmfadef_nde,
 351                                               Cmfadef_nf,
 352                                               flap_pos,
 353                                               Alpha,
 354                                               elevator);
 355             Cm += CmfadefI;
 356             break;
 357           }
 358         case Cmfaqf_flag:
 359           {
 360             q_nondim = Q_body * cbar_2U;
 361             if (Cmfaqf_nice == 1)
 362               CmfaqfI = uiuc_3Dinterp_quick(Cmfaqf_fArray,
 363                                             Cmfaqf_aArray_nice,
 364                                             Cmfaqf_qArray_nice,
 365                                             Cmfaqf_CmArray,
 366                                             Cmfaqf_na_nice,
 367                                             Cmfaqf_nq_nice,
 368                                             Cmfaqf_nf,
 369                                             flap_pos,
 370                                             Alpha,
 371                                             q_nondim);
 372             else
 373               CmfaqfI = uiuc_3Dinterpolation(Cmfaqf_fArray,
 374                                              Cmfaqf_aArray,
 375                                              Cmfaqf_qArray,
 376                                              Cmfaqf_CmArray,
 377                                              Cmfaqf_nAlphaArray,
 378                                              Cmfaqf_nq,
 379                                              Cmfaqf_nf,
 380                                              flap_pos,
 381                                              Alpha,
 382                                              q_nondim);
 383             Cm += CmfaqfI;
 384             break;
 385           }
 386         };
 387     } // end Cm map
 388
 389   return;
 390 }
 391
 392 // end uiuc_coef_pitch.cpp