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_save;
 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 * Std_Alpha;
 125             Cm += Cm_a_save;
 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 * Std_Alpha * Std_Alpha;
 135             Cm += Cm_a2_save;
 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 * Std_Alpha_dot * cbar_2U;
 147             if (eta_q_Cm_adot_fac)
 148               {
 149                 Cm += Cm_adot_save * eta_q_Cm_adot_fac;
 150               }
 151             else
 152               {
 153                 Cm += Cm_adot_save;
 154               }
 155             break;
 156           }
 157         case Cm_q_flag:
 158           {
 159             if (ice_on)
 160               {
 161                 Cm_q = uiuc_ice_filter(Cm_q_clean,kCm_q);
 162               }
 163             /* Cm_q must be mulitplied by cbar/2U
 164                (see Roskam Control book, Part 1, pg. 147) */
 165             Cm_q_save = Cm_q * Q_body * cbar_2U;
 166             if (eta_q_Cm_q_fac)
 167               {
 168                 Cm += Cm_q_save * eta_q_Cm_q_fac;
 169               }
 170             else
 171               {
 172                 Cm += Cm_q_save;
 173               }
 174             break;
 175           }
 176         case Cm_ih_flag:
 177           {
 178             Cm_ih_save = Cm_ih * ih;
 179             Cm += Cm_ih_save;
 180             break;
 181           }
 182         case Cm_de_flag:
 183           {
 184             if (ice_on)
 185               {
 186                 Cm_de = uiuc_ice_filter(Cm_de_clean,kCm_de);
 187               }
 188             Cm_de_save = Cm_de * elevator;
 189             if (eta_q_Cm_de_fac)
 190               {
 191                 Cm += Cm_de_save * eta_q_Cm_de_fac;
 192               }
 193             else
 194               {
 195                 Cm += Cm_de_save;
 196               }
 197             break;
 198           }
 199         case Cm_b2_flag:
 200           {
 201             if (ice_on)
 202               {
 203                 Cm_b2 = uiuc_ice_filter(Cm_b2_clean,kCm_b2);
 204               }
 205             Cm_b2_save = Cm_b2 * Std_Beta * Std_Beta;
 206             Cm += Cm_b2_save;
 207             break;
 208           }
 209         case Cm_r_flag:
 210           {
 211             if (ice_on)
 212               {
 213                 Cm_r = uiuc_ice_filter(Cm_r_clean,kCm_r);
 214               }
 215             Cm_r_save = Cm_r * R_body * b_2U;
 216             Cm += Cm_r_save;
 217             break;
 218           }
 219         case Cm_df_flag:
 220           {
 221             if (ice_on)
 222               {
 223                 Cm_df = uiuc_ice_filter(Cm_df_clean,kCm_df);
 224               }
 225             Cm_df_save = Cm_df * flap_pos;
 226             Cm += Cm_df_save;
 227             break;
 228           }
 229         case Cm_ds_flag:
 230           {
 231             Cm_ds_save = Cm_ds * spoiler_pos;
 232             Cm += Cm_ds_save;
 233             break;
 234           }
 235         case Cm_dg_flag:
 236           {
 237             Cm_dg_save = Cm_dg * gear_pos_norm;
 238             Cm += Cm_dg_save;
 239             break;
 240           }
 241         case Cmfa_flag:
 242           {
 243             CmfaI = uiuc_1Dinterpolation(Cmfa_aArray,
 244                                          Cmfa_CmArray,
 245                                          Cmfa_nAlpha,
 246                                          Std_Alpha);
 247             Cm += CmfaI;
 248             break;
 249           }
 250         case Cmfade_flag:
 251           {
 252             if(b_downwashMode)
 253               {
 254                 // compute the induced velocity on the tail to account for tail downwash
 255                 switch(downwashMode)
 256                   {
 257                   case 100:
 258                     if (V_rel_wind < dyn_on_speed)
 259                       {
 260                         alphaTail = Std_Alpha;
 261                       }
 262                     else
 263                       {
 264                         gammaWing = V_rel_wind * Sw * CL / (2.0 * bw);
 265                         // printf("gammaWing = %.4f\n", (gammaWing));
 266                         downwash  = downwashCoef * gammaWing;
 267                         downwashAngle = atan(downwash/V_rel_wind);
 268                         alphaTail = Std_Alpha - downwashAngle;
 269                       }
 270                     CmfadeI = uiuc_2Dinterpolation(Cmfade_aArray,
 271                                                    Cmfade_deArray,
 272                                                    Cmfade_CmArray,
 273                                                    Cmfade_nAlphaArray,
 274                                                    Cmfade_nde,
 275                                                    alphaTail,
 276                                                    elevator);
 277                     break;
 278                   }
 279               }
 280             else
 281               {
 282                 CmfadeI = uiuc_2Dinterpolation(Cmfade_aArray,
 283                                                Cmfade_deArray,
 284                                                Cmfade_CmArray,
 285                                                Cmfade_nAlphaArray,
 286                                                Cmfade_nde,
 287                                                Std_Alpha,
 288                                                elevator);
 289               }
 290             if (eta_q_Cmfade_fac)
 291               {
 292                 Cm += CmfadeI * eta_q_Cmfade_fac;
 293               }
 294             else
 295               {
 296                 Cm += CmfadeI;
 297               }
 298             break;
 299           }
 300         case Cmfdf_flag:
 301           {
 302             CmfdfI = uiuc_1Dinterpolation(Cmfdf_dfArray,
 303                                           Cmfdf_CmArray,
 304                                           Cmfdf_ndf,
 305                                           flap_pos);
 306             Cm += CmfdfI;
 307             break;
 308           }
 309         case Cmfadf_flag:
 310           {
 311             CmfadfI = uiuc_2Dinterpolation(Cmfadf_aArray,
 312                                            Cmfadf_dfArray,
 313                                            Cmfadf_CmArray,
 314                                            Cmfadf_nAlphaArray,
 315                                            Cmfadf_ndf,
 316                                            Std_Alpha,
 317                                            flap_pos);
 318             Cm += CmfadfI;
 319             break;
 320           }
 321         case Cmfabetaf_flag:
 322           {
 323             if (Cmfabetaf_nice == 1)
 324               CmfabetafI = uiuc_3Dinterp_quick(Cmfabetaf_fArray,
 325                                                Cmfabetaf_aArray_nice,
 326                                                Cmfabetaf_bArray_nice,
 327                                                Cmfabetaf_CmArray,
 328                                                Cmfabetaf_na_nice,
 329                                                Cmfabetaf_nb_nice,
 330                                                Cmfabetaf_nf,
 331                                                flap_pos,
 332                                                Std_Alpha,
 333                                                Std_Beta);
 334             else
 335               CmfabetafI = uiuc_3Dinterpolation(Cmfabetaf_fArray,
 336                                                 Cmfabetaf_aArray,
 337                                                 Cmfabetaf_betaArray,
 338                                                 Cmfabetaf_CmArray,
 339                                                 Cmfabetaf_nAlphaArray,
 340                                                 Cmfabetaf_nbeta,
 341                                                 Cmfabetaf_nf,
 342                                                 flap_pos,
 343                                                 Std_Alpha,
 344                                                 Std_Beta);
 345             Cm += CmfabetafI;
 346             break;
 347           }
 348         case Cmfadef_flag:
 349           {
 350             if (Cmfadef_nice == 1)
 351               CmfadefI = uiuc_3Dinterp_quick(Cmfadef_fArray,
 352                                              Cmfadef_aArray_nice,
 353                                              Cmfadef_deArray_nice,
 354                                              Cmfadef_CmArray,
 355                                              Cmfadef_na_nice,
 356                                              Cmfadef_nde_nice,
 357                                              Cmfadef_nf,
 358                                              flap_pos,
 359                                              Std_Alpha,
 360                                              elevator);
 361             else
 362               CmfadefI = uiuc_3Dinterpolation(Cmfadef_fArray,
 363                                               Cmfadef_aArray,
 364                                               Cmfadef_deArray,
 365                                               Cmfadef_CmArray,
 366                                               Cmfadef_nAlphaArray,
 367                                               Cmfadef_nde,
 368                                               Cmfadef_nf,
 369                                               flap_pos,
 370                                               Std_Alpha,
 371                                               elevator);
 372             Cm += CmfadefI;
 373             break;
 374           }
 375         case Cmfaqf_flag:
 376           {
 377             q_nondim = Q_body * cbar_2U;
 378             if (Cmfaqf_nice == 1)
 379               CmfaqfI = uiuc_3Dinterp_quick(Cmfaqf_fArray,
 380                                             Cmfaqf_aArray_nice,
 381                                             Cmfaqf_qArray_nice,
 382                                             Cmfaqf_CmArray,
 383                                             Cmfaqf_na_nice,
 384                                             Cmfaqf_nq_nice,
 385                                             Cmfaqf_nf,
 386                                             flap_pos,
 387                                             Std_Alpha,
 388                                             q_nondim);
 389             else
 390               CmfaqfI = uiuc_3Dinterpolation(Cmfaqf_fArray,
 391                                              Cmfaqf_aArray,
 392                                              Cmfaqf_qArray,
 393                                              Cmfaqf_CmArray,
 394                                              Cmfaqf_nAlphaArray,
 395                                              Cmfaqf_nq,
 396                                              Cmfaqf_nf,
 397                                              flap_pos,
 398                                              Std_Alpha,
 399                                              q_nondim);
 400             Cm += CmfaqfI;
 401             break;
 402           }
 403         };
 404     } // end Cm map
 405
 406   return;
 407 }
 408
 409 // end uiuc_coef_pitch.cpp