Struct ConventionalVehicle 

#[non_exhaustive]
pub struct ConventionalVehicle {
    pub fs: FuelStorage,
    pub fc: FuelConverter,
    pub transmission: Transmission,
    pub alt_eff: Ratio,
    /* private fields */
}

Conventional vehicle with only a FuelConverter as a power source

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.

fs: FuelStorage

fc: FuelConverter

transmission: Transmission

alt_eff: Ratio

Alternator efficiency used to calculate aux mechanical power demand on engine

Implementations

impl ConventionalVehicle

pub fn solve_thermal( &mut self, te_amb: Temperature, pwr_thrml_fc_to_cab: Option<Power>, veh_state: &mut VehicleState, dt: Time, ) -> Result<()>

Trait Implementations

impl Clone for ConventionalVehicle

fn clone(&self) -> ConventionalVehicle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConventionalVehicle

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ConventionalVehicle

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl HistoryMethods for ConventionalVehicle

fn save_interval(&self) -> Result<Option<usize>>

Returns save interval for self but does not guarantee recursive consistency in nested objects

fn set_save_interval(&mut self, save_interval: Option<usize>) -> Result<()>

Recursively sets save interval

fn clear(&mut self)

Remove all history

impl Init for ConventionalVehicle

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 ConventionalVehicle

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 ConventionalVehicle

fn eq(&self, other: &ConventionalVehicle) -> 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 Powertrain for Box<ConventionalVehicle>

fn set_curr_pwr_prop_out_max( &mut self, _pwr_upstream: (Power, Power), pwr_aux: Power, dt: Time, _veh_state: &VehicleState, ) -> Result<()>

Sets maximum possible positive and negative propulsion-related powers this component/system can produce, accounting for any aux-related power required.

fn get_curr_pwr_prop_out_max(&self) -> Result<(Power, Power)>

Returns maximum achievable positive and negative propulsion powers after Powertrain::set_curr_pwr_prop_out_max has been called.

fn solve( &mut self, pwr_out_req: Power, _enabled: bool, dt: Time, ) -> Result<Option<Power>>

Solves for this powertrain system/component efficiency and sets/returns power output values.

fn pwr_regen(&self) -> Result<Power>

Returns regen power after Powertrain::solve has been called

impl SaveState for ConventionalVehicle

fn save_state<F: Fn() -> String>(&mut self, loc: F) -> Result<()>

Implementation for objects without save_interval

impl SerdeAPI for ConventionalVehicle

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 ConventionalVehicle

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SetCumulative for ConventionalVehicle

fn set_cumulative<F: Fn() -> String>(&mut self, dt: Time, loc: F) -> Result<()>

Sets cumulative values based on rate values

fn reset_cumulative<F: Fn() -> String>(&mut self, loc: F) -> Result<()>

Resets cumulative and corresponding rate values to zero

impl Step for ConventionalVehicle

fn step<F: Fn() -> String>(&mut self, loc: F) -> Result<()>

Increments i field of this and all contained structs, recursively

fn reset_step<F: Fn() -> String>(&mut self, loc: F) -> Result<()>

Resets i field of this and all contained structs, recursively

impl TrackedStateMethods for ConventionalVehicle

fn check_and_reset<F: Fn() -> String>(&mut self, loc: F) -> Result<()>

Ensure [State::Fresh] and reset to [State::Stale]

fn mark_fresh<F: Fn() -> String>(&mut self, loc: F) -> Result<()>

Mark states as [State::Fresh]

impl TryFrom<&RustVehicle> for ConventionalVehicle

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<PowertrainType> for Box<ConventionalVehicle>

type Error = TryIntoError<PowertrainType>

The type returned in the event of a conversion error.

fn try_from(value: PowertrainType) -> Result<Self, Self::Error>

Performs the conversion.

impl StateMethods for ConventionalVehicle

impl StructuralPartialEq for ConventionalVehicle