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