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             // compute the induced velocity on the tail to account for tail downwash
 236             gamma_wing = V_rel_wind * Sw * CL / (2.0 * bw);
 237             w_coef = 0.036;
 238             w_induced  = w_coef * gamma_wing;
 239             downwash_angle = atan(w_induced/V_rel_wind);
 240             AlphaTail = Alpha - downwash_angle;
 241             CmfadeI = uiuc_2Dinterpolation(Cmfade_aArray,
 242                                            Cmfade_deArray,
 243                                            Cmfade_CmArray,
 244                                            Cmfade_nAlphaArray,
 245                                            Cmfade_nde,
 246                                            AlphaTail,
 247                                            elevator);
 248             // Cm += CmfadeI;
 249             if (eta_q_Cmfade_fac)
 250               {
 251                 Cm += CmfadeI * eta_q_Cmfade_fac;
 252               }
 253             else
 254               {
 255                 Cm += CmfadeI;
 256               }
 257             break;
 258           }
 259         case Cmfdf_flag:
 260           {
 261             CmfdfI = uiuc_1Dinterpolation(Cmfdf_dfArray,
 262                                           Cmfdf_CmArray,
 263                                           Cmfdf_ndf,
 264                                           flap);
 265             Cm += CmfdfI;
 266             break;
 267           }
 268         case Cmfadf_flag:
 269           {
 270             CmfadfI = uiuc_2Dinterpolation(Cmfadf_aArray,
 271                                            Cmfadf_dfArray,
 272                                            Cmfadf_CmArray,
 273                                            Cmfadf_nAlphaArray,
 274                                            Cmfadf_ndf,
 275                                            Alpha,
 276                                            flap);
 277             Cm += CmfadfI;
 278             break;
 279           }
 280         case Cmfabetaf_flag:
 281           {
 282             if (Cmfabetaf_nice == 1)
 283               CmfabetafI = uiuc_3Dinterp_quick(Cmfabetaf_fArray,
 284                                                Cmfabetaf_aArray_nice,
 285                                                Cmfabetaf_bArray_nice,
 286                                                Cmfabetaf_CmArray,
 287                                                Cmfabetaf_na_nice,
 288                                                Cmfabetaf_nb_nice,
 289                                                Cmfabetaf_nf,
 290                                                flap_pos,
 291                                                Alpha,
 292                                                Beta);
 293             else
 294               CmfabetafI = uiuc_3Dinterpolation(Cmfabetaf_fArray,
 295                                                 Cmfabetaf_aArray,
 296                                                 Cmfabetaf_betaArray,
 297                                                 Cmfabetaf_CmArray,
 298                                                 Cmfabetaf_nAlphaArray,
 299                                                 Cmfabetaf_nbeta,
 300                                                 Cmfabetaf_nf,
 301                                                 flap_pos,
 302                                                 Alpha,
 303                                                 Beta);
 304             Cm += CmfabetafI;
 305             break;
 306           }
 307         case Cmfadef_flag:
 308           {
 309             if (Cmfadef_nice == 1)
 310               CmfadefI = uiuc_3Dinterp_quick(Cmfadef_fArray,
 311                                              Cmfadef_aArray_nice,
 312                                              Cmfadef_deArray_nice,
 313                                              Cmfadef_CmArray,
 314                                              Cmfadef_na_nice,
 315                                              Cmfadef_nde_nice,
 316                                              Cmfadef_nf,
 317                                              flap_pos,
 318                                              Alpha,
 319                                              elevator);
 320             else
 321               CmfadefI = uiuc_3Dinterpolation(Cmfadef_fArray,
 322                                               Cmfadef_aArray,
 323                                               Cmfadef_deArray,
 324                                               Cmfadef_CmArray,
 325                                               Cmfadef_nAlphaArray,
 326                                               Cmfadef_nde,
 327                                               Cmfadef_nf,
 328                                               flap_pos,
 329                                               Alpha,
 330                                               elevator);
 331             Cm += CmfadefI;
 332             break;
 333           }
 334         case Cmfaqf_flag:
 335           {
 336             q_nondim = Q_body * cbar_2U;
 337             if (Cmfaqf_nice == 1)
 338               CmfaqfI = uiuc_3Dinterp_quick(Cmfaqf_fArray,
 339                                             Cmfaqf_aArray_nice,
 340                                             Cmfaqf_qArray_nice,
 341                                             Cmfaqf_CmArray,
 342                                             Cmfaqf_na_nice,
 343                                             Cmfaqf_nq_nice,
 344                                             Cmfaqf_nf,
 345                                             flap_pos,
 346                                             Alpha,
 347                                             q_nondim);
 348             else
 349               CmfaqfI = uiuc_3Dinterpolation(Cmfaqf_fArray,
 350                                              Cmfaqf_aArray,
 351                                              Cmfaqf_qArray,
 352                                              Cmfaqf_CmArray,
 353                                              Cmfaqf_nAlphaArray,
 354                                              Cmfaqf_nq,
 355                                              Cmfaqf_nf,
 356                                              flap_pos,
 357                                              Alpha,
 358                                              q_nondim);
 359             Cm += CmfaqfI;
 360             break;
 361           }
 362         };
 363     } // end Cm map
 364
 365   return;
 366 }
 367
 368 // end uiuc_coef_pitch.cpp