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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  85  USA or view http://www.gnu.org/copyleft/gpl.html.
  86
  87 **********************************************************************/
  88
  89 #include "uiuc_coef_roll.h"
  90
  91
  92 void uiuc_coef_roll()
  93 {
  94   string linetoken1;
  95   string linetoken2;
  96   stack command_list;
  97
  98   double p_nondim;
  99   double r_nondim;
 100
 101   command_list = aeroRollParts -> getCommands();
 102
 103   for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
 104     {
 105       linetoken1 = aeroRollParts -> getToken(*command_line, 1);
 106       linetoken2 = aeroRollParts -> getToken(*command_line, 2);
 107
 108       switch(Cl_map[linetoken2])
 109         {
 110         case Clo_flag:
 111           {
 112             if (ice_on)
 113               {
 114                 Clo = uiuc_ice_filter(Clo_clean,kClo);
 115               }
 116             Clo_save = Clo;
 117             Cl += Clo;
 118             break;
 119           }
 120         case Cl_beta_flag:
 121           {
 122             if (ice_on)
 123               {
 124                 Cl_beta = uiuc_ice_filter(Cl_beta_clean,kCl_beta);
 125               }
 126             Cl_beta_save = Cl_beta * Beta;
 127             //       Cl += Cl_beta * Beta;
 128             if (eta_q_Cl_beta_fac)
 129               {
 130                 Cl += Cl_beta_save * eta_q_Cl_beta_fac;
 131               }
 132             else
 133               {
 134                 Cl += Cl_beta_save;
 135               }
 136             break;
 137           }
 138         case Cl_p_flag:
 139           {
 140             if (ice_on)
 141               {
 142                 Cl_p = uiuc_ice_filter(Cl_p_clean,kCl_p);
 143               }
 144             /* Cl_p must be mulitplied by b/2U
 145                (see Roskam Control book, Part 1, pg. 147) */
 146             Cl_p_save = Cl_p * P_body * b_2U;
 147             //    Cl += Cl_p * P_body * b_2U;
 148             if (eta_q_Cl_p_fac)
 149               {
 150                 Cl += Cl_p_save * eta_q_Cl_p_fac;
 151               }
 152             else
 153               {
 154                 Cl += Cl_p_save;
 155               }
 156             break;
 157           }
 158         case Cl_r_flag:
 159           {
 160             if (ice_on)
 161               {
 162                 Cl_r = uiuc_ice_filter(Cl_r_clean,kCl_r);
 163               }
 164             /* Cl_r must be mulitplied by b/2U
 165                (see Roskam Control book, Part 1, pg. 147) */
 166             Cl_r_save = Cl_r * R_body * b_2U;
 167             //    Cl += Cl_r * R_body * b_2U;
 168             if (eta_q_Cl_r_fac)
 169               {
 170                 Cl += Cl_r_save * eta_q_Cl_r_fac;
 171               }
 172             else
 173               {
 174                 Cl += Cl_r_save;
 175               }
 176             break;
 177           }
 178         case Cl_da_flag:
 179           {
 180             if (ice_on)
 181               {
 182                 Cl_da = uiuc_ice_filter(Cl_da_clean,kCl_da);
 183               }
 184             Cl_da_save = Cl_da * aileron;
 185             Cl += Cl_da * aileron;
 186             break;
 187           }
 188         case Cl_dr_flag:
 189           {
 190             if (ice_on)
 191               {
 192                 Cl_dr = uiuc_ice_filter(Cl_dr_clean,kCl_dr);
 193               }
 194             Cl_dr_save = Cl_dr * rudder;
 195             //     Cl += Cl_dr * rudder;
 196             if (eta_q_Cl_dr_fac)
 197               {
 198                 Cl += Cl_dr_save * eta_q_Cl_dr_fac;
 199               }
 200             else
 201               {
 202                 Cl += Cl_dr_save;
 203               }
 204             break;
 205           }
 206         case Cl_daa_flag:
 207           {
 208             if (ice_on)
 209               {
 210                 Cl_daa = uiuc_ice_filter(Cl_daa_clean,kCl_daa);
 211               }
 212             Cl_daa_save = Cl_daa * aileron * Alpha;
 213             Cl += Cl_daa * aileron * Alpha;
 214             break;
 215           }
 216         case Clfada_flag:
 217           {
 218             ClfadaI = uiuc_2Dinterpolation(Clfada_aArray,
 219                                            Clfada_daArray,
 220                                            Clfada_ClArray,
 221                                            Clfada_nAlphaArray,
 222                                            Clfada_nda,
 223                                            Alpha,
 224                                            aileron);
 225             Cl += ClfadaI;
 226             break;
 227           }
 228         case Clfbetadr_flag:
 229           {
 230             ClfbetadrI = uiuc_2Dinterpolation(Clfbetadr_betaArray,
 231                                               Clfbetadr_drArray,
 232                                               Clfbetadr_ClArray,
 233                                               Clfbetadr_nBetaArray,
 234                                               Clfbetadr_ndr,
 235                                               Beta,
 236                                               rudder);
 237             Cl += ClfbetadrI;
 238             break;
 239           }
 240         case Clfabetaf_flag:
 241           {
 242             if (Clfabetaf_nice == 1)
 243               ClfabetafI = uiuc_3Dinterp_quick(Clfabetaf_fArray,
 244                                                Clfabetaf_aArray_nice,
 245                                                Clfabetaf_bArray_nice,
 246                                                Clfabetaf_ClArray,
 247                                                Clfabetaf_na_nice,
 248                                                Clfabetaf_nb_nice,
 249                                                Clfabetaf_nf,
 250                                                flap_pos,
 251                                                Alpha,
 252                                                Beta);
 253             else
 254               ClfabetafI = uiuc_3Dinterpolation(Clfabetaf_fArray,
 255                                                 Clfabetaf_aArray,
 256                                                 Clfabetaf_betaArray,
 257                                                 Clfabetaf_ClArray,
 258                                                 Clfabetaf_nAlphaArray,
 259                                                 Clfabetaf_nbeta,
 260                                                 Clfabetaf_nf,
 261                                                 flap_pos,
 262                                                 Alpha,
 263                                                 Beta);
 264             Cl += ClfabetafI;
 265             break;
 266           }
 267         case Clfadaf_flag:
 268           {
 269             if (Clfadaf_nice == 1)
 270               ClfadafI = uiuc_3Dinterp_quick(Clfadaf_fArray,
 271                                              Clfadaf_aArray_nice,
 272                                              Clfadaf_daArray_nice,
 273                                              Clfadaf_ClArray,
 274                                              Clfadaf_na_nice,
 275                                              Clfadaf_nda_nice,
 276                                              Clfadaf_nf,
 277                                              flap_pos,
 278                                              Alpha,
 279                                              aileron);
 280             else
 281               ClfadafI = uiuc_3Dinterpolation(Clfadaf_fArray,
 282                                               Clfadaf_aArray,
 283                                               Clfadaf_daArray,
 284                                               Clfadaf_ClArray,
 285                                               Clfadaf_nAlphaArray,
 286                                               Clfadaf_nda,
 287                                               Clfadaf_nf,
 288                                               flap_pos,
 289                                               Alpha,
 290                                               aileron);
 291             Cl += ClfadafI;
 292             break;
 293           }
 294         case Clfadrf_flag:
 295           {
 296             if (Clfadrf_nice == 1)
 297               ClfadrfI = uiuc_3Dinterp_quick(Clfadrf_fArray,
 298                                              Clfadrf_aArray_nice,
 299                                              Clfadrf_drArray_nice,
 300                                              Clfadrf_ClArray,
 301                                              Clfadrf_na_nice,
 302                                              Clfadrf_ndr_nice,
 303                                              Clfadrf_nf,
 304                                              flap_pos,
 305                                              Alpha,
 306                                              rudder);
 307             else
 308               ClfadrfI = uiuc_3Dinterpolation(Clfadrf_fArray,
 309                                               Clfadrf_aArray,
 310                                               Clfadrf_drArray,
 311                                               Clfadrf_ClArray,
 312                                               Clfadrf_nAlphaArray,
 313                                               Clfadrf_ndr,
 314                                               Clfadrf_nf,
 315                                               flap_pos,
 316                                               Alpha,
 317                                               rudder);
 318             Cl += ClfadrfI;
 319             break;
 320           }
 321         case Clfapf_flag:
 322           {
 323             p_nondim = P_body * b_2U;
 324             if (Clfapf_nice == 1)
 325               ClfapfI = uiuc_3Dinterp_quick(Clfapf_fArray,
 326                                             Clfapf_aArray_nice,
 327                                             Clfapf_pArray_nice,
 328                                             Clfapf_ClArray,
 329                                             Clfapf_na_nice,
 330                                             Clfapf_np_nice,
 331                                             Clfapf_nf,
 332                                             flap_pos,
 333                                             Alpha,
 334                                             p_nondim);
 335             else
 336               ClfapfI = uiuc_3Dinterpolation(Clfapf_fArray,
 337                                              Clfapf_aArray,
 338                                              Clfapf_pArray,
 339                                              Clfapf_ClArray,
 340                                              Clfapf_nAlphaArray,
 341                                              Clfapf_np,
 342                                              Clfapf_nf,
 343                                              flap_pos,
 344                                              Alpha,
 345                                              p_nondim);
 346             Cl += ClfapfI;
 347             break;
 348           }
 349         case Clfarf_flag:
 350           {
 351             r_nondim = R_body * b_2U;
 352             if (Clfarf_nice == 1)
 353               ClfarfI = uiuc_3Dinterp_quick(Clfarf_fArray,
 354                                             Clfarf_aArray_nice,
 355                                             Clfarf_rArray_nice,
 356                                             Clfarf_ClArray,
 357                                             Clfarf_na_nice,
 358                                             Clfarf_nr_nice,
 359                                             Clfarf_nf,
 360                                             flap_pos,
 361                                             Alpha,
 362                                             r_nondim);
 363             else
 364               ClfarfI = uiuc_3Dinterpolation(Clfarf_fArray,
 365                                              Clfarf_aArray,
 366                                              Clfarf_rArray,
 367                                              Clfarf_ClArray,
 368                                              Clfarf_nAlphaArray,
 369                                              Clfarf_nr,
 370                                              Clfarf_nf,
 371                                              flap_pos,
 372                                              Alpha,
 373                                              r_nondim);
 374             Cl += ClfarfI;
 375             break;
 376           }
 377         };
 378     } // end Cl map
 379
 380   return;
 381 }
 382
 383 // end uiuc_coef_roll.cpp