// set_Gravity( Gravity );
// set_Centrifugal_relief( Centrifugal_relief );
- _set_Alpha( Alpha );
- _set_Beta( Beta );
- // set_Alpha_dot( Alpha_dot );
- // set_Beta_dot( Beta_dot );
+ _set_Alpha( Std_Alpha );
+ _set_Beta( Std_Beta );
+ // set_Alpha_dot( Std_Alpha_dot );
+ // set_Beta_dot( Std_Beta_dot );
// set_Cos_alpha( Cos_alpha );
// set_Sin_alpha( Sin_alpha );
/* sum coefficients */
- CLwbh = interp(CLtable,alpha_ind,NCL,Alpha);
+ CLwbh = interp(CLtable,alpha_ind,NCL,Std_Alpha);
/* printf("CLwbh: %g\n",CLwbh);
*/
CLo = CLob + interp(dCLf,flap_ind,Ndf,Flap_Position);
- CL = CLo + CLwbh + (CLadot*Alpha_dot + CLq*Theta_dot)*cbar_2V + CLde*elevator;
+ CL = CLo + CLwbh + (CLadot*Std_Alpha_dot + CLq*Theta_dot)*cbar_2V + CLde*elevator;
cd = Cdo + rPiARe*Ai*Ai*CL*CL + Cdde*elevator;
- cy = Cybeta*Beta + (Cyp*P_body + Cyr*R_body)*b_2V + Cyda*aileron + Cydr*rudder;
+ cy = Cybeta*Std_Beta + (Cyp*P_body + Cyr*R_body)*b_2V + Cyda*aileron + Cydr*rudder;
- cm = Cmo + Cma*Alpha + (Cmq*Q_body + Cmadot*Alpha_dot)*cbar_2V + Cmde*(elevator);
- cn = Cnbeta*Beta + (Cnp*P_body + Cnr*R_body)*b_2V + Cnda*aileron + Cndr*rudder;
- croll=Clbeta*Beta + (Clp*P_body + Clr*R_body)*b_2V + Clda*aileron + Cldr*rudder;
+ cm = Cmo + Cma*Std_Alpha + (Cmq*Q_body + Cmadot*Std_Alpha_dot)*cbar_2V + Cmde*(elevator);
+ cn = Cnbeta*Std_Beta + (Cnp*P_body + Cnr*R_body)*b_2V + Cnda*aileron + Cndr*rudder;
+ croll=Clbeta*Std_Beta + (Clp*P_body + Clr*R_body)*b_2V + Clda*aileron + Cldr*rudder;
/* printf("aero: CL: %7.4f, Cd: %7.4f, Cm: %7.4f, Cy: %7.4f, Cn: %7.4f, Cl: %7.4f\n",CL,cd,cm,cy,cn,croll);
*/
- Cz = Cz0 + Cza*Alpha + Czat*(Alpha_dot*c/2.0/V) + Czq*(q*c/2.0/V) + Czde * elevator;
- Cm = Cm0 + Cma*Alpha + Cmat*(Alpha_dot*c/2.0/V) + Cmq*(q*c/2.0/V) + Cmde * elevator;
+ Cz = Cz0 + Cza*Std_Alpha + Czat*(Std_Alpha_dot*c/2.0/V) + Czq*(q*c/2.0/V) + Czde * elevator;
+ Cm = Cm0 + Cma*Std_Alpha + Cmat*(Std_Alpha_dot*c/2.0/V) + Cmq*(q*c/2.0/V) + Cmde * elevator;
- Cx = Cx0 - (Cza*Alpha)*(Cza*Alpha)/(LS_PI*5.71*0.6);
- Cl = Clb*Beta + Clp*(p*b/2.0/V) + Clr*(r*b/2.0/V) + Clda * aileron;
+ Cx = Cx0 - (Cza*Std_Alpha)*(Cza*Std_Alpha)/(LS_PI*5.71*0.6);
+ Cl = Clb*Std_Beta + Clp*(p*b/2.0/V) + Clr*(r*b/2.0/V) + Clda * aileron;
- Cy = Cyb*Beta + Cyr*(r*b/2.0/V);
- Cn = Cnb*Beta + Cnp*(p*b/2.0/V) + Cnr*(r*b/2.0/V) + Cndr * rudder;
+ Cy = Cyb*Std_Beta + Cyr*(r*b/2.0/V);
+ Cn = Cnb*Std_Beta + Cnp*(p*b/2.0/V) + Cnr*(r*b/2.0/V) + Cndr * rudder;
/* back to body axes */
{
$Header$
$Log$
+Revision 1.4 2003/05/25 12:14:46 ehofman
+Rename some defines to prevent a namespace clash
+
Revision 1.3 2003/05/13 18:45:06 curt
Robert Deters:
if( (v_XZ_plane_2 == 0) || (V_rel_wind == 0) )
{
- Alpha_dot = 0;
- Beta_dot = 0;
+ Std_Alpha_dot = 0;
+ Std_Beta_dot = 0;
}
else
{
- Alpha_dot = (U_body*W_dot_body - W_body*U_dot_body)/
+ Std_Alpha_dot = (U_body*W_dot_body - W_body*U_dot_body)/
v_XZ_plane_2;
- Beta_dot = (signU*v_XZ_plane_2*V_dot_body
+ Std_Beta_dot = (signU*v_XZ_plane_2*V_dot_body
- V_body*(U_body*U_dot_body + W_body*W_dot_body))
/(V_rel_wind*V_rel_wind*sqrt(v_XZ_plane_2));
}
/* Calculate flight path and other flight condition values */
if (U_body == 0)
- Alpha = 0;
+ Std_Alpha = 0;
else
- Alpha = atan2( W_body, U_body );
+ Std_Alpha = atan2( W_body, U_body );
- Cos_alpha = cos(Alpha);
- Sin_alpha = sin(Alpha);
+ Cos_alpha = cos(Std_Alpha);
+ Sin_alpha = sin(Std_Alpha);
if (V_rel_wind == 0)
- Beta = 0;
+ Std_Beta = 0;
else
- Beta = asin( V_body/ V_rel_wind );
+ Std_Beta = asin( V_body/ V_rel_wind );
- Cos_beta = cos(Beta);
- Sin_beta = sin(Beta);
+ Cos_beta = cos(Std_Beta);
+ Sin_beta = sin(Std_Beta);
V_true_kts = V_rel_wind * V_TO_KNOTS;
typedef struct {
-/*
- * Needed for windows builds
- */
-#ifdef Alpha
-#undef Alpha
-#endif
-
/*================== Mass properties and geometry values ==================*/
DATA mass, i_xx, i_yy, i_zz, i_xz; /* Inertias */
#define Centrifugal_relief generic_.centrifugal_relief
DATA alpha, beta, alpha_dot, beta_dot; /* in radians */
-#define Alpha generic_.alpha
-#define Beta generic_.beta
-#define Alpha_dot generic_.alpha_dot
-#define Beta_dot generic_.beta_dot
+#define Std_Alpha generic_.alpha
+#define Std_Beta generic_.beta
+#define Std_Alpha_dot generic_.alpha_dot
+#define Std_Beta_dot generic_.beta_dot
DATA cos_alpha, sin_alpha, cos_beta, sin_beta;
#define Cos_alpha generic_.cos_alpha
$Header$
$Log$
-Revision 1.1 2002/09/10 01:14:02 curt
-Initial revision
+Revision 1.2 2003/05/25 12:14:46 ehofman
+Rename some defines to prevent a namespace clash
+
+Revision 1.1.1.1 2002/09/10 01:14:02 curt
+Initial revision of FlightGear-0.9.0
Revision 1.5 2001/09/14 18:47:27 curt
More changes in support of UIUCModel.
/* Initialize auxiliary variables */
ls_aux();
- Alpha_dot = 0.;
- Beta_dot = 0.;
+ Std_Alpha_dot = 0.;
+ Std_Beta_dot = 0.;
/* set flag; disable integrators */
F_Y_aero = scale*(Mass*Y_v*V_body);
F_Z_aero = scale*(Z_0 + Mass*(Z_u*u + Z_w*w + Z_de*elevator));
- M_l_aero = scale*(I_xx*(L_beta*Beta + L_p*P_body + L_r*R_body
+ M_l_aero = scale*(I_xx*(L_beta*Std_Beta + L_p*P_body + L_r*R_body
+ L_da*aileron + L_dr*rudder));
M_m_aero = scale*(M_0 + I_yy*(M_w*w + M_q*Q_body + M_de*(elevator + Long_trim)));
- M_n_aero = scale*(I_zz*(N_beta*Beta + N_p*P_body + N_r*R_body
+ M_n_aero = scale*(I_zz*(N_beta*Std_Beta + N_p*P_body + N_r*R_body
+ N_da*aileron + N_dr*rudder));
}
AIRCRAFT()
{
- fog_field;
+ fog_field = 0;
fog_segments = 0;
fog_point_index = -1;
fog_time = NULL;
{
if (CX && CZ)
{
- CLclean_wing = CXclean_wing * sin(Alpha) - CZclean_wing * cos(Alpha);
- CLiced_wing = CXiced_wing * sin(Alpha) - CZiced_wing * cos(Alpha);
- CLclean_tail = CXclean_tail * sin(Alpha) - CZclean_tail * cos(Alpha);
- CLiced_tail = CXiced_tail * sin(Alpha) - CZiced_tail * cos(Alpha);
+ CLclean_wing = CXclean_wing * sin(Std_Alpha) - CZclean_wing * cos(Std_Alpha);
+ CLiced_wing = CXiced_wing * sin(Std_Alpha) - CZiced_wing * cos(Std_Alpha);
+ CLclean_tail = CXclean_tail * sin(Std_Alpha) - CZclean_tail * cos(Std_Alpha);
+ CLiced_tail = CXiced_tail * sin(Std_Alpha) - CZiced_tail * cos(Std_Alpha);
}
/* calculate lift per unit span*/
V_total_clean_wing = sqrt(w_clean_wing*w_clean_wing +
V_rel_wind*V_rel_wind -
2*w_clean_wing*V_rel_wind *
- cos(LS_PI/2 + Alpha));
+ cos(LS_PI/2 + Std_Alpha));
V_total_iced_wing = sqrt(w_iced_wing*w_iced_wing +
V_rel_wind*V_rel_wind -
2*w_iced_wing*V_rel_wind *
- cos(LS_PI/2 + Alpha));
+ cos(LS_PI/2 + Std_Alpha));
V_total_clean_tail = sqrt(w_clean_tail*w_clean_tail +
V_rel_wind*V_rel_wind -
2*w_clean_tail*V_rel_wind *
- cos(LS_PI/2 + Alpha));
+ cos(LS_PI/2 + Std_Alpha));
V_total_iced_tail = sqrt(w_iced_tail*w_iced_tail +
V_rel_wind*V_rel_wind -
2*w_iced_tail*V_rel_wind *
- cos(LS_PI/2 + Alpha));
+ cos(LS_PI/2 + Std_Alpha));
beta_flow_clean_wing = asin((w_clean_wing / V_total_clean_wing) *
- sin (LS_PI/2 + Alpha));
+ sin (LS_PI/2 + Std_Alpha));
beta_flow_iced_wing = asin((w_iced_wing / V_total_iced_wing) *
- sin (LS_PI/2 + Alpha));
+ sin (LS_PI/2 + Std_Alpha));
beta_flow_clean_tail = asin((w_clean_tail / V_total_clean_tail) *
- sin (LS_PI/2 + Alpha));
+ sin (LS_PI/2 + Std_Alpha));
beta_flow_iced_tail = asin((w_iced_tail / V_total_iced_tail) *
- sin (LS_PI/2 + Alpha));
+ sin (LS_PI/2 + Std_Alpha));
Dbeta_flow_wing = fabs(beta_flow_clean_wing - beta_flow_iced_wing);
Dbeta_flow_tail = fabs(beta_flow_clean_tail - beta_flow_iced_tail);
{
CD_a = uiuc_ice_filter(CD_a_clean,kCD_a);
}
- CD_a_save = CD_a * Alpha;
+ CD_a_save = CD_a * Std_Alpha;
CD += CD_a_save;
break;
}
}
/* 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_adot_save = CD_adot * Std_Alpha_dot * cbar_2U;
CD += CD_adot_save;
break;
}
}
case CD_beta_flag:
{
- CD_beta_save = fabs(CD_beta * Beta);
+ CD_beta_save = fabs(CD_beta * Std_Beta);
CD += CD_beta_save;
break;
}
CDfaI = uiuc_1Dinterpolation(CDfa_aArray,
CDfa_CDArray,
CDfa_nAlpha,
- Alpha);
+ Std_Alpha);
CD += CDfaI;
break;
}
CDfade_CDArray,
CDfade_nAlphaArray,
CDfade_nde,
- Alpha,
+ Std_Alpha,
elevator);
CD += CDfadeI;
break;
CDfadf_CDArray,
CDfadf_nAlphaArray,
CDfadf_ndf,
- Alpha,
+ Std_Alpha,
flap_pos);
CD += CDfadfI;
break;
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_a_save = CX_a * Std_Alpha;
CX += CX_a_save;
break;
}
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_a2_save = CX_a2 * Std_Alpha * Std_Alpha;
CX += CX_a2_save;
break;
}
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_a3_save = CX_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
CX += CX_a3_save;
break;
}
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_adot_save = CX_adot * Std_Alpha_dot * cbar_2U;
CX += CX_adot_save;
break;
}
CX_adf = uiuc_ice_filter(CX_adf_clean,kCX_adf);
if (beta_model)
{
- CXclean_wing += CX_adf_clean * Alpha * flap_pos;
- CXclean_tail += CX_adf_clean * Alpha * flap_pos;
- CXiced_wing += CX_adf * Alpha * flap_pos;
- CXiced_tail += CX_adf * Alpha * flap_pos;
+ 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_pos;
+ CX_adf_save = CX_adf * Std_Alpha * flap_pos;
CX += CX_adf_save;
break;
}
CXfabetaf_nb_nice,
CXfabetaf_nf,
flap_pos,
- Alpha,
- Beta);
+ Std_Alpha,
+ Std_Beta);
// temp until Jim's code works
//CXo = uiuc_3Dinterp_quick(CXfabetaf_fArray,
// CXfabetaf_aArray_nice,
// CXfabetaf_nf,
// flap_pos,
// 0.0,
- // Beta);
+ // Std_Beta);
}
else {
CXfabetafI = uiuc_3Dinterpolation(CXfabetaf_fArray,
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_nf,
// flap_pos,
// 0.0,
- // Beta);
+ // 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;
CL_a = uiuc_ice_filter(CL_a_clean,kCL_a);
if (beta_model)
{
- CLclean_wing += CL_a_clean * Alpha;
- CLclean_tail += CL_a_clean * Alpha;
- CLiced_wing += CL_a * Alpha;
- CLiced_tail += CL_a * Alpha;
+ CLclean_wing += CL_a_clean * Std_Alpha;
+ CLclean_tail += CL_a_clean * Std_Alpha;
+ CLiced_wing += CL_a * Std_Alpha;
+ CLiced_tail += CL_a * Std_Alpha;
}
}
- CL_a_save = CL_a * Alpha;
+ CL_a_save = CL_a * Std_Alpha;
CL += CL_a_save;
break;
}
CL_adot = uiuc_ice_filter(CL_adot_clean,kCL_adot);
if (beta_model)
{
- CLclean_wing += CL_adot_clean * Alpha_dot * cbar_2U;
- CLclean_tail += CL_adot_clean * Alpha_dot * ch_2U;
- CLiced_wing += CL_adot * Alpha_dot * cbar_2U;
- CLiced_tail += CL_adot * Alpha_dot * ch_2U;
+ CLclean_wing += CL_adot_clean * Std_Alpha_dot * cbar_2U;
+ CLclean_tail += CL_adot_clean * Std_Alpha_dot * ch_2U;
+ CLiced_wing += CL_adot * Std_Alpha_dot * cbar_2U;
+ CLiced_tail += CL_adot * Std_Alpha_dot * ch_2U;
}
}
/* CL_adot must be mulitplied by cbar/2U
(see Roskam Control book, Part 1, pg. 147) */
- CL_adot_save = CL_adot * Alpha_dot * cbar_2U;
+ CL_adot_save = CL_adot * Std_Alpha_dot * cbar_2U;
CL += CL_adot_save;
break;
}
CLfaI = uiuc_1Dinterpolation(CLfa_aArray,
CLfa_CLArray,
CLfa_nAlpha,
- Alpha);
+ Std_Alpha);
CL += CLfaI;
break;
}
CLfade_CLArray,
CLfade_nAlphaArray,
CLfade_nde,
- Alpha,
+ Std_Alpha,
elevator);
CL += CLfadeI;
break;
CLfadf_CLArray,
CLfadf_nAlphaArray,
CLfadf_ndf,
- Alpha,
+ Std_Alpha,
flap);
CL += CLfadfI;
break;
CZ_a = uiuc_ice_filter(CZ_a_clean,kCZ_a);
if (beta_model)
{
- CZclean_wing += CZ_a_clean * Alpha;
- CZclean_tail += CZ_a_clean * Alpha;
- CZiced_wing += CZ_a * Alpha;
- CZiced_tail += CZ_a * Alpha;
+ CZclean_wing += CZ_a_clean * Std_Alpha;
+ CZclean_tail += CZ_a_clean * Std_Alpha;
+ CZiced_wing += CZ_a * Std_Alpha;
+ CZiced_tail += CZ_a * Std_Alpha;
}
}
- CZ_a_save = CZ_a * Alpha;
+ CZ_a_save = CZ_a * Std_Alpha;
CZ += CZ_a_save;
break;
}
CZ_a2 = uiuc_ice_filter(CZ_a2_clean,kCZ_a2);
if (beta_model)
{
- CZclean_wing += CZ_a2_clean * Alpha * Alpha;
- CZclean_tail += CZ_a2_clean * Alpha * Alpha;
- CZiced_wing += CZ_a2 * Alpha * Alpha;
- CZiced_tail += CZ_a2 * Alpha * Alpha;
+ CZclean_wing += CZ_a2_clean * Std_Alpha * Std_Alpha;
+ CZclean_tail += CZ_a2_clean * Std_Alpha * Std_Alpha;
+ CZiced_wing += CZ_a2 * Std_Alpha * Std_Alpha;
+ CZiced_tail += CZ_a2 * Std_Alpha * Std_Alpha;
}
}
- CZ_a2_save = CZ_a2 * Alpha * Alpha;
+ CZ_a2_save = CZ_a2 * Std_Alpha * Std_Alpha;
CZ += CZ_a2_save;
break;
}
CZ_a3 = uiuc_ice_filter(CZ_a3_clean,kCZ_a3);
if (beta_model)
{
- CZclean_wing += CZ_a3_clean * Alpha * Alpha * Alpha;
- CZclean_tail += CZ_a3_clean * Alpha * Alpha * Alpha;
- CZiced_wing += CZ_a3 * Alpha * Alpha * Alpha;
- CZiced_tail += CZ_a3 * Alpha * Alpha * Alpha;
+ CZclean_wing += CZ_a3_clean * Std_Alpha * Std_Alpha * Std_Alpha;
+ CZclean_tail += CZ_a3_clean * Std_Alpha * Std_Alpha * Std_Alpha;
+ CZiced_wing += CZ_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
+ CZiced_tail += CZ_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
}
}
- CZ_a3_save = CZ_a3 * Alpha * Alpha * Alpha;
+ CZ_a3_save = CZ_a3 * Std_Alpha * Std_Alpha * Std_Alpha;
CZ += CZ_a3_save;
break;
}
CZ_adot = uiuc_ice_filter(CZ_adot_clean,kCZ_adot);
if (beta_model)
{
- CZclean_wing += CZ_adot_clean * Alpha_dot * cbar_2U;
- CZclean_tail += CZ_adot_clean * Alpha_dot * ch_2U;
- CZiced_wing += CZ_adot * Alpha_dot * cbar_2U;
- CZiced_tail += CZ_adot * Alpha_dot * ch_2U;
+ CZclean_wing += CZ_adot_clean * Std_Alpha_dot * cbar_2U;
+ CZclean_tail += CZ_adot_clean * Std_Alpha_dot * ch_2U;
+ CZiced_wing += CZ_adot * Std_Alpha_dot * cbar_2U;
+ CZiced_tail += CZ_adot * Std_Alpha_dot * ch_2U;
}
}
/* CZ_adot must be mulitplied by cbar/2U
(see Roskam Control book, Part 1, pg. 147) */
- CZ_adot_save = CZ_adot * Alpha_dot * cbar_2U;
+ CZ_adot_save = CZ_adot * Std_Alpha_dot * cbar_2U;
CZ += CZ_adot_save;
break;
}
CZ_deb2 = uiuc_ice_filter(CZ_deb2_clean,kCZ_deb2);
if (beta_model)
{
- CZclean_wing += CZ_deb2_clean * elevator * Beta * Beta;
- CZclean_tail += CZ_deb2_clean * elevator * Beta * Beta;
- CZiced_wing += CZ_deb2 * elevator * Beta * Beta;
- CZiced_tail += CZ_deb2 * elevator * Beta * Beta;
+ CZclean_wing += CZ_deb2_clean * elevator * Std_Beta * Std_Beta;
+ CZclean_tail += CZ_deb2_clean * elevator * Std_Beta * Std_Beta;
+ CZiced_wing += CZ_deb2 * elevator * Std_Beta * Std_Beta;
+ CZiced_tail += CZ_deb2 * elevator * Std_Beta * Std_Beta;
}
}
- CZ_deb2_save = CZ_deb2 * elevator * Beta * Beta;
+ CZ_deb2_save = CZ_deb2 * elevator * Std_Beta * Std_Beta;
CZ += CZ_deb2_save;
break;
}
CZ_adf = uiuc_ice_filter(CZ_adf_clean,kCZ_adf);
if (beta_model)
{
- CZclean_wing += CZ_adf_clean * Alpha * flap_pos;
- CZclean_tail += CZ_adf_clean * Alpha * flap_pos;
- CZiced_wing += CZ_adf * Alpha * flap_pos;
- CZiced_tail += CZ_adf * Alpha * flap_pos;
+ CZclean_wing += CZ_adf_clean * Std_Alpha * flap_pos;
+ CZclean_tail += CZ_adf_clean * Std_Alpha * flap_pos;
+ CZiced_wing += CZ_adf * Std_Alpha * flap_pos;
+ CZiced_tail += CZ_adf * Std_Alpha * flap_pos;
}
}
- CZ_adf_save = CZ_adf * Alpha * flap_pos;
+ CZ_adf_save = CZ_adf * Std_Alpha * flap_pos;
CZ += CZ_adf_save;
break;
}
CZfaI = uiuc_1Dinterpolation(CZfa_aArray,
CZfa_CZArray,
CZfa_nAlpha,
- Alpha);
+ Std_Alpha);
CZ += CZfaI;
break;
}
CZfabetaf_nb_nice,
CZfabetaf_nf,
flap_pos,
- Alpha,
- Beta);
+ Std_Alpha,
+ Std_Beta);
else
CZfabetafI = uiuc_3Dinterpolation(CZfabetaf_fArray,
CZfabetaf_aArray,
CZfabetaf_nbeta,
CZfabetaf_nf,
flap_pos,
- Alpha,
- Beta);
+ Std_Alpha,
+ Std_Beta);
CZ += CZfabetafI;
break;
}
CZfadef_nde_nice,
CZfadef_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
elevator);
else
CZfadefI = uiuc_3Dinterpolation(CZfadef_fArray,
CZfadef_nde,
CZfadef_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
elevator);
CZ += CZfadefI;
break;
CZfaqf_nq_nice,
CZfaqf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
q_nondim);
else
CZfaqfI = uiuc_3Dinterpolation(CZfaqf_fArray,
CZfaqf_nq,
CZfaqf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
q_nondim);
CZ += CZfaqfI;
break;
{
Cm_a = uiuc_ice_filter(Cm_a_clean,kCm_a);
}
- Cm_a_save = Cm_a * Alpha;
+ Cm_a_save = Cm_a * Std_Alpha;
Cm += Cm_a_save;
break;
}
{
Cm_a2 = uiuc_ice_filter(Cm_a2_clean,kCm_a2);
}
- Cm_a2_save = Cm_a2 * Alpha * Alpha;
+ Cm_a2_save = Cm_a2 * Std_Alpha * Std_Alpha;
Cm += Cm_a2_save;
break;
}
}
/* Cm_adot must be mulitplied by cbar/2U
(see Roskam Control book, Part 1, pg. 147) */
- Cm_adot_save = Cm_adot * Alpha_dot * cbar_2U;
+ Cm_adot_save = Cm_adot * Std_Alpha_dot * cbar_2U;
if (eta_q_Cm_adot_fac)
{
Cm += Cm_adot_save * eta_q_Cm_adot_fac;
{
Cm_b2 = uiuc_ice_filter(Cm_b2_clean,kCm_b2);
}
- Cm_b2_save = Cm_b2 * Beta * Beta;
+ Cm_b2_save = Cm_b2 * Std_Beta * Std_Beta;
Cm += Cm_b2_save;
break;
}
CmfaI = uiuc_1Dinterpolation(Cmfa_aArray,
Cmfa_CmArray,
Cmfa_nAlpha,
- Alpha);
+ Std_Alpha);
Cm += CmfaI;
break;
}
case 100:
if (V_rel_wind < dyn_on_speed)
{
- alphaTail = Alpha;
+ alphaTail = Std_Alpha;
}
else
{
// printf("gammaWing = %.4f\n", (gammaWing));
downwash = downwashCoef * gammaWing;
downwashAngle = atan(downwash/V_rel_wind);
- alphaTail = Alpha - downwashAngle;
+ alphaTail = Std_Alpha - downwashAngle;
}
CmfadeI = uiuc_2Dinterpolation(Cmfade_aArray,
Cmfade_deArray,
Cmfade_CmArray,
Cmfade_nAlphaArray,
Cmfade_nde,
- Alpha,
+ Std_Alpha,
elevator);
}
if (eta_q_Cmfade_fac)
Cmfadf_CmArray,
Cmfadf_nAlphaArray,
Cmfadf_ndf,
- Alpha,
+ Std_Alpha,
flap_pos);
Cm += CmfadfI;
break;
Cmfabetaf_nb_nice,
Cmfabetaf_nf,
flap_pos,
- Alpha,
- Beta);
+ Std_Alpha,
+ Std_Beta);
else
CmfabetafI = uiuc_3Dinterpolation(Cmfabetaf_fArray,
Cmfabetaf_aArray,
Cmfabetaf_nbeta,
Cmfabetaf_nf,
flap_pos,
- Alpha,
- Beta);
+ Std_Alpha,
+ Std_Beta);
Cm += CmfabetafI;
break;
}
Cmfadef_nde_nice,
Cmfadef_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
elevator);
else
CmfadefI = uiuc_3Dinterpolation(Cmfadef_fArray,
Cmfadef_nde,
Cmfadef_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
elevator);
Cm += CmfadefI;
break;
Cmfaqf_nq_nice,
Cmfaqf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
q_nondim);
else
CmfaqfI = uiuc_3Dinterpolation(Cmfaqf_fArray,
Cmfaqf_nq,
Cmfaqf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
q_nondim);
Cm += CmfaqfI;
break;
{
Cl_beta = uiuc_ice_filter(Cl_beta_clean,kCl_beta);
}
- Cl_beta_save = Cl_beta * Beta;
+ Cl_beta_save = Cl_beta * Std_Beta;
if (eta_q_Cl_beta_fac)
{
Cl += Cl_beta_save * eta_q_Cl_beta_fac;
{
Cl_daa = uiuc_ice_filter(Cl_daa_clean,kCl_daa);
}
- Cl_daa_save = Cl_daa * aileron * Alpha;
+ Cl_daa_save = Cl_daa * aileron * Std_Alpha;
Cl += Cl_daa_save;
break;
}
Clfada_ClArray,
Clfada_nAlphaArray,
Clfada_nda,
- Alpha,
+ Std_Alpha,
aileron);
Cl += ClfadaI;
break;
Clfbetadr_ClArray,
Clfbetadr_nBetaArray,
Clfbetadr_ndr,
- Beta,
+ Std_Beta,
rudder);
Cl += ClfbetadrI;
break;
Clfabetaf_nb_nice,
Clfabetaf_nf,
flap_pos,
- Alpha,
- Beta);
+ Std_Alpha,
+ Std_Beta);
else
ClfabetafI = uiuc_3Dinterpolation(Clfabetaf_fArray,
Clfabetaf_aArray,
Clfabetaf_nbeta,
Clfabetaf_nf,
flap_pos,
- Alpha,
- Beta);
+ Std_Alpha,
+ Std_Beta);
Cl += ClfabetafI;
break;
}
Clfadaf_nda_nice,
Clfadaf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
aileron);
else
ClfadafI = uiuc_3Dinterpolation(Clfadaf_fArray,
Clfadaf_nda,
Clfadaf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
aileron);
Cl += ClfadafI;
break;
Clfadrf_ndr_nice,
Clfadrf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
rudder);
else
ClfadrfI = uiuc_3Dinterpolation(Clfadrf_fArray,
Clfadrf_ndr,
Clfadrf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
rudder);
Cl += ClfadrfI;
break;
Clfapf_np_nice,
Clfapf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
p_nondim);
else
ClfapfI = uiuc_3Dinterpolation(Clfapf_fArray,
Clfapf_np,
Clfapf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
p_nondim);
Cl += ClfapfI;
break;
Clfarf_nr_nice,
Clfarf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
r_nondim);
else
ClfarfI = uiuc_3Dinterpolation(Clfarf_fArray,
Clfarf_nr,
Clfarf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
r_nondim);
Cl += ClfarfI;
break;
{
CY_beta = uiuc_ice_filter(CY_beta_clean,kCY_beta);
}
- CY_beta_save = CY_beta * Beta;
+ CY_beta_save = CY_beta * Std_Beta;
if (eta_q_CY_beta_fac)
{
CY += CY_beta_save * eta_q_CY_beta_fac;
{
CY_dra = uiuc_ice_filter(CY_dra_clean,kCY_dra);
}
- CY_dra_save = CY_dra * rudder * Alpha;
+ CY_dra_save = CY_dra * rudder * Std_Alpha;
CY += CY_dra_save;
break;
}
{
CY_bdot = uiuc_ice_filter(CY_bdot_clean,kCY_bdot);
}
- CY_bdot_save = CY_bdot * Beta_dot * b_2U;
+ CY_bdot_save = CY_bdot * Std_Beta_dot * b_2U;
CY += CY_bdot_save;
break;
}
CYfada_CYArray,
CYfada_nAlphaArray,
CYfada_nda,
- Alpha,
+ Std_Alpha,
aileron);
CY += CYfadaI;
break;
CYfbetadr_CYArray,
CYfbetadr_nBetaArray,
CYfbetadr_ndr,
- Beta,
+ Std_Beta,
rudder);
CY += CYfbetadrI;
break;
CYfabetaf_nb_nice,
CYfabetaf_nf,
flap_pos,
- Alpha,
- Beta);
+ Std_Alpha,
+ Std_Beta);
else
CYfabetafI = uiuc_3Dinterpolation(CYfabetaf_fArray,
CYfabetaf_aArray,
CYfabetaf_nbeta,
CYfabetaf_nf,
flap_pos,
- Alpha,
- Beta);
+ Std_Alpha,
+ Std_Beta);
CY += CYfabetafI;
break;
}
CYfadaf_nda_nice,
CYfadaf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
aileron);
else
CYfadafI = uiuc_3Dinterpolation(CYfadaf_fArray,
CYfadaf_nda,
CYfadaf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
aileron);
CY += CYfadafI;
break;
CYfadrf_ndr_nice,
CYfadrf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
rudder);
else
CYfadrfI = uiuc_3Dinterpolation(CYfadrf_fArray,
CYfadrf_ndr,
CYfadrf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
rudder);
CY += CYfadrfI;
break;
CYfapf_np_nice,
CYfapf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
p_nondim);
else
CYfapfI = uiuc_3Dinterpolation(CYfapf_fArray,
CYfapf_np,
CYfapf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
p_nondim);
CY += CYfapfI;
break;
CYfarf_nr_nice,
CYfarf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
r_nondim);
else
CYfarfI = uiuc_3Dinterpolation(CYfarf_fArray,
CYfarf_nr,
CYfarf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
r_nondim);
CY += CYfarfI;
break;
{
Cn_beta = uiuc_ice_filter(Cn_beta_clean,kCn_beta);
}
- Cn_beta_save = Cn_beta * Beta;
+ Cn_beta_save = Cn_beta * Std_Beta;
if (eta_q_Cn_beta_fac)
{
Cn += Cn_beta_save * eta_q_Cn_beta_fac;
{
Cn_b3 = uiuc_ice_filter(Cn_b3_clean,kCn_b3);
}
- Cn_b3_save = Cn_b3 * Beta * Beta * Beta;
+ Cn_b3_save = Cn_b3 * Std_Beta * Std_Beta * Std_Beta;
Cn += Cn_b3_save;
break;
}
Cnfada_CnArray,
Cnfada_nAlphaArray,
Cnfada_nda,
- Alpha,
+ Std_Alpha,
aileron);
Cn += CnfadaI;
break;
Cnfbetadr_CnArray,
Cnfbetadr_nBetaArray,
Cnfbetadr_ndr,
- Beta,
+ Std_Beta,
rudder);
Cn += CnfbetadrI;
break;
Cnfabetaf_nb_nice,
Cnfabetaf_nf,
flap_pos,
- Alpha,
- Beta);
+ Std_Alpha,
+ Std_Beta);
else
CnfabetafI = uiuc_3Dinterpolation(Cnfabetaf_fArray,
Cnfabetaf_aArray,
Cnfabetaf_nbeta,
Cnfabetaf_nf,
flap_pos,
- Alpha,
- Beta);
+ Std_Alpha,
+ Std_Beta);
Cn += CnfabetafI;
break;
}
Cnfadaf_nda_nice,
Cnfadaf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
aileron);
else
CnfadafI = uiuc_3Dinterpolation(Cnfadaf_fArray,
Cnfadaf_nda,
Cnfadaf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
aileron);
Cn += CnfadafI;
break;
Cnfadrf_ndr_nice,
Cnfadrf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
rudder);
else
CnfadrfI = uiuc_3Dinterpolation(Cnfadrf_fArray,
Cnfadrf_ndr,
Cnfadrf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
rudder);
Cn += CnfadrfI;
break;
Cnfapf_np_nice,
Cnfapf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
p_nondim);
else
CnfapfI = uiuc_3Dinterpolation(Cnfapf_fArray,
Cnfapf_np,
Cnfapf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
p_nondim);
Cn += CnfapfI;
break;
Cnfarf_nr_nice,
Cnfarf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
r_nondim);
else
CnfarfI = uiuc_3Dinterpolation(Cnfarf_fArray,
Cnfarf_nr,
Cnfarf_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
r_nondim);
Cn += CnfarfI;
break;
Cnfada, and Cnfbetadr switches
04/15/2000 (JS) broke up into multiple
uiuc_coef_xxx functions
- 06/18/2001 (RD) Added initialization of Alpha and
- Beta. Added aileron_input and rudder_input.
+ 06/18/2001 (RD) Added initialization of Std_Alpha and
+ Std_Beta. Added aileron_input and rudder_input.
Added pilot_elev_no, pilot_ail_no, and
pilot_rud_no.
07/05/2001 (RD) Added pilot_(elev,ail,rud)_no=false
int ap_alh_init = 1;
if (Alpha_init_true && Simtime==0)
- Alpha = Alpha_init;
+ Std_Alpha = Alpha_init;
if (Beta_init_true && Simtime==0)
- Beta = Beta_init;
+ Std_Beta = Beta_init;
// calculate rate derivative nondimensionalization factors
// check if speed is sufficient to compute dynamic pressure terms
cbar_2U = cbar / (2.0 * V_rel_wind_dum);
b_2U = bw / (2.0 * V_rel_wind_dum);
ch_2U = ch / (2.0 * V_rel_wind_dum);
- Alpha_dot = 0.0;
+ Std_Alpha_dot = 0.0;
}
else
{
cbar_2U = 0.0;
b_2U = 0.0;
ch_2U = 0.0;
- Alpha_dot = 0.0;
+ Std_Alpha_dot = 0.0;
}
}
else if(use_abs_U_body_2U) // use absolute(U_body)
cbar_2U = cbar / (2.0 * U_body_dum);
b_2U = bw / (2.0 * U_body_dum);
ch_2U = ch / (2.0 * U_body_dum);
- Alpha_dot = 0.0;
+ Std_Alpha_dot = 0.0;
}
else
{
cbar_2U = 0.0;
b_2U = 0.0;
ch_2U = 0.0;
- Alpha_dot = 0.0;
+ Std_Alpha_dot = 0.0;
}
}
else // use U_body
cbar_2U = cbar / (2.0 * U_body_dum);
b_2U = bw / (2.0 * U_body_dum);
ch_2U = ch / (2.0 * U_body_dum);
- Alpha_dot = 0.0;
+ Std_Alpha_dot = 0.0;
beta_flow_clean_tail = cbar_2U;
}
else
cbar_2U = 0.0;
b_2U = 0.0;
ch_2U = 0.0;
- Alpha_dot = 0.0;
+ Std_Alpha_dot = 0.0;
}
}
- // check if speed is sufficient to "trust" Alpha_dot value
+ // check if speed is sufficient to "trust" Std_Alpha_dot value
if (use_Alpha_dot_on_speed)
{
if (V_rel_wind < Alpha_dot_on_speed)
- Alpha_dot = 0.0;
+ Std_Alpha_dot = 0.0;
}
tactilefadef_nde_nice,
tactilefadef_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
elevator);
else
tactilefadefI = uiuc_3Dinterpolation(tactilefadef_fArray,
tactilefadef_nde,
tactilefadef_nf,
flap_pos,
- Alpha,
+ Std_Alpha,
elevator);
}
else if (demo_tactile)
flapStruct flapper_struct;
//FlapStruct flapper_struct;
- flapper_alpha = Alpha*180/LS_PI;
+ flapper_alpha = Std_Alpha*180/LS_PI;
flapper_V = V_rel_wind;
flapper_freq = 0.8 + 0.45*Throttle_pct;
flapper_Inertia=flapper_struct.getInertia();
flapper_Moment=flapper_struct.getMoment();
- F_Z_aero_flapper = -1*flapper_Lift*cos(Alpha) - flapper_Thrust*sin(Alpha);
+ F_Z_aero_flapper = -1*flapper_Lift*cos(Std_Alpha) - flapper_Thrust*sin(Std_Alpha);
F_Z_aero_flapper -= flapper_Inertia;
- F_X_aero_flapper = -1*flapper_Lift*sin(Alpha) + flapper_Thrust*cos(Alpha);
+ F_X_aero_flapper = -1*flapper_Lift*sin(Std_Alpha) + flapper_Thrust*cos(Std_Alpha);
}
- alpha = Alpha*RAD_TO_DEG;
+ alpha = Std_Alpha*RAD_TO_DEG;
de = elevator*RAD_TO_DEG;
// lift fits
if (alpha < 16)
/************************ Angles ***********************/
case Alpha_record:
{
- fout << Alpha << " ";
+ fout << Std_Alpha << " ";
break;
}
case Alpha_deg_record:
{
- fout << Alpha * RAD_TO_DEG << " ";
+ fout << Std_Alpha * RAD_TO_DEG << " ";
break;
}
case Alpha_dot_record:
{
- fout << Alpha_dot << " ";
+ fout << Std_Alpha_dot << " ";
break;
}
case Alpha_dot_deg_record:
{
- fout << Alpha_dot * RAD_TO_DEG << " ";
+ fout << Std_Alpha_dot * RAD_TO_DEG << " ";
break;
}
case Beta_record:
{
- fout << Beta << " ";
+ fout << Std_Beta << " ";
break;
}
case Beta_deg_record:
{
- fout << Beta * RAD_TO_DEG << " ";
+ fout << Std_Beta * RAD_TO_DEG << " ";
break;
}
case Beta_dot_record:
{
- fout << Beta_dot << " ";
+ fout << Std_Beta_dot << " ";
break;
}
case Beta_dot_deg_record:
{
- fout << Beta_dot * RAD_TO_DEG << " ";
+ fout << Std_Beta_dot * RAD_TO_DEG << " ";
break;
}
case Gamma_vert_record:
projects / flightgear.git / commitdiff