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