----------------------------------------------------------------------
HISTORY: 04/15/2000 initial release
+ 10/25/2001 (RD) Added new variables needed for the non-
+ linear Twin Otter model at zero flaps
+ (CXfxxf0)
+ 11/12/2001 (RD) Added new variables needed for the non-
+ linear Twin Otter model with flaps
+ (CXfxxf). Zero flap vairables removed.
+ 02/13/2002 (RD) Added variables so linear aero model
+ values can be recorded
+ 02/18/2002 (RD) Added uiuc_3Dinterp_quick() function
+ for a quicker 3D interpolation. Takes
+ advantage of "nice" data.
----------------------------------------------------------------------
AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
- Jeff Scott <jscott@mail.com>
+ Jeff Scott http://www.jeffscott.net/
+ Robert Deters <rdeters@uiuc.edu>
----------------------------------------------------------------------
CALLS TO: uiuc_1Dinterpolation
uiuc_2Dinterpolation
uiuc_ice_filter
+ uiuc_3Dinterpolation
+ uiuc_3Dinterp_quick
----------------------------------------------------------------------
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
- USA or view http://www.gnu.org/copyleft/gpl.html.
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**********************************************************************/
#include "uiuc_coef_drag.h"
-
+#include <math.h>
void uiuc_coef_drag()
{
string linetoken1;
string linetoken2;
stack command_list;
-
+
+ double q_nondim;
+
command_list = aeroDragParts -> getCommands();
for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
{
CDo = uiuc_ice_filter(CDo_clean,kCDo);
}
- CD += CDo;
+ CDo_save = CDo;
+ CD += CDo_save;
break;
}
case CDK_flag:
{
CDK = uiuc_ice_filter(CDK_clean,kCDK);
}
- CD += CDK * CL * CL;
+ if (b_CLK)
+ {
+ CDK_save = CDK * (CL - CLK) * (CL - CLK);
+ }
+ else
+ {
+ CDK_save = CDK * CL * CL;
+ }
+ CD += CDK_save;
break;
}
case CD_a_flag:
{
CD_a = uiuc_ice_filter(CD_a_clean,kCD_a);
}
- CD += CD_a * Alpha;
+ CD_a_save = CD_a * Std_Alpha;
+ CD += CD_a_save;
break;
}
case CD_adot_flag:
}
/* CD_adot must be mulitplied by cbar/2U
(see Roskam Control book, Part 1, pg. 147) */
- CD += CD_adot * Alpha_dot * cbar_2U;
+ CD_adot_save = CD_adot * Std_Alpha_dot * cbar_2U;
+ CD += CD_adot_save;
break;
}
case CD_q_flag:
(see Roskam Control book, Part 1, pg. 147) */
/* why multiply by Theta_dot instead of Q_body?
see note in coef_lift.cpp */
- CD += CD_q * Theta_dot * cbar_2U;
+ CD_q_save = CD_q * Theta_dot * cbar_2U;
+ CD += CD_q_save;
break;
}
case CD_ih_flag:
{
- CD += CD_ih * ih;
+ CD_ih_save = fabs(CD_ih * ih);
+ CD += CD_ih_save;
break;
}
case CD_de_flag:
{
CD_de = uiuc_ice_filter(CD_de_clean,kCD_de);
}
- CD += CD_de * elevator;
+ CD_de_save = fabs(CD_de * elevator);
+ CD += CD_de_save;
+ break;
+ }
+ case CD_dr_flag:
+ {
+ CD_dr_save = fabs(CD_dr * rudder);
+ CD += CD_dr_save;
+ break;
+ }
+ case CD_da_flag:
+ {
+ CD_da_save = fabs(CD_da * aileron);
+ CD += CD_da_save;
+ break;
+ }
+ case CD_beta_flag:
+ {
+ CD_beta_save = fabs(CD_beta * Std_Beta);
+ CD += CD_beta_save;
+ break;
+ }
+ case CD_df_flag:
+ {
+ CD_df_save = fabs(CD_df * flap_pos);
+ CD += CD_df_save;
+ break;
+ }
+ case CD_ds_flag:
+ {
+ CD_ds_save = fabs(CD_ds * spoiler_pos);
+ CD += CD_ds_save;
+ break;
+ }
+ case CD_dg_flag:
+ {
+ CD_dg_save = fabs(CD_dg * gear_pos_norm);
+ CD += CD_dg_save;
break;
}
case CDfa_flag:
CDfaI = uiuc_1Dinterpolation(CDfa_aArray,
CDfa_CDArray,
CDfa_nAlpha,
- Alpha);
+ Std_Alpha);
CD += CDfaI;
break;
}
CDfdfI = uiuc_1Dinterpolation(CDfdf_dfArray,
CDfdf_CDArray,
CDfdf_ndf,
- flap);
+ flap_pos);
CD += CDfdfI;
break;
}
CDfade_CDArray,
CDfade_nAlphaArray,
CDfade_nde,
- Alpha,
+ Std_Alpha,
elevator);
CD += CDfadeI;
break;
CDfadf_CDArray,
CDfadf_nAlphaArray,
CDfadf_ndf,
- Alpha,
- flap);
+ Std_Alpha,
+ flap_pos);
CD += CDfadfI;
break;
}
CXiced_tail += CXo;
}
}
- CX += CXo;
+ CXo_save = CXo;
+ CX += CXo_save;
break;
}
case CXK_flag:
CXiced_tail += CXK * CLiced_tail * CLiced_tail;
}
}
- CX += CXK * CZ * CZ;
+ CXK_save = CXK * CZ * CZ;
+ CX += CXK_save;
break;
}
case CX_a_flag:
CX_a = uiuc_ice_filter(CX_a_clean,kCX_a);
if (beta_model)
{
- CXclean_wing += CX_a_clean * Alpha;
- CXclean_tail += CX_a_clean * Alpha;
- CXiced_wing += CX_a * Alpha;
- CXiced_tail += CX_a * Alpha;
+ CXclean_wing += CX_a_clean * Std_Alpha;
+ CXclean_tail += CX_a_clean * Std_Alpha;
+ CXiced_wing += CX_a * Std_Alpha;
+ CXiced_tail += CX_a * Std_Alpha;
}
}
- CX += CX_a * Alpha;
+ CX_a_save = CX_a * Std_Alpha;
+ CX += CX_a_save;
break;
}
case CX_a2_flag:
CX_a2 = uiuc_ice_filter(CX_a2_clean,kCX_a2);
if (beta_model)
{
- CXclean_wing += CX_a2_clean * Alpha * Alpha;
- CXclean_tail += CX_a2_clean * Alpha * Alpha;
- CXiced_wing += CX_a2 * Alpha * Alpha;
- CXiced_tail += CX_a2 * Alpha * Alpha;
+ CXclean_wing += CX_a2_clean * Std_Alpha * Std_Alpha;
+ CXclean_tail += CX_a2_clean * Std_Alpha * Std_Alpha;
+ CXiced_wing += CX_a2 * Std_Alpha * Std_Alpha;
+ CXiced_tail += CX_a2 * Std_Alpha * Std_Alpha;
}
}
- CX += CX_a2 * Alpha * Alpha;
+ CX_a2_save = CX_a2 * Std_Alpha * Std_Alpha;
+ CX += CX_a2_save;
break;
}
case CX_a3_flag:
CX_a3 = uiuc_ice_filter(CX_a3_clean,kCX_a3);
if (beta_model)
{
- CXclean_wing += CX_a3_clean * Alpha * Alpha * Alpha;
- CXclean_tail += CX_a3_clean * Alpha * Alpha * Alpha;
- CXiced_wing += CX_a3 * Alpha * Alpha * Alpha;
- CXiced_tail += CX_a3 * Alpha * Alpha * Alpha;
+ CXclean_wing += CX_a3_clean * Std_Alpha * Std_Alpha * Std_Alpha;
+ CXclean_tail += CX_a3_clean * Std_Alpha * Std_Alpha * Std_Alpha;
+ CXiced_wing += CX_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
+ CXiced_tail += CX_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
}
}
- CX += CX_a3 * Alpha * Alpha * Alpha;
+ CX_a3_save = CX_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
+ CX += CX_a3_save;
break;
}
case CX_adot_flag:
CX_adot = uiuc_ice_filter(CX_adot_clean,kCX_adot);
if (beta_model)
{
- CXclean_wing += CX_adot_clean * Alpha_dot * cbar_2U;
- CXclean_tail += CX_adot_clean * Alpha_dot * ch_2U;
- CXiced_wing += CX * Alpha_dot * cbar_2U;
- CXiced_tail += CX * Alpha_dot * ch_2U;
+ CXclean_wing += CX_adot_clean * Std_Alpha_dot * cbar_2U;
+ CXclean_tail += CX_adot_clean * Std_Alpha_dot * ch_2U;
+ CXiced_wing += CX * Std_Alpha_dot * cbar_2U;
+ CXiced_tail += CX * Std_Alpha_dot * ch_2U;
}
}
/* CX_adot must be mulitplied by cbar/2U
(see Roskam Control book, Part 1, pg. 147) */
- CX += CX_adot * Alpha_dot * cbar_2U;
+ CX_adot_save = CX_adot * Std_Alpha_dot * cbar_2U;
+ CX += CX_adot_save;
break;
}
case CX_q_flag:
}
/* CX_q must be mulitplied by cbar/2U
(see Roskam Control book, Part 1, pg. 147) */
- CX += CX_q * Q_body * cbar_2U;
+ CX_q_save = CX_q * Q_body * cbar_2U;
+ CX += CX_q_save;
break;
}
case CX_de_flag:
CXiced_tail += CX_de * elevator;
}
}
- CX += CX_de * elevator;
+ CX_de_save = CX_de * elevator;
+ CX += CX_de_save;
break;
}
case CX_dr_flag:
CXiced_tail += CX_dr * rudder;
}
}
- CX += CX_dr * rudder;
+ CX_dr_save = CX_dr * rudder;
+ CX += CX_dr_save;
break;
}
case CX_df_flag:
CX_df = uiuc_ice_filter(CX_df_clean,kCX_df);
if (beta_model)
{
- CXclean_wing += CX_df_clean * flap;
- CXclean_tail += CX_df_clean * flap;
- CXiced_wing += CX * flap;
- CXiced_tail += CX * flap;
+ CXclean_wing += CX_df_clean * flap_pos;
+ CXclean_tail += CX_df_clean * flap_pos;
+ CXiced_wing += CX * flap_pos;
+ CXiced_tail += CX * flap_pos;
}
}
- CX += CX_df * flap;
+ CX_df_save = CX_df * flap_pos;
+ CX += CX_df_save;
break;
}
case CX_adf_flag:
CX_adf = uiuc_ice_filter(CX_adf_clean,kCX_adf);
if (beta_model)
{
- CXclean_wing += CX_adf_clean * Alpha * flap;
- CXclean_tail += CX_adf_clean * Alpha * flap;
- CXiced_wing += CX_adf * Alpha * flap;
- CXiced_tail += CX_adf * Alpha * flap;
+ CXclean_wing += CX_adf_clean * Std_Alpha * flap_pos;
+ CXclean_tail += CX_adf_clean * Std_Alpha * flap_pos;
+ CXiced_wing += CX_adf * Std_Alpha * flap_pos;
+ CXiced_tail += CX_adf * Std_Alpha * flap_pos;
}
}
- CX += CX_adf * Alpha * flap;
+ CX_adf_save = CX_adf * Std_Alpha * flap_pos;
+ CX += CX_adf_save;
+ break;
+ }
+ case CXfabetaf_flag:
+ {
+ if (CXfabetaf_nice == 1) {
+ CXfabetafI = uiuc_3Dinterp_quick(CXfabetaf_fArray,
+ CXfabetaf_aArray_nice,
+ CXfabetaf_bArray_nice,
+ CXfabetaf_CXArray,
+ CXfabetaf_na_nice,
+ CXfabetaf_nb_nice,
+ CXfabetaf_nf,
+ flap_pos,
+ Std_Alpha,
+ Std_Beta);
+ // temp until Jim's code works
+ //CXo = uiuc_3Dinterp_quick(CXfabetaf_fArray,
+ // CXfabetaf_aArray_nice,
+ // CXfabetaf_bArray_nice,
+ // CXfabetaf_CXArray,
+ // CXfabetaf_na_nice,
+ // CXfabetaf_nb_nice,
+ // CXfabetaf_nf,
+ // flap_pos,
+ // 0.0,
+ // Std_Beta);
+ }
+ else {
+ CXfabetafI = uiuc_3Dinterpolation(CXfabetaf_fArray,
+ CXfabetaf_aArray,
+ CXfabetaf_betaArray,
+ CXfabetaf_CXArray,
+ CXfabetaf_nAlphaArray,
+ CXfabetaf_nbeta,
+ CXfabetaf_nf,
+ flap_pos,
+ Std_Alpha,
+ Std_Beta);
+ // temp until Jim's code works
+ //CXo = uiuc_3Dinterpolation(CXfabetaf_fArray,
+ // CXfabetaf_aArray,
+ // CXfabetaf_betaArray,
+ // CXfabetaf_CXArray,
+ // CXfabetaf_nAlphaArray,
+ // CXfabetaf_nbeta,
+ // CXfabetaf_nf,
+ // flap_pos,
+ // 0.0,
+ // Std_Beta);
+ }
+ CX += CXfabetafI;
+ break;
+ }
+ case CXfadef_flag:
+ {
+ if (CXfadef_nice == 1)
+ CXfadefI = uiuc_3Dinterp_quick(CXfadef_fArray,
+ CXfadef_aArray_nice,
+ CXfadef_deArray_nice,
+ CXfadef_CXArray,
+ CXfadef_na_nice,
+ CXfadef_nde_nice,
+ CXfadef_nf,
+ flap_pos,
+ Std_Alpha,
+ elevator);
+ else
+ CXfadefI = uiuc_3Dinterpolation(CXfadef_fArray,
+ CXfadef_aArray,
+ CXfadef_deArray,
+ CXfadef_CXArray,
+ CXfadef_nAlphaArray,
+ CXfadef_nde,
+ CXfadef_nf,
+ flap_pos,
+ Std_Alpha,
+ elevator);
+ CX += CXfadefI;
+ break;
+ }
+ case CXfaqf_flag:
+ {
+ q_nondim = Q_body * cbar_2U;
+ if (CXfaqf_nice == 1)
+ CXfaqfI = uiuc_3Dinterp_quick(CXfaqf_fArray,
+ CXfaqf_aArray_nice,
+ CXfaqf_qArray_nice,
+ CXfaqf_CXArray,
+ CXfaqf_na_nice,
+ CXfaqf_nq_nice,
+ CXfaqf_nf,
+ flap_pos,
+ Std_Alpha,
+ q_nondim);
+ else
+ CXfaqfI = uiuc_3Dinterpolation(CXfaqf_fArray,
+ CXfaqf_aArray,
+ CXfaqf_qArray,
+ CXfaqf_CXArray,
+ CXfaqf_nAlphaArray,
+ CXfaqf_nq,
+ CXfaqf_nf,
+ flap_pos,
+ Std_Alpha,
+ q_nondim);
+ CX += CXfaqfI;
break;
}
};
projects / flightgear.git / blobdiff