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