----------------------------------------------------------------------
AUTHOR(S): Bipin Sehgal <bsehgal@uiuc.edu>
- Jeff Scott <jscott@mail.com>
+ Jeff Scott http://www.jeffscott.net/
Robert Deters <rdeters@uiuc.edu>
----------------------------------------------------------------------
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.
**********************************************************************/
CDo = uiuc_ice_filter(CDo_clean,kCDo);
}
CDo_save = CDo;
- CD += CDo;
+ CD += CDo_save;
break;
}
case CDK_flag:
{
CDK = uiuc_ice_filter(CDK_clean,kCDK);
}
- CDK_save = CDK * CL * CL;
- 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_a_save = CD_a * Alpha;
- 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_adot_save = CD_adot * Alpha_dot * cbar_2U;
- 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:
/* why multiply by Theta_dot instead of Q_body?
see note in coef_lift.cpp */
CD_q_save = CD_q * Theta_dot * cbar_2U;
- CD += CD_q * Theta_dot * cbar_2U;
+ CD += CD_q_save;
break;
}
case CD_ih_flag:
{
CD_ih_save = fabs(CD_ih * ih);
- CD += fabs(CD_ih * ih);
+ CD += CD_ih_save;
break;
}
case CD_de_flag:
CD_de = uiuc_ice_filter(CD_de_clean,kCD_de);
}
CD_de_save = fabs(CD_de * elevator);
- CD += 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;
}
}
}
CXo_save = CXo;
- CX += CXo;
+ CX += CXo_save;
break;
}
case CXK_flag:
}
}
CXK_save = CXK * CZ * CZ;
- CX += 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_a_save = CX_a * 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_a2_save = CX_a2 * Alpha * 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_a3_save = CX_a3 * Alpha * Alpha * 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_adot_save = CX_adot * Alpha_dot * cbar_2U;
- 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_q_save = CX_q * Q_body * cbar_2U;
- CX += CX_q * Q_body * cbar_2U;
+ CX += CX_q_save;
break;
}
case CX_de_flag:
}
}
CX_de_save = CX_de * elevator;
- CX += CX_de * elevator;
+ CX += CX_de_save;
break;
}
case CX_dr_flag:
}
}
CX_dr_save = CX_dr * rudder;
- CX += 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_df_save = CX_df * flap;
- 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_adf_save = CX_adf * Alpha * flap;
- 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)
+ if (CXfabetaf_nice == 1) {
CXfabetafI = uiuc_3Dinterp_quick(CXfabetaf_fArray,
CXfabetaf_aArray_nice,
CXfabetaf_bArray_nice,
CXfabetaf_nb_nice,
CXfabetaf_nf,
flap_pos,
- Alpha,
- Beta);
- else
+ 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_nbeta,
CXfabetaf_nf,
flap_pos,
- Alpha,
- Beta);
+ 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;
}
CXfadef_nde_nice,
CXfadef_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
elevator);
else
CXfadefI = uiuc_3Dinterpolation(CXfadef_fArray,
CXfadef_nde,
CXfadef_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
elevator);
CX += CXfadefI;
break;
CXfaqf_nq_nice,
CXfaqf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
q_nondim);
else
CXfaqfI = uiuc_3Dinterpolation(CXfaqf_fArray,
CXfaqf_nq,
CXfaqf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
q_nondim);
CX += CXfaqfI;
break;
projects / flightgear.git / blobdiff