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