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             break;
 129           }
 130         case Cn_p_flag:
 131           {
 132             if (ice_on)
 133               {
 134                 Cn_p = uiuc_ice_filter(Cn_p_clean,kCn_p);
 135               }
 136             /* Cn_p must be mulitplied by b/2U
 137                (see Roskam Control book, Part 1, pg. 147) */
 138             Cn_p_save = Cn_p * P_body * b_2U;
 139             Cn += Cn_p * P_body * b_2U;
 140             break;
 141           }
 142         case Cn_r_flag:
 143           {
 144             if (ice_on)
 145               {
 146                 Cn_r = uiuc_ice_filter(Cn_r_clean,kCn_r);
 147               }
 148             /* Cn_r must be mulitplied by b/2U
 149                (see Roskam Control book, Part 1, pg. 147) */
 150             Cn_r_save = Cn_r * R_body * b_2U;
 151             Cn += Cn_r * R_body * b_2U;
 152             break;
 153           }
 154         case Cn_da_flag:
 155           {
 156             if (ice_on)
 157               {
 158                 Cn_da = uiuc_ice_filter(Cn_da_clean,kCn_da);
 159               }
 160             Cn_da_save = Cn_da * aileron;
 161             Cn += Cn_da * aileron;
 162             break;
 163           }
 164         case Cn_dr_flag:
 165           {
 166             if (ice_on)
 167               {
 168                 Cn_dr = uiuc_ice_filter(Cn_dr_clean,kCn_dr);
 169               }
 170             Cn_dr_save = Cn_dr * rudder;
 171             Cn += Cn_dr * rudder;
 172             break;
 173           }
 174         case Cn_q_flag:
 175           {
 176             if (ice_on)
 177               {
 178                 Cn_q = uiuc_ice_filter(Cn_q_clean,kCn_q);
 179               }
 180             Cn_q_save = Cn_q * Q_body * cbar_2U;
 181             Cn += Cn_q * Q_body * cbar_2U;
 182             break;
 183           }
 184         case Cn_b3_flag:
 185           {
 186             if (ice_on)
 187               {
 188                 Cn_b3 = uiuc_ice_filter(Cn_b3_clean,kCn_b3);
 189               }
 190             Cn_b3_save = Cn_b3 * Beta * Beta * Beta;
 191             Cn += Cn_b3 * Beta * Beta * Beta;
 192             break;
 193           }
 194         case Cnfada_flag:
 195           {
 196             CnfadaI = uiuc_2Dinterpolation(Cnfada_aArray,
 197                                            Cnfada_daArray,
 198                                            Cnfada_CnArray,
 199                                            Cnfada_nAlphaArray,
 200                                            Cnfada_nda,
 201                                            Alpha,
 202                                            aileron);
 203             Cn += CnfadaI;
 204             break;
 205           }
 206         case Cnfbetadr_flag:
 207           {
 208             CnfbetadrI = uiuc_2Dinterpolation(Cnfbetadr_betaArray,
 209                                               Cnfbetadr_drArray,
 210                                               Cnfbetadr_CnArray,
 211                                               Cnfbetadr_nBetaArray,
 212                                               Cnfbetadr_ndr,
 213                                               Beta,
 214                                               rudder);
 215             Cn += CnfbetadrI;
 216             break;
 217           }
 218         case Cnfabetaf_flag:
 219           {
 220             if (Cnfabetaf_nice == 1)
 221               CnfabetafI = uiuc_3Dinterp_quick(Cnfabetaf_fArray,
 222                                                Cnfabetaf_aArray_nice,
 223                                                Cnfabetaf_bArray_nice,
 224                                                Cnfabetaf_CnArray,
 225                                                Cnfabetaf_na_nice,
 226                                                Cnfabetaf_nb_nice,
 227                                                Cnfabetaf_nf,
 228                                                flap_pos,
 229                                                Alpha,
 230                                                Beta);
 231             else
 232               CnfabetafI = uiuc_3Dinterpolation(Cnfabetaf_fArray,
 233                                                 Cnfabetaf_aArray,
 234                                                 Cnfabetaf_betaArray,
 235                                                 Cnfabetaf_CnArray,
 236                                                 Cnfabetaf_nAlphaArray,
 237                                                 Cnfabetaf_nbeta,
 238                                                 Cnfabetaf_nf,
 239                                                 flap_pos,
 240                                                 Alpha,
 241                                                 Beta);
 242             Cn += CnfabetafI;
 243             break;
 244           }
 245         case Cnfadaf_flag:
 246           {
 247             if (Cnfadaf_nice == 1)
 248               CnfadafI = uiuc_3Dinterp_quick(Cnfadaf_fArray,
 249                                              Cnfadaf_aArray_nice,
 250                                              Cnfadaf_daArray_nice,
 251                                              Cnfadaf_CnArray,
 252                                              Cnfadaf_na_nice,
 253                                              Cnfadaf_nda_nice,
 254                                              Cnfadaf_nf,
 255                                              flap_pos,
 256                                              Alpha,
 257                                              aileron);
 258             else
 259               CnfadafI = uiuc_3Dinterpolation(Cnfadaf_fArray,
 260                                               Cnfadaf_aArray,
 261                                               Cnfadaf_daArray,
 262                                               Cnfadaf_CnArray,
 263                                               Cnfadaf_nAlphaArray,
 264                                               Cnfadaf_nda,
 265                                               Cnfadaf_nf,
 266                                               flap_pos,
 267                                               Alpha,
 268                                               aileron);
 269             Cn += CnfadafI;
 270             break;
 271           }
 272         case Cnfadrf_flag:
 273           {
 274             if (Cnfadrf_nice == 1)
 275               CnfadrfI = uiuc_3Dinterp_quick(Cnfadrf_fArray,
 276                                              Cnfadrf_aArray_nice,
 277                                              Cnfadrf_drArray_nice,
 278                                              Cnfadrf_CnArray,
 279                                              Cnfadrf_na_nice,
 280                                              Cnfadrf_ndr_nice,
 281                                              Cnfadrf_nf,
 282                                              flap_pos,
 283                                              Alpha,
 284                                              rudder);
 285             else
 286               CnfadrfI = uiuc_3Dinterpolation(Cnfadrf_fArray,
 287                                               Cnfadrf_aArray,
 288                                               Cnfadrf_drArray,
 289                                               Cnfadrf_CnArray,
 290                                               Cnfadrf_nAlphaArray,
 291                                               Cnfadrf_ndr,
 292                                               Cnfadrf_nf,
 293                                               flap_pos,
 294                                               Alpha,
 295                                               rudder);
 296             Cn += CnfadrfI;
 297             break;
 298           }
 299         case Cnfapf_flag:
 300           {
 301             p_nondim = P_body * b_2U;
 302             if (Cnfapf_nice == 1)
 303               CnfapfI = uiuc_3Dinterp_quick(Cnfapf_fArray,
 304                                             Cnfapf_aArray_nice,
 305                                             Cnfapf_pArray_nice,
 306                                             Cnfapf_CnArray,
 307                                             Cnfapf_na_nice,
 308                                             Cnfapf_np_nice,
 309                                             Cnfapf_nf,
 310                                             flap_pos,
 311                                             Alpha,
 312                                             p_nondim);
 313             else
 314               CnfapfI = uiuc_3Dinterpolation(Cnfapf_fArray,
 315                                              Cnfapf_aArray,
 316                                              Cnfapf_pArray,
 317                                              Cnfapf_CnArray,
 318                                              Cnfapf_nAlphaArray,
 319                                              Cnfapf_np,
 320                                              Cnfapf_nf,
 321                                              flap_pos,
 322                                              Alpha,
 323                                              p_nondim);
 324             Cn += CnfapfI;
 325             break;
 326           }
 327         case Cnfarf_flag:
 328           {
 329             r_nondim = R_body * b_2U;
 330             if (Cnfarf_nice == 1)
 331               CnfarfI = uiuc_3Dinterp_quick(Cnfarf_fArray,
 332                                             Cnfarf_aArray_nice,
 333                                             Cnfarf_rArray_nice,
 334                                             Cnfarf_CnArray,
 335                                             Cnfarf_na_nice,
 336                                             Cnfarf_nr_nice,
 337                                             Cnfarf_nf,
 338                                             flap_pos,
 339                                             Alpha,
 340                                             r_nondim);
 341             else
 342               CnfarfI = uiuc_3Dinterpolation(Cnfarf_fArray,
 343                                              Cnfarf_aArray,
 344                                              Cnfarf_rArray,
 345                                              Cnfarf_CnArray,
 346                                              Cnfarf_nAlphaArray,
 347                                              Cnfarf_nr,
 348                                              Cnfarf_nf,
 349                                              flap_pos,
 350                                              Alpha,
 351                                              r_nondim);
 352             Cn += CnfarfI;
 353             break;
 354           }
 355         };
 356     } // end Cn map
 357
 358   return;
 359 }
 360
 361 // end uiuc_coef_yaw.cpp