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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
83 USA or view http://www.gnu.org/copyleft/gpl.html.
85 **********************************************************************/
87 #include "uiuc_coef_drag.h"
98 command_list = aeroDragParts -> getCommands();
100 for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
102 linetoken1 = aeroDragParts -> getToken(*command_line, 1);
103 linetoken2 = aeroDragParts -> getToken(*command_line, 2);
105 switch (CD_map[linetoken2])
111 CDo = uiuc_ice_filter(CDo_clean,kCDo);
121 CDK = uiuc_ice_filter(CDK_clean,kCDK);
125 CDK_save = CDK * (CL - CLK) * (CL - CLK);
129 CDK_save = CDK * CL * CL;
138 CD_a = uiuc_ice_filter(CD_a_clean,kCD_a);
140 CD_a_save = CD_a * Std_Alpha;
148 CD_adot = uiuc_ice_filter(CD_adot_clean,kCD_adot);
150 /* CD_adot must be mulitplied by cbar/2U
151 (see Roskam Control book, Part 1, pg. 147) */
152 CD_adot_save = CD_adot * Std_Alpha_dot * cbar_2U;
160 CD_q = uiuc_ice_filter(CD_q_clean,kCD_q);
162 /* CD_q must be mulitplied by cbar/2U
163 (see Roskam Control book, Part 1, pg. 147) */
164 /* why multiply by Theta_dot instead of Q_body?
165 see note in coef_lift.cpp */
166 CD_q_save = CD_q * Theta_dot * cbar_2U;
172 CD_ih_save = fabs(CD_ih * ih);
180 CD_de = uiuc_ice_filter(CD_de_clean,kCD_de);
182 CD_de_save = fabs(CD_de * elevator);
188 CD_dr_save = fabs(CD_dr * rudder);
194 CD_da_save = fabs(CD_da * aileron);
200 CD_beta_save = fabs(CD_beta * Std_Beta);
206 CD_df_save = fabs(CD_df * flap_pos);
212 CD_ds_save = fabs(CD_ds * spoiler_pos);
218 CD_dg_save = fabs(CD_dg * gear_pos_norm);
224 CDfaI = uiuc_1Dinterpolation(CDfa_aArray,
233 CDfCLI = uiuc_1Dinterpolation(CDfCL_CLArray,
242 CDfdfI = uiuc_1Dinterpolation(CDfdf_dfArray,
251 CDfadeI = uiuc_2Dinterpolation(CDfade_aArray,
263 CDfadfI = uiuc_2Dinterpolation(CDfadf_aArray,
277 CXo = uiuc_ice_filter(CXo_clean,kCXo);
280 CXclean_wing += CXo_clean;
281 CXclean_tail += CXo_clean;
294 CXK = uiuc_ice_filter(CXK_clean,kCXK);
297 CXclean_wing += CXK_clean * CLclean_wing * CLclean_wing;
298 CXclean_tail += CXK_clean * CLclean_tail * CLclean_tail;
299 CXiced_wing += CXK * CLiced_wing * CLiced_wing;
300 CXiced_tail += CXK * CLiced_tail * CLiced_tail;
303 CXK_save = CXK * CZ * CZ;
311 CX_a = uiuc_ice_filter(CX_a_clean,kCX_a);
314 CXclean_wing += CX_a_clean * Std_Alpha;
315 CXclean_tail += CX_a_clean * Std_Alpha;
316 CXiced_wing += CX_a * Std_Alpha;
317 CXiced_tail += CX_a * Std_Alpha;
320 CX_a_save = CX_a * Std_Alpha;
328 CX_a2 = uiuc_ice_filter(CX_a2_clean,kCX_a2);
331 CXclean_wing += CX_a2_clean * Std_Alpha * Std_Alpha;
332 CXclean_tail += CX_a2_clean * Std_Alpha * Std_Alpha;
333 CXiced_wing += CX_a2 * Std_Alpha * Std_Alpha;
334 CXiced_tail += CX_a2 * Std_Alpha * Std_Alpha;
337 CX_a2_save = CX_a2 * Std_Alpha * Std_Alpha;
345 CX_a3 = uiuc_ice_filter(CX_a3_clean,kCX_a3);
348 CXclean_wing += CX_a3_clean * Std_Alpha * Std_Alpha * Std_Alpha;
349 CXclean_tail += CX_a3_clean * Std_Alpha * Std_Alpha * Std_Alpha;
350 CXiced_wing += CX_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
351 CXiced_tail += CX_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
354 CX_a3_save = CX_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
362 CX_adot = uiuc_ice_filter(CX_adot_clean,kCX_adot);
365 CXclean_wing += CX_adot_clean * Std_Alpha_dot * cbar_2U;
366 CXclean_tail += CX_adot_clean * Std_Alpha_dot * ch_2U;
367 CXiced_wing += CX * Std_Alpha_dot * cbar_2U;
368 CXiced_tail += CX * Std_Alpha_dot * ch_2U;
371 /* CX_adot must be mulitplied by cbar/2U
372 (see Roskam Control book, Part 1, pg. 147) */
373 CX_adot_save = CX_adot * Std_Alpha_dot * cbar_2U;
381 CX_q = uiuc_ice_filter(CX_q_clean,kCX_q);
384 CXclean_wing += CX_q_clean * Q_body * cbar_2U;
385 CXclean_tail += CX_q_clean * Q_body * ch_2U;
386 CXiced_wing += CX_q * Q_body * cbar_2U;
387 CXiced_tail += CX_q * Q_body * ch_2U;
390 /* CX_q must be mulitplied by cbar/2U
391 (see Roskam Control book, Part 1, pg. 147) */
392 CX_q_save = CX_q * Q_body * cbar_2U;
400 CX_de = uiuc_ice_filter(CX_de_clean,kCX_de);
403 CXclean_wing += CX_de_clean * elevator;
404 CXclean_tail += CX_de_clean * elevator;
405 CXiced_wing += CX_de * elevator;
406 CXiced_tail += CX_de * elevator;
409 CX_de_save = CX_de * elevator;
417 CX_dr = uiuc_ice_filter(CX_dr_clean,kCX_dr);
420 CXclean_wing += CX_dr_clean * rudder;
421 CXclean_tail += CX_dr_clean * rudder;
422 CXiced_wing += CX_dr * rudder;
423 CXiced_tail += CX_dr * rudder;
426 CX_dr_save = CX_dr * rudder;
434 CX_df = uiuc_ice_filter(CX_df_clean,kCX_df);
437 CXclean_wing += CX_df_clean * flap_pos;
438 CXclean_tail += CX_df_clean * flap_pos;
439 CXiced_wing += CX * flap_pos;
440 CXiced_tail += CX * flap_pos;
443 CX_df_save = CX_df * flap_pos;
451 CX_adf = uiuc_ice_filter(CX_adf_clean,kCX_adf);
454 CXclean_wing += CX_adf_clean * Std_Alpha * flap_pos;
455 CXclean_tail += CX_adf_clean * Std_Alpha * flap_pos;
456 CXiced_wing += CX_adf * Std_Alpha * flap_pos;
457 CXiced_tail += CX_adf * Std_Alpha * flap_pos;
460 CX_adf_save = CX_adf * Std_Alpha * flap_pos;
466 if (CXfabetaf_nice == 1) {
467 CXfabetafI = uiuc_3Dinterp_quick(CXfabetaf_fArray,
468 CXfabetaf_aArray_nice,
469 CXfabetaf_bArray_nice,
477 // temp until Jim's code works
478 //CXo = uiuc_3Dinterp_quick(CXfabetaf_fArray,
479 // CXfabetaf_aArray_nice,
480 // CXfabetaf_bArray_nice,
481 // CXfabetaf_CXArray,
482 // CXfabetaf_na_nice,
483 // CXfabetaf_nb_nice,
490 CXfabetafI = uiuc_3Dinterpolation(CXfabetaf_fArray,
494 CXfabetaf_nAlphaArray,
500 // temp until Jim's code works
501 //CXo = uiuc_3Dinterpolation(CXfabetaf_fArray,
503 // CXfabetaf_betaArray,
504 // CXfabetaf_CXArray,
505 // CXfabetaf_nAlphaArray,
517 if (CXfadef_nice == 1)
518 CXfadefI = uiuc_3Dinterp_quick(CXfadef_fArray,
520 CXfadef_deArray_nice,
529 CXfadefI = uiuc_3Dinterpolation(CXfadef_fArray,
544 q_nondim = Q_body * cbar_2U;
545 if (CXfaqf_nice == 1)
546 CXfaqfI = uiuc_3Dinterp_quick(CXfaqf_fArray,
557 CXfaqfI = uiuc_3Dinterpolation(CXfaqf_fArray,
576 // end uiuc_coef_drag.cpp