1 /**********************************************************************
3 FILENAME: uiuc_coef_drag.cpp
5 ----------------------------------------------------------------------
7 DESCRIPTION: computes aggregated aerodynamic drag coefficient
9 ----------------------------------------------------------------------
13 ----------------------------------------------------------------------
15 REFERENCES: Roskam, Jan. Airplane Flight Dynamics and Automatic
16 Flight Controls, Part I. Lawrence, KS: DARcorporation,
19 ----------------------------------------------------------------------
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
25 11/12/2001 (RD) Added new variables needed for the non-
26 linear Twin Otter model with flaps
27 (CXfxxf). 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.
34 ----------------------------------------------------------------------
36 AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
37 Jeff Scott http://www.jeffscott.net/
38 Robert Deters <rdeters@uiuc.edu>
40 ----------------------------------------------------------------------
44 ----------------------------------------------------------------------
48 -drag coefficient components
51 ----------------------------------------------------------------------
55 ----------------------------------------------------------------------
57 CALLED BY: uiuc_coefficients.cpp
59 ----------------------------------------------------------------------
61 CALLS TO: uiuc_1Dinterpolation
67 ----------------------------------------------------------------------
69 COPYRIGHT: (C) 2000 by Michael Selig
71 This program is free software; you can redistribute it and/or
72 modify it under the terms of the GNU General Public License
73 as published by the Free Software Foundation.
75 This program is distributed in the hope that it will be useful,
76 but WITHOUT ANY WARRANTY; without even the implied warranty of
77 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
78 GNU General Public License for more details.
80 You should have received a copy of the GNU General Public License
81 along with this program; if not, write to the Free Software
82 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
84 **********************************************************************/
86 #include "uiuc_coef_drag.h"
97 command_list = aeroDragParts -> getCommands();
99 for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
101 linetoken1 = aeroDragParts -> getToken(*command_line, 1);
102 linetoken2 = aeroDragParts -> getToken(*command_line, 2);
104 switch (CD_map[linetoken2])
110 CDo = uiuc_ice_filter(CDo_clean,kCDo);
120 CDK = uiuc_ice_filter(CDK_clean,kCDK);
124 CDK_save = CDK * (CL - CLK) * (CL - CLK);
128 CDK_save = CDK * CL * CL;
137 CD_a = uiuc_ice_filter(CD_a_clean,kCD_a);
139 CD_a_save = CD_a * Std_Alpha;
147 CD_adot = uiuc_ice_filter(CD_adot_clean,kCD_adot);
149 /* CD_adot must be mulitplied by cbar/2U
150 (see Roskam Control book, Part 1, pg. 147) */
151 CD_adot_save = CD_adot * Std_Alpha_dot * cbar_2U;
159 CD_q = uiuc_ice_filter(CD_q_clean,kCD_q);
161 /* CD_q must be mulitplied by cbar/2U
162 (see Roskam Control book, Part 1, pg. 147) */
163 /* why multiply by Theta_dot instead of Q_body?
164 see note in coef_lift.cpp */
165 CD_q_save = CD_q * Theta_dot * cbar_2U;
171 CD_ih_save = fabs(CD_ih * ih);
179 CD_de = uiuc_ice_filter(CD_de_clean,kCD_de);
181 CD_de_save = fabs(CD_de * elevator);
187 CD_dr_save = fabs(CD_dr * rudder);
193 CD_da_save = fabs(CD_da * aileron);
199 CD_beta_save = fabs(CD_beta * Std_Beta);
205 CD_df_save = fabs(CD_df * flap_pos);
211 CD_ds_save = fabs(CD_ds * spoiler_pos);
217 CD_dg_save = fabs(CD_dg * gear_pos_norm);
223 CDfaI = uiuc_1Dinterpolation(CDfa_aArray,
232 CDfCLI = uiuc_1Dinterpolation(CDfCL_CLArray,
241 CDfdfI = uiuc_1Dinterpolation(CDfdf_dfArray,
250 CDfadeI = uiuc_2Dinterpolation(CDfade_aArray,
262 CDfadfI = uiuc_2Dinterpolation(CDfadf_aArray,
276 CXo = uiuc_ice_filter(CXo_clean,kCXo);
279 CXclean_wing += CXo_clean;
280 CXclean_tail += CXo_clean;
293 CXK = uiuc_ice_filter(CXK_clean,kCXK);
296 CXclean_wing += CXK_clean * CLclean_wing * CLclean_wing;
297 CXclean_tail += CXK_clean * CLclean_tail * CLclean_tail;
298 CXiced_wing += CXK * CLiced_wing * CLiced_wing;
299 CXiced_tail += CXK * CLiced_tail * CLiced_tail;
302 CXK_save = CXK * CZ * CZ;
310 CX_a = uiuc_ice_filter(CX_a_clean,kCX_a);
313 CXclean_wing += CX_a_clean * Std_Alpha;
314 CXclean_tail += CX_a_clean * Std_Alpha;
315 CXiced_wing += CX_a * Std_Alpha;
316 CXiced_tail += CX_a * Std_Alpha;
319 CX_a_save = CX_a * Std_Alpha;
327 CX_a2 = uiuc_ice_filter(CX_a2_clean,kCX_a2);
330 CXclean_wing += CX_a2_clean * Std_Alpha * Std_Alpha;
331 CXclean_tail += CX_a2_clean * Std_Alpha * Std_Alpha;
332 CXiced_wing += CX_a2 * Std_Alpha * Std_Alpha;
333 CXiced_tail += CX_a2 * Std_Alpha * Std_Alpha;
336 CX_a2_save = CX_a2 * Std_Alpha * Std_Alpha;
344 CX_a3 = uiuc_ice_filter(CX_a3_clean,kCX_a3);
347 CXclean_wing += CX_a3_clean * Std_Alpha * Std_Alpha * Std_Alpha;
348 CXclean_tail += CX_a3_clean * Std_Alpha * Std_Alpha * Std_Alpha;
349 CXiced_wing += CX_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
350 CXiced_tail += CX_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
353 CX_a3_save = CX_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
361 CX_adot = uiuc_ice_filter(CX_adot_clean,kCX_adot);
364 CXclean_wing += CX_adot_clean * Std_Alpha_dot * cbar_2U;
365 CXclean_tail += CX_adot_clean * Std_Alpha_dot * ch_2U;
366 CXiced_wing += CX * Std_Alpha_dot * cbar_2U;
367 CXiced_tail += CX * Std_Alpha_dot * ch_2U;
370 /* CX_adot must be mulitplied by cbar/2U
371 (see Roskam Control book, Part 1, pg. 147) */
372 CX_adot_save = CX_adot * Std_Alpha_dot * cbar_2U;
380 CX_q = uiuc_ice_filter(CX_q_clean,kCX_q);
383 CXclean_wing += CX_q_clean * Q_body * cbar_2U;
384 CXclean_tail += CX_q_clean * Q_body * ch_2U;
385 CXiced_wing += CX_q * Q_body * cbar_2U;
386 CXiced_tail += CX_q * Q_body * ch_2U;
389 /* CX_q must be mulitplied by cbar/2U
390 (see Roskam Control book, Part 1, pg. 147) */
391 CX_q_save = CX_q * Q_body * cbar_2U;
399 CX_de = uiuc_ice_filter(CX_de_clean,kCX_de);
402 CXclean_wing += CX_de_clean * elevator;
403 CXclean_tail += CX_de_clean * elevator;
404 CXiced_wing += CX_de * elevator;
405 CXiced_tail += CX_de * elevator;
408 CX_de_save = CX_de * elevator;
416 CX_dr = uiuc_ice_filter(CX_dr_clean,kCX_dr);
419 CXclean_wing += CX_dr_clean * rudder;
420 CXclean_tail += CX_dr_clean * rudder;
421 CXiced_wing += CX_dr * rudder;
422 CXiced_tail += CX_dr * rudder;
425 CX_dr_save = CX_dr * rudder;
433 CX_df = uiuc_ice_filter(CX_df_clean,kCX_df);
436 CXclean_wing += CX_df_clean * flap_pos;
437 CXclean_tail += CX_df_clean * flap_pos;
438 CXiced_wing += CX * flap_pos;
439 CXiced_tail += CX * flap_pos;
442 CX_df_save = CX_df * flap_pos;
450 CX_adf = uiuc_ice_filter(CX_adf_clean,kCX_adf);
453 CXclean_wing += CX_adf_clean * Std_Alpha * flap_pos;
454 CXclean_tail += CX_adf_clean * Std_Alpha * flap_pos;
455 CXiced_wing += CX_adf * Std_Alpha * flap_pos;
456 CXiced_tail += CX_adf * Std_Alpha * flap_pos;
459 CX_adf_save = CX_adf * Std_Alpha * flap_pos;
465 if (CXfabetaf_nice == 1) {
466 CXfabetafI = uiuc_3Dinterp_quick(CXfabetaf_fArray,
467 CXfabetaf_aArray_nice,
468 CXfabetaf_bArray_nice,
476 // temp until Jim's code works
477 //CXo = uiuc_3Dinterp_quick(CXfabetaf_fArray,
478 // CXfabetaf_aArray_nice,
479 // CXfabetaf_bArray_nice,
480 // CXfabetaf_CXArray,
481 // CXfabetaf_na_nice,
482 // CXfabetaf_nb_nice,
489 CXfabetafI = uiuc_3Dinterpolation(CXfabetaf_fArray,
493 CXfabetaf_nAlphaArray,
499 // temp until Jim's code works
500 //CXo = uiuc_3Dinterpolation(CXfabetaf_fArray,
502 // CXfabetaf_betaArray,
503 // CXfabetaf_CXArray,
504 // CXfabetaf_nAlphaArray,
516 if (CXfadef_nice == 1)
517 CXfadefI = uiuc_3Dinterp_quick(CXfadef_fArray,
519 CXfadef_deArray_nice,
528 CXfadefI = uiuc_3Dinterpolation(CXfadef_fArray,
543 q_nondim = Q_body * cbar_2U;
544 if (CXfaqf_nice == 1)
545 CXfaqfI = uiuc_3Dinterp_quick(CXfaqf_fArray,
556 CXfaqfI = uiuc_3Dinterpolation(CXfaqf_fArray,
575 // end uiuc_coef_drag.cpp