src/FDM/UIUCModel/uiuc_coef_roll.cpp

   1 /**********************************************************************
   2
   3  FILENAME:     uiuc_coef_roll.cpp
   4
   5 ----------------------------------------------------------------------
   6
   7  DESCRIPTION:  computes aggregated aerodynamic roll 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                             (Clfxxf0)
  25                11/12/2001   (RD) Added new variables needed for the non-
  26                             linear Twin Otter model with flaps
  27                             (Clfxxf).  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                -aileron
  48                -rudder
  49                -roll coefficient components
  50                -icing parameters
  51                -b_2U multiplier
  52
  53 ----------------------------------------------------------------------
  54
  55  OUTPUTS:      -Cl
  56
  57 ----------------------------------------------------------------------
  58
  59  CALLED BY:    uiuc_coefficients.cpp
  60
  61 ----------------------------------------------------------------------
  62
  63  CALLS TO:     uiuc_1Dinterpolation
  64                uiuc_2Dinterpolation
  65                uiuc_ice_filter
  66                uiuc_3Dinterpolation
  67                uiuc_3Dinterp_quick
  68
  69 ----------------------------------------------------------------------
  70
  71  COPYRIGHT:    (C) 2000 by Michael Selig
  72
  73  This program is free software; you can redistribute it and/or
  74  modify it under the terms of the GNU General Public License
  75  as published by the Free Software Foundation.
  76
  77  This program is distributed in the hope that it will be useful,
  78  but WITHOUT ANY WARRANTY; without even the implied warranty of
  79  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  80  GNU General Public License for more details.
  81
  82  You should have received a copy of the GNU General Public License
  83  along with this program; if not, write to the Free Software
  84  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  85
  86 **********************************************************************/
  87
  88 #include "uiuc_coef_roll.h"
  89
  90
  91 void uiuc_coef_roll()
  92 {
  93   string linetoken1;
  94   string linetoken2;
  95   stack command_list;
  96
  97   double p_nondim;
  98   double r_nondim;
  99
 100   command_list = aeroRollParts -> getCommands();
 101
 102   for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
 103     {
 104       linetoken1 = aeroRollParts -> getToken(*command_line, 1);
 105       linetoken2 = aeroRollParts -> getToken(*command_line, 2);
 106
 107       switch(Cl_map[linetoken2])
 108         {
 109         case Clo_flag:
 110           {
 111             if (ice_on)
 112               {
 113                 Clo = uiuc_ice_filter(Clo_clean,kClo);
 114               }
 115             Clo_save = Clo;
 116             Cl += Clo_save;
 117             break;
 118           }
 119         case Cl_beta_flag:
 120           {
 121             if (ice_on)
 122               {
 123                 Cl_beta = uiuc_ice_filter(Cl_beta_clean,kCl_beta);
 124               }
 125             Cl_beta_save = Cl_beta * Std_Beta;
 126             if (eta_q_Cl_beta_fac)
 127               {
 128                 Cl += Cl_beta_save * eta_q_Cl_beta_fac;
 129               }
 130             else
 131               {
 132                 Cl += Cl_beta_save;
 133               }
 134             break;
 135           }
 136         case Cl_p_flag:
 137           {
 138             if (ice_on)
 139               {
 140                 Cl_p = uiuc_ice_filter(Cl_p_clean,kCl_p);
 141               }
 142             /* Cl_p must be mulitplied by b/2U
 143                (see Roskam Control book, Part 1, pg. 147) */
 144             Cl_p_save = Cl_p * P_body * b_2U;
 145 //          if (Cl_p_save > 0.1) {
 146 //            Cl_p_save = 0.1;
 147 //          }
 148 //          if (Cl_p_save < -0.1) {
 149 //            Cl_p_save = -0.1;
 150 //          }
 151             if (eta_q_Cl_p_fac)
 152               {
 153                 Cl += Cl_p_save * eta_q_Cl_p_fac;
 154               }
 155             else
 156               {
 157                 Cl += Cl_p_save;
 158               }
 159             break;
 160           }
 161         case Cl_r_flag:
 162           {
 163             if (ice_on)
 164               {
 165                 Cl_r = uiuc_ice_filter(Cl_r_clean,kCl_r);
 166               }
 167             /* Cl_r must be mulitplied by b/2U
 168                (see Roskam Control book, Part 1, pg. 147) */
 169             Cl_r_save = Cl_r * R_body * b_2U;
 170             if (eta_q_Cl_r_fac)
 171               {
 172                 Cl += Cl_r_save * eta_q_Cl_r_fac;
 173               }
 174             else
 175               {
 176                 Cl += Cl_r_save;
 177               }
 178             break;
 179           }
 180         case Cl_da_flag:
 181           {
 182             if (ice_on)
 183               {
 184                 Cl_da = uiuc_ice_filter(Cl_da_clean,kCl_da);
 185               }
 186             Cl_da_save = Cl_da * aileron;
 187             Cl += Cl_da_save;
 188             break;
 189           }
 190         case Cl_dr_flag:
 191           {
 192             if (ice_on)
 193               {
 194                 Cl_dr = uiuc_ice_filter(Cl_dr_clean,kCl_dr);
 195               }
 196             Cl_dr_save = Cl_dr * rudder;
 197             if (eta_q_Cl_dr_fac)
 198               {
 199                 Cl += Cl_dr_save * eta_q_Cl_dr_fac;
 200               }
 201             else
 202               {
 203                 Cl += Cl_dr_save;
 204               }
 205             break;
 206           }
 207         case Cl_daa_flag:
 208           {
 209             if (ice_on)
 210               {
 211                 Cl_daa = uiuc_ice_filter(Cl_daa_clean,kCl_daa);
 212               }
 213             Cl_daa_save = Cl_daa * aileron * Std_Alpha;
 214             Cl += Cl_daa_save;
 215             break;
 216           }
 217         case Clfada_flag:
 218           {
 219             ClfadaI = uiuc_2Dinterpolation(Clfada_aArray,
 220                                            Clfada_daArray,
 221                                            Clfada_ClArray,
 222                                            Clfada_nAlphaArray,
 223                                            Clfada_nda,
 224                                            Std_Alpha,
 225                                            aileron);
 226             Cl += ClfadaI;
 227             break;
 228           }
 229         case Clfbetadr_flag:
 230           {
 231             ClfbetadrI = uiuc_2Dinterpolation(Clfbetadr_betaArray,
 232                                               Clfbetadr_drArray,
 233                                               Clfbetadr_ClArray,
 234                                               Clfbetadr_nBetaArray,
 235                                               Clfbetadr_ndr,
 236                                               Std_Beta,
 237                                               rudder);
 238             Cl += ClfbetadrI;
 239             break;
 240           }
 241         case Clfabetaf_flag:
 242           {
 243             if (Clfabetaf_nice == 1)
 244               ClfabetafI = uiuc_3Dinterp_quick(Clfabetaf_fArray,
 245                                                Clfabetaf_aArray_nice,
 246                                                Clfabetaf_bArray_nice,
 247                                                Clfabetaf_ClArray,
 248                                                Clfabetaf_na_nice,
 249                                                Clfabetaf_nb_nice,
 250                                                Clfabetaf_nf,
 251                                                flap_pos,
 252                                                Std_Alpha,
 253                                                Std_Beta);
 254             else
 255               ClfabetafI = uiuc_3Dinterpolation(Clfabetaf_fArray,
 256                                                 Clfabetaf_aArray,
 257                                                 Clfabetaf_betaArray,
 258                                                 Clfabetaf_ClArray,
 259                                                 Clfabetaf_nAlphaArray,
 260                                                 Clfabetaf_nbeta,
 261                                                 Clfabetaf_nf,
 262                                                 flap_pos,
 263                                                 Std_Alpha,
 264                                                 Std_Beta);
 265             Cl += ClfabetafI;
 266             break;
 267           }
 268         case Clfadaf_flag:
 269           {
 270             if (Clfadaf_nice == 1)
 271               ClfadafI = uiuc_3Dinterp_quick(Clfadaf_fArray,
 272                                              Clfadaf_aArray_nice,
 273                                              Clfadaf_daArray_nice,
 274                                              Clfadaf_ClArray,
 275                                              Clfadaf_na_nice,
 276                                              Clfadaf_nda_nice,
 277                                              Clfadaf_nf,
 278                                              flap_pos,
 279                                              Std_Alpha,
 280                                              aileron);
 281             else
 282               ClfadafI = uiuc_3Dinterpolation(Clfadaf_fArray,
 283                                               Clfadaf_aArray,
 284                                               Clfadaf_daArray,
 285                                               Clfadaf_ClArray,
 286                                               Clfadaf_nAlphaArray,
 287                                               Clfadaf_nda,
 288                                               Clfadaf_nf,
 289                                               flap_pos,
 290                                               Std_Alpha,
 291                                               aileron);
 292             Cl += ClfadafI;
 293             break;
 294           }
 295         case Clfadrf_flag:
 296           {
 297             if (Clfadrf_nice == 1)
 298               ClfadrfI = uiuc_3Dinterp_quick(Clfadrf_fArray,
 299                                              Clfadrf_aArray_nice,
 300                                              Clfadrf_drArray_nice,
 301                                              Clfadrf_ClArray,
 302                                              Clfadrf_na_nice,
 303                                              Clfadrf_ndr_nice,
 304                                              Clfadrf_nf,
 305                                              flap_pos,
 306                                              Std_Alpha,
 307                                              rudder);
 308             else
 309               ClfadrfI = uiuc_3Dinterpolation(Clfadrf_fArray,
 310                                               Clfadrf_aArray,
 311                                               Clfadrf_drArray,
 312                                               Clfadrf_ClArray,
 313                                               Clfadrf_nAlphaArray,
 314                                               Clfadrf_ndr,
 315                                               Clfadrf_nf,
 316                                               flap_pos,
 317                                               Std_Alpha,
 318                                               rudder);
 319             Cl += ClfadrfI;
 320             break;
 321           }
 322         case Clfapf_flag:
 323           {
 324             p_nondim = P_body * b_2U;
 325             if (Clfapf_nice == 1)
 326               ClfapfI = uiuc_3Dinterp_quick(Clfapf_fArray,
 327                                             Clfapf_aArray_nice,
 328                                             Clfapf_pArray_nice,
 329                                             Clfapf_ClArray,
 330                                             Clfapf_na_nice,
 331                                             Clfapf_np_nice,
 332                                             Clfapf_nf,
 333                                             flap_pos,
 334                                             Std_Alpha,
 335                                             p_nondim);
 336             else
 337               ClfapfI = uiuc_3Dinterpolation(Clfapf_fArray,
 338                                              Clfapf_aArray,
 339                                              Clfapf_pArray,
 340                                              Clfapf_ClArray,
 341                                              Clfapf_nAlphaArray,
 342                                              Clfapf_np,
 343                                              Clfapf_nf,
 344                                              flap_pos,
 345                                              Std_Alpha,
 346                                              p_nondim);
 347             Cl += ClfapfI;
 348             break;
 349           }
 350         case Clfarf_flag:
 351           {
 352             r_nondim = R_body * b_2U;
 353             if (Clfarf_nice == 1)
 354               ClfarfI = uiuc_3Dinterp_quick(Clfarf_fArray,
 355                                             Clfarf_aArray_nice,
 356                                             Clfarf_rArray_nice,
 357                                             Clfarf_ClArray,
 358                                             Clfarf_na_nice,
 359                                             Clfarf_nr_nice,
 360                                             Clfarf_nf,
 361                                             flap_pos,
 362                                             Std_Alpha,
 363                                             r_nondim);
 364             else
 365               ClfarfI = uiuc_3Dinterpolation(Clfarf_fArray,
 366                                              Clfarf_aArray,
 367                                              Clfarf_rArray,
 368                                              Clfarf_ClArray,
 369                                              Clfarf_nAlphaArray,
 370                                              Clfarf_nr,
 371                                              Clfarf_nf,
 372                                              flap_pos,
 373                                              Std_Alpha,
 374                                              r_nondim);
 375             Cl += ClfarfI;
 376             break;
 377           }
 378         };
 379     } // end Cl map
 380
 381   return;
 382 }
 383
 384 // end uiuc_coef_roll.cpp