Struct ReductionTurns 

#[non_exhaustive]
pub struct ReductionTurns {
    pub crossing_rad: f64,
    pub crossing_residual_p0: f64,
    pub balance_rad: f64,
    pub balance_residual_p0_per_m: f64,
    pub crossing_loading_gap_per_rad: f64,
}

The two turns that bound where the second-order method’s exponential form does not hold at a corner behind a body (flare_reduction_turns_rad).

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

crossing_rad: f64

The turn whose pressure just behind the corner lands exactly on its tangent cone’s, p₂ = p_c. η has a pole here, because eq. 9 divides by that gap.

crossing_residual_p0: f64

What the crossing’s solution left behind: p₂ − p_c there, in units of the free stream’s pressure. Read it before trusting the turn. How small it can be made is the tangent cone’s accuracy, not the solver’s: below SLENDER_CONE_RAD the cone flow is slender-cone theory’s closed form and this closes to the last bits of an f64, while above it the cone flow is an integration and what is left is that integration’s own.

balance_rad: f64

The turn whose own compression exactly cancels the pressure gradient the body ahead delivers to the corner, (∂p/∂s)₂ = 0 (TN 3527 eq. 4). η is zero here, so the method is already the generalized one.

balance_residual_p0_per_m: f64

What the balance’s solution left behind: (∂p/∂s)₂ there, p₀ per m of axial distance.

crossing_loading_gap_per_rad: f64

Λ₂ − Λ_c at Self::crossing_rad, per radian of angle of attack: the whole size of the step the crossing leaves, before it is integrated over the element that holds it.

At the crossing η has a pole, and the two sides of it take the two constants eq. 19 relaxes between: the side the method still owns sheds the corner’s loading onto its tangent cone’s at once (Λ_c = tan δ₂ (dC_N/dα)_tc), and the reduced side holds the corner’s (Λ₂ = (λ₂/λ₁) Λ₁). Both are constant along a conical flare, so eq. 19’s C_Nα = (2π/A_ref) ∫ Λ r dx integrates a constant and the step in the body’s slope is

ΔC_Nα = (2π/A_ref) (Λ₂ − Λ_c) · ½(r_fore + r_aft) · L

for a flare of length L between those radii. It is exact, not a sample, and the one number a reader needs to work out what the crossing costs on their own body (ADR-050).

Trait Implementations

impl Clone for ReductionTurns

fn clone(&self) -> ReductionTurns

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ReductionTurns

impl Debug for ReductionTurns

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReductionTurns

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ReductionTurns

fn eq(&self, other: &ReductionTurns) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ReductionTurns

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ReductionTurns