src/FDM/UIUCModel/uiuc_coef_yaw.cpp

   1 /**********************************************************************
   2
   3  FILENAME:     uiuc_coef_yaw.cpp
   4
   5 ----------------------------------------------------------------------
   6
   7  DESCRIPTION:  computes aggregated aerodynamic yaw 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                             (Cnfxxf0)
  25                11/12/2001   (RD) Added new variables needed for the non-
  26                             linear Twin Otter model with flaps
  27                             (Cnfxxf).  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                -yaw coefficient components
  50                -icing parameters
  51                -b_2U multiplier
  52
  53 ----------------------------------------------------------------------
  54
  55  OUTPUTS:      -Cn
  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_yaw.h"
  89
  90
  91 void uiuc_coef_yaw()
  92 {
  93   string linetoken1;
  94   string linetoken2;
  95   stack command_list;
  96
  97   double p_nondim;
  98   double r_nondim;
  99
 100   command_list = aeroYawParts -> getCommands();
 101
 102   for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
 103     {
 104       linetoken1 = aeroYawParts -> getToken(*command_line, 1);
 105       linetoken2 = aeroYawParts -> getToken(*command_line, 2);
 106
 107       switch(Cn_map[linetoken2])
 108         {
 109         case Cno_flag:
 110           {
 111             if (ice_on)
 112               {
 113                 Cno = uiuc_ice_filter(Cno_clean,kCno);
 114               }
 115             Cno_save = Cno;
 116             Cn += Cno_save;
 117             break;
 118           }
 119         case Cn_beta_flag:
 120           {
 121             if (ice_on)
 122               {
 123                 Cn_beta = uiuc_ice_filter(Cn_beta_clean,kCn_beta);
 124               }
 125             Cn_beta_save = Cn_beta * Std_Beta;
 126             if (eta_q_Cn_beta_fac)
 127               {
 128                 Cn += Cn_beta_save * eta_q_Cn_beta_fac;
 129               }
 130             else
 131               {
 132                 Cn += Cn_beta_save;
 133               }
 134             break;
 135           }
 136         case Cn_p_flag:
 137           {
 138             if (ice_on)
 139               {
 140                 Cn_p = uiuc_ice_filter(Cn_p_clean,kCn_p);
 141               }
 142             /* Cn_p must be mulitplied by b/2U
 143                (see Roskam Control book, Part 1, pg. 147) */
 144             Cn_p_save = Cn_p * P_body * b_2U;
 145             if (eta_q_Cn_p_fac)
 146               {
 147                 Cn += Cn_p_save * eta_q_Cn_p_fac;
 148               }
 149             else
 150               {
 151                 Cn += Cn_p_save;
 152               }
 153             break;
 154           }
 155         case Cn_r_flag:
 156           {
 157             if (ice_on)
 158               {
 159                 Cn_r = uiuc_ice_filter(Cn_r_clean,kCn_r);
 160               }
 161             /* Cn_r must be mulitplied by b/2U
 162                (see Roskam Control book, Part 1, pg. 147) */
 163             Cn_r_save = Cn_r * R_body * b_2U;
 164             if (eta_q_Cn_r_fac)
 165               {
 166                 Cn += Cn_r_save * eta_q_Cn_r_fac;
 167               }
 168             else
 169               {
 170                 Cn += Cn_r_save;
 171               }
 172             break;
 173           }
 174         case Cn_da_flag:
 175           {
 176             if (ice_on)
 177               {
 178                 Cn_da = uiuc_ice_filter(Cn_da_clean,kCn_da);
 179               }
 180             Cn_da_save = Cn_da * aileron;
 181             Cn += Cn_da_save;
 182             break;
 183           }
 184         case Cn_dr_flag:
 185           {
 186             if (ice_on)
 187               {
 188                 Cn_dr = uiuc_ice_filter(Cn_dr_clean,kCn_dr);
 189               }
 190             Cn_dr_save = Cn_dr * rudder;
 191             if (eta_q_Cn_dr_fac)
 192               {
 193                 Cn += Cn_dr_save * eta_q_Cn_dr_fac;
 194               }
 195             else
 196               {
 197                 Cn += Cn_dr_save;
 198               }
 199             break;
 200           }
 201         case Cn_q_flag:
 202           {
 203             if (ice_on)
 204               {
 205                 Cn_q = uiuc_ice_filter(Cn_q_clean,kCn_q);
 206               }
 207             Cn_q_save = Cn_q * Q_body * cbar_2U;
 208             Cn += Cn_q_save;
 209             break;
 210           }
 211         case Cn_b3_flag:
 212           {
 213             if (ice_on)
 214               {
 215                 Cn_b3 = uiuc_ice_filter(Cn_b3_clean,kCn_b3);
 216               }
 217             Cn_b3_save = Cn_b3 * Std_Beta * Std_Beta * Std_Beta;
 218             Cn += Cn_b3_save;
 219             break;
 220           }
 221         case Cnfada_flag:
 222           {
 223             CnfadaI = uiuc_2Dinterpolation(Cnfada_aArray,
 224                                            Cnfada_daArray,
 225                                            Cnfada_CnArray,
 226                                            Cnfada_nAlphaArray,
 227                                            Cnfada_nda,
 228                                            Std_Alpha,
 229                                            aileron);
 230             Cn += CnfadaI;
 231             break;
 232           }
 233         case Cnfbetadr_flag:
 234           {
 235             CnfbetadrI = uiuc_2Dinterpolation(Cnfbetadr_betaArray,
 236                                               Cnfbetadr_drArray,
 237                                               Cnfbetadr_CnArray,
 238                                               Cnfbetadr_nBetaArray,
 239                                               Cnfbetadr_ndr,
 240                                               Std_Beta,
 241                                               rudder);
 242             Cn += CnfbetadrI;
 243             break;
 244           }
 245         case Cnfabetaf_flag:
 246           {
 247             if (Cnfabetaf_nice == 1)
 248               CnfabetafI = uiuc_3Dinterp_quick(Cnfabetaf_fArray,
 249                                                Cnfabetaf_aArray_nice,
 250                                                Cnfabetaf_bArray_nice,
 251                                                Cnfabetaf_CnArray,
 252                                                Cnfabetaf_na_nice,
 253                                                Cnfabetaf_nb_nice,
 254                                                Cnfabetaf_nf,
 255                                                flap_pos,
 256                                                Std_Alpha,
 257                                                Std_Beta);
 258             else
 259               CnfabetafI = uiuc_3Dinterpolation(Cnfabetaf_fArray,
 260                                                 Cnfabetaf_aArray,
 261                                                 Cnfabetaf_betaArray,
 262                                                 Cnfabetaf_CnArray,
 263                                                 Cnfabetaf_nAlphaArray,
 264                                                 Cnfabetaf_nbeta,
 265                                                 Cnfabetaf_nf,
 266                                                 flap_pos,
 267                                                 Std_Alpha,
 268                                                 Std_Beta);
 269             Cn += CnfabetafI;
 270             break;
 271           }
 272         case Cnfadaf_flag:
 273           {
 274             if (Cnfadaf_nice == 1)
 275               CnfadafI = uiuc_3Dinterp_quick(Cnfadaf_fArray,
 276                                              Cnfadaf_aArray_nice,
 277                                              Cnfadaf_daArray_nice,
 278                                              Cnfadaf_CnArray,
 279                                              Cnfadaf_na_nice,
 280                                              Cnfadaf_nda_nice,
 281                                              Cnfadaf_nf,
 282                                              flap_pos,
 283                                              Std_Alpha,
 284                                              aileron);
 285             else
 286               CnfadafI = uiuc_3Dinterpolation(Cnfadaf_fArray,
 287                                               Cnfadaf_aArray,
 288                                               Cnfadaf_daArray,
 289                                               Cnfadaf_CnArray,
 290                                               Cnfadaf_nAlphaArray,
 291                                               Cnfadaf_nda,
 292                                               Cnfadaf_nf,
 293                                               flap_pos,
 294                                               Std_Alpha,
 295                                               aileron);
 296             Cn += CnfadafI;
 297             break;
 298           }
 299         case Cnfadrf_flag:
 300           {
 301             if (Cnfadrf_nice == 1)
 302               CnfadrfI = uiuc_3Dinterp_quick(Cnfadrf_fArray,
 303                                              Cnfadrf_aArray_nice,
 304                                              Cnfadrf_drArray_nice,
 305                                              Cnfadrf_CnArray,
 306                                              Cnfadrf_na_nice,
 307                                              Cnfadrf_ndr_nice,
 308                                              Cnfadrf_nf,
 309                                              flap_pos,
 310                                              Std_Alpha,
 311                                              rudder);
 312             else
 313               CnfadrfI = uiuc_3Dinterpolation(Cnfadrf_fArray,
 314                                               Cnfadrf_aArray,
 315                                               Cnfadrf_drArray,
 316                                               Cnfadrf_CnArray,
 317                                               Cnfadrf_nAlphaArray,
 318                                               Cnfadrf_ndr,
 319                                               Cnfadrf_nf,
 320                                               flap_pos,
 321                                               Std_Alpha,
 322                                               rudder);
 323             Cn += CnfadrfI;
 324             break;
 325           }
 326         case Cnfapf_flag:
 327           {
 328             p_nondim = P_body * b_2U;
 329             if (Cnfapf_nice == 1)
 330               CnfapfI = uiuc_3Dinterp_quick(Cnfapf_fArray,
 331                                             Cnfapf_aArray_nice,
 332                                             Cnfapf_pArray_nice,
 333                                             Cnfapf_CnArray,
 334                                             Cnfapf_na_nice,
 335                                             Cnfapf_np_nice,
 336                                             Cnfapf_nf,
 337                                             flap_pos,
 338                                             Std_Alpha,
 339                                             p_nondim);
 340             else
 341               CnfapfI = uiuc_3Dinterpolation(Cnfapf_fArray,
 342                                              Cnfapf_aArray,
 343                                              Cnfapf_pArray,
 344                                              Cnfapf_CnArray,
 345                                              Cnfapf_nAlphaArray,
 346                                              Cnfapf_np,
 347                                              Cnfapf_nf,
 348                                              flap_pos,
 349                                              Std_Alpha,
 350                                              p_nondim);
 351             Cn += CnfapfI;
 352             break;
 353           }
 354         case Cnfarf_flag:
 355           {
 356             r_nondim = R_body * b_2U;
 357             if (Cnfarf_nice == 1)
 358               CnfarfI = uiuc_3Dinterp_quick(Cnfarf_fArray,
 359                                             Cnfarf_aArray_nice,
 360                                             Cnfarf_rArray_nice,
 361                                             Cnfarf_CnArray,
 362                                             Cnfarf_na_nice,
 363                                             Cnfarf_nr_nice,
 364                                             Cnfarf_nf,
 365                                             flap_pos,
 366                                             Std_Alpha,
 367                                             r_nondim);
 368             else
 369               CnfarfI = uiuc_3Dinterpolation(Cnfarf_fArray,
 370                                              Cnfarf_aArray,
 371                                              Cnfarf_rArray,
 372                                              Cnfarf_CnArray,
 373                                              Cnfarf_nAlphaArray,
 374                                              Cnfarf_nr,
 375                                              Cnfarf_nf,
 376                                              flap_pos,
 377                                              Std_Alpha,
 378                                              r_nondim);
 379             Cn += CnfarfI;
 380             break;
 381           }
 382         };
 383     } // end Cn map
 384
 385   return;
 386 }
 387
 388 // end uiuc_coef_yaw.cpp