Struct Banked3 

pub struct Banked3 {
    pub base: Elevated3,
    pub cant: CantLaw,
    pub pivot: CantLaw,
    pub rail_head_distance: f64,
    pub convention: BankConvention,
}

A centreline with a roll law: the composition a canted track is authored as. See the module docs.

Evaluated by PLAN distance d, like its base. The point is base(d) + pivot(d) z; the section frame is rolled about that point’s own unit tangent by the angle convention gives. The curve’s span is the cant law’s: no station outside it has a section.

Fields

base: Elevated3

Centreline: plan and vertical profile.

cant: CantLaw

Cant D(d) (left rail head above right), or bank angle, by piece.

pivot: CantLaw

Elevation e(d) of the rotation point above the profile: height pieces, or held-rail pieces derived from the cant (CantForm::AboutRail). No angle pieces.

rail_head_distance: f64

Rail-head distance b, from which psi = asin(D / b).

convention: BankConvention

Which height difference D states on a grade.

Implementations

impl Banked3

pub const fn new( base: Elevated3, cant: CantLaw, pivot: CantLaw, rail_head_distance: f64, convention: BankConvention, ) -> Banked3

Pair a centreline with cant and pivot laws under a named convention.

pub fn span(&self) -> f64

Plan length the curve is defined over: the cant law’s.

pub fn cant_at(&self, distance: f64) -> Result<f64, BankError>

Cant D at distance: the law’s height, or b sin(psi) for an angle piece.

Errors

BankError::OutsideLaw off the law, BankError::RailHeadDistance for a bad b, and the angle checks of bank_angle_at.

pub fn bank_angle_at(&self, distance: f64) -> Result<f64, BankError>

Nominal bank angle psi = asin(D / b) at distance; an angle piece gives it directly.

Errors

BankError::CantExceedsRailHeadDistance when |D| > b, BankError::AngleOutOfRange for an angle piece beyond a quarter turn, BankError::OutsideLaw off the law.

pub fn cant_rate_at(&self, distance: f64) -> Result<f64, BankError>

Rate of the cant dD/dd per unit plan distance at distance: the law’s, or b cos(psi) psi' for an angle piece.

Errors

As cant_at.

pub fn pivot_at(&self, distance: f64) -> Result<(f64, f64), BankError>

Elevation e of the rotation point above the profile at distance, and its rate per unit plan distance.

A held-rail piece (CantForm::AboutRail) derives both from the cant law: e = e0 + s D / 2 and e' = s D' / 2, which for an angle piece are e0 + s (b / 2) sin(psi) and s (b / 2) cos(psi) psi'.

Errors

BankError::AngleInPivot for a pivot law with an angle piece, BankError::OutsideLaw off the law; for a held-rail piece, the cant law’s refusals at distance (cant_at).

Trait Implementations

impl Clone for Banked3

fn clone(&self) -> Banked3

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Banked3

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Banked3

fn deserialize<__D>( __deserializer: __D, ) -> Result<Banked3, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Banked3

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Banked3

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Banked3