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             break;
 149           }
 150         case Cm_q_flag:
 151           {
 152             if (ice_on)
 153               {
 154                 Cm_q = uiuc_ice_filter(Cm_q_clean,kCm_q);
 155               }
 156             /* Cm_q must be mulitplied by cbar/2U
 157                (see Roskam Control book, Part 1, pg. 147) */
 158             Cm_q_save = Cm_q * Q_body * cbar_2U;
 159             Cm += Cm_q * Q_body * cbar_2U;
 160             break;
 161           }
 162         case Cm_ih_flag:
 163           {
 164             Cm_ih_save = Cm_ih * ih;
 165             Cm += Cm_ih * ih;
 166             break;
 167           }
 168         case Cm_de_flag:
 169           {
 170             if (ice_on)
 171               {
 172                 Cm_de = uiuc_ice_filter(Cm_de_clean,kCm_de);
 173               }
 174             Cm_de_save = Cm_de * elevator;
 175             Cm += Cm_de * elevator;
 176             break;
 177           }
 178         case Cm_b2_flag:
 179           {
 180             if (ice_on)
 181               {
 182                 Cm_b2 = uiuc_ice_filter(Cm_b2_clean,kCm_b2);
 183               }
 184             Cm_b2_save = Cm_b2 * Beta * Beta;
 185             Cm += Cm_b2 * Beta * Beta;
 186             break;
 187           }
 188         case Cm_r_flag:
 189           {
 190             if (ice_on)
 191               {
 192                 Cm_r = uiuc_ice_filter(Cm_r_clean,kCm_r);
 193               }
 194             Cm_r_save = Cm_r * R_body * b_2U;
 195             Cm += Cm_r * R_body * b_2U;
 196             break;
 197           }
 198         case Cm_df_flag:
 199           {
 200             if (ice_on)
 201               {
 202                 Cm_df = uiuc_ice_filter(Cm_df_clean,kCm_df);
 203               }
 204             Cm_df_save = Cm_df * flap;
 205             Cm += Cm_df * flap;
 206             break;
 207           }
 208         case Cmfa_flag:
 209           {
 210             CmfaI = uiuc_1Dinterpolation(Cmfa_aArray,
 211                                          Cmfa_CmArray,
 212                                          Cmfa_nAlpha,
 213                                          Alpha);
 214             Cm += CmfaI;
 215             break;
 216           }
 217         case Cmfade_flag:
 218           {
 219             CmfadeI = uiuc_2Dinterpolation(Cmfade_aArray,
 220                                            Cmfade_deArray,
 221                                            Cmfade_CmArray,
 222                                            Cmfade_nAlphaArray,
 223                                            Cmfade_nde,
 224                                            Alpha,
 225                                            elevator);
 226             Cm += CmfadeI;
 227             break;
 228           }
 229         case Cmfdf_flag:
 230           {
 231             CmfdfI = uiuc_1Dinterpolation(Cmfdf_dfArray,
 232                                           Cmfdf_CmArray,
 233                                           Cmfdf_ndf,
 234                                           flap);
 235             Cm += CmfdfI;
 236             break;
 237           }
 238         case Cmfadf_flag:
 239           {
 240             CmfadfI = uiuc_2Dinterpolation(Cmfadf_aArray,
 241                                            Cmfadf_dfArray,
 242                                            Cmfadf_CmArray,
 243                                            Cmfadf_nAlphaArray,
 244                                            Cmfadf_ndf,
 245                                            Alpha,
 246                                            flap);
 247             Cm += CmfadfI;
 248             break;
 249           }
 250         case Cmfabetaf_flag:
 251           {
 252             if (Cmfabetaf_nice == 1)
 253               CmfabetafI = uiuc_3Dinterp_quick(Cmfabetaf_fArray,
 254                                                Cmfabetaf_aArray_nice,
 255                                                Cmfabetaf_bArray_nice,
 256                                                Cmfabetaf_CmArray,
 257                                                Cmfabetaf_na_nice,
 258                                                Cmfabetaf_nb_nice,
 259                                                Cmfabetaf_nf,
 260                                                flap_pos,
 261                                                Alpha,
 262                                                Beta);
 263             else
 264               CmfabetafI = uiuc_3Dinterpolation(Cmfabetaf_fArray,
 265                                                 Cmfabetaf_aArray,
 266                                                 Cmfabetaf_betaArray,
 267                                                 Cmfabetaf_CmArray,
 268                                                 Cmfabetaf_nAlphaArray,
 269                                                 Cmfabetaf_nbeta,
 270                                                 Cmfabetaf_nf,
 271                                                 flap_pos,
 272                                                 Alpha,
 273                                                 Beta);
 274             Cm += CmfabetafI;
 275             break;
 276           }
 277         case Cmfadef_flag:
 278           {
 279             if (Cmfadef_nice == 1)
 280               CmfadefI = uiuc_3Dinterp_quick(Cmfadef_fArray,
 281                                              Cmfadef_aArray_nice,
 282                                              Cmfadef_deArray_nice,
 283                                              Cmfadef_CmArray,
 284                                              Cmfadef_na_nice,
 285                                              Cmfadef_nde_nice,
 286                                              Cmfadef_nf,
 287                                              flap_pos,
 288                                              Alpha,
 289                                              elevator);
 290             else
 291               CmfadefI = uiuc_3Dinterpolation(Cmfadef_fArray,
 292                                               Cmfadef_aArray,
 293                                               Cmfadef_deArray,
 294                                               Cmfadef_CmArray,
 295                                               Cmfadef_nAlphaArray,
 296                                               Cmfadef_nde,
 297                                               Cmfadef_nf,
 298                                               flap_pos,
 299                                               Alpha,
 300                                               elevator);
 301             Cm += CmfadefI;
 302             break;
 303           }
 304         case Cmfaqf_flag:
 305           {
 306             q_nondim = Q_body * cbar_2U;
 307             if (Cmfaqf_nice == 1)
 308               CmfaqfI = uiuc_3Dinterp_quick(Cmfaqf_fArray,
 309                                             Cmfaqf_aArray_nice,
 310                                             Cmfaqf_qArray_nice,
 311                                             Cmfaqf_CmArray,
 312                                             Cmfaqf_na_nice,
 313                                             Cmfaqf_nq_nice,
 314                                             Cmfaqf_nf,
 315                                             flap_pos,
 316                                             Alpha,
 317                                             q_nondim);
 318             else
 319               CmfaqfI = uiuc_3Dinterpolation(Cmfaqf_fArray,
 320                                              Cmfaqf_aArray,
 321                                              Cmfaqf_qArray,
 322                                              Cmfaqf_CmArray,
 323                                              Cmfaqf_nAlphaArray,
 324                                              Cmfaqf_nq,
 325                                              Cmfaqf_nf,
 326                                              flap_pos,
 327                                              Alpha,
 328                                              q_nondim);
 329             Cm += CmfaqfI;
 330             break;
 331           }
 332         };
 333     } // end Cm map
 334
 335   return;
 336 }
 337
 338 // end uiuc_coef_pitch.cpp