Struct Chassis 

#[non_exhaustive]
pub struct Chassis {

    pub drag_coef: Ratio,
    pub frontal_area: Area,
    pub wheel_rr_coef: Ratio,
    pub wheel_inertia: MomentOfInertia,
    pub num_wheels: u8,
    pub wheel_radius: Option<Length>,
    pub tire_code: Option<String>,
    pub cg_height: Length,
    pub wheel_fric_coef: Ratio,
    pub drive_type: DriveTypes,
    pub drive_axle_weight_frac: Ratio,
    pub wheel_base: Length,
    pub cargo_mass: Option<Mass>,
    /* private fields */
}

Struct for simulating vehicle

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.

drag_coef: Ratio

Aerodynamic drag coefficient

frontal_area: Area

Projected frontal area for drag calculations

wheel_rr_coef: Ratio

Wheel rolling resistance coefficient for the vehicle (i.e. all wheels included)

wheel_inertia: MomentOfInertia

Wheel inertia per wheel

num_wheels: u8

Number of wheels

wheel_radius: Option<Length>

Wheel radius

tire_code: Option<String>

Tire code (optional method of calculating wheel radius)

cg_height: Length

Vehicle center of mass height

wheel_fric_coef: Ratio

Wheel coefficient of friction

drive_type: DriveTypes

Drive wheel configuration

drive_axle_weight_frac: Ratio

Fraction of vehicle weight on drive action when stationary

wheel_base: Length

Wheel base length

cargo_mass: Option<Mass>

Cargo mass including passengers

Trait Implementations

impl Clone for Chassis

fn clone(&self) -> Chassis

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Chassis

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Chassis

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Init for Chassis

fn init(&mut self) -> Result<(), Error>

Specialized code to execute upon initialization. For any struct with fields that implement Init, this should propagate down the hierarchy.

impl Mass for Chassis

fn mass(&self) -> Result<Option<Mass>>

Returns mass of Self, either from self.mass or the derived from fields that store mass data. Mass::mass also checks that derived mass, if Some, is same as self.mass.

fn set_mass( &mut self, new_mass: Option<Mass>, _side_effect: MassSideEffect, ) -> Result<()>

Sets component mass to mass, or if None is provided for mass, sets mass based on other component parameters (e.g. power and power density, sum of fields containing mass)

fn derived_mass(&self) -> Result<Option<Mass>>

Returns derived mass (e.g. sum of mass fields, or calculation involving mass specific properties). If

fn expunge_mass_fields(&mut self)

Sets all fields that are used in calculating derived mass to None. Does not touch self.mass.

fn set_mass_specific_property(&mut self) -> Result<()>

Sets any mass-specific property with appropriate side effects

impl PartialEq for Chassis

fn eq(&self, other: &Chassis) -> 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 SerdeAPI for Chassis

const ACCEPTED_BYTE_FORMATS: &'static [&'static str] = _

const ACCEPTED_STR_FORMATS: &'static [&'static str] = _

const RESOURCES_DIR: &'static Dir<'_> = _

const RESOURCES_SUBDIR: &'static str = ""

fn from_resource<P: AsRef<Path>>( filepath: P, skip_init: bool, ) -> Result<Self, Error>

Read (deserialize) an object from a resource file packaged with the fastsim-core crate

fn list_resources() -> Result<Vec<PathBuf>, Error>

List the available resources in the resources directory

fn to_file<P: AsRef<Path>>(&self, filepath: P) -> Result<(), Error>

Write (serialize) an object to a file. Supported file extensions are listed in ACCEPTED_BYTE_FORMATS. Creates a new file if it does not already exist, otherwise truncates the existing file.

fn from_file<P: AsRef<Path>>( filepath: P, skip_init: bool, ) -> Result<Self, Error>

Read (deserialize) an object from a file. Supported file extensions are listed in ACCEPTED_BYTE_FORMATS.

fn to_writer<W: Write>(&self, wtr: W, format: &str) -> Result<(), Error>

Write (serialize) an object into anything that implements std::io::Write

fn from_reader<R: Read>( rdr: &mut R, format: &str, skip_init: bool, ) -> Result<Self, Error>

Deserialize an object from anything that implements std::io::Read

fn to_str(&self, format: &str) -> Result<String>

Write (serialize) an object into a string

fn from_str<S: AsRef<str>>( contents: S, format: &str, skip_init: bool, ) -> Result<Self>

Read (deserialize) an object from a string

fn to_json(&self) -> Result<String>

Write (serialize) an object to a JSON string

fn from_json<S: AsRef<str>>(json_str: S, skip_init: bool) -> Result<Self>

Read (deserialize) an object from a JSON string

fn to_msg_pack(&self) -> Result<Vec<u8>>

Write (serialize) an object to a message pack

fn from_msg_pack(msg_pack: &[u8], skip_init: bool) -> Result<Self>

Read (deserialize) an object from a message pack

fn to_toml(&self) -> Result<String>

Write (serialize) an object to a TOML string

fn from_toml<S: AsRef<str>>(toml_str: S, skip_init: bool) -> Result<Self>

Read (deserialize) an object from a TOML string

fn to_yaml(&self) -> Result<String>

Write (serialize) an object to a YAML string

fn from_yaml<S: AsRef<str>>(yaml_str: S, skip_init: bool) -> Result<Self>

Read (deserialize) an object from a YAML string

impl Serialize for Chassis

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&RustVehicle> for Chassis

type Error = Error

The type returned in the event of a conversion error.

fn try_from(f2veh: &RustVehicle) -> Result<Self>

Performs the conversion.

impl StructuralPartialEq for Chassis