Struct TrainState 

pub struct TrainState {

    pub time: TrackedState<Time>,
    pub i: TrackedState<usize>,
    pub offset: TrackedState<Length>,
    pub offset_back: TrackedState<Length>,
    pub total_dist: TrackedState<Length>,
    pub link_idx_front: TrackedState<u32>,
    pub link_idx_back: TrackedState<u32>,
    pub offset_in_link: TrackedState<Length>,
    pub speed: TrackedState<Velocity>,
    pub speed_limit: TrackedState<Velocity>,
    pub speed_target: TrackedState<Velocity>,
    pub dt: TrackedState<Time>,
    pub length: TrackedState<Length>,
    pub mass_static: TrackedState<Mass>,
    pub mass_rot: TrackedState<Mass>,
    pub mass_freight: TrackedState<Mass>,
    pub weight_static: TrackedState<Force>,
    pub res_rolling: TrackedState<Force>,
    pub res_bearing: TrackedState<Force>,
    pub res_davis_b: TrackedState<Force>,
    pub res_aero: TrackedState<Force>,
    pub res_grade: TrackedState<Force>,
    pub res_curve: TrackedState<Force>,
    pub grade_front: TrackedState<Ratio>,
    pub grade_back: TrackedState<Ratio>,
    pub elev_front: TrackedState<Length>,
    pub elev_back: TrackedState<Length>,
    pub pwr_res: TrackedState<Power>,
    pub pwr_accel: TrackedState<Power>,
    pub pwr_whl_out: TrackedState<Power>,
    pub energy_whl_out: TrackedState<Energy>,
    pub energy_whl_out_pos: TrackedState<Energy>,
    pub energy_whl_out_neg: TrackedState<Energy>,
}

Fields

time: TrackedState<Time>

time since user-defined datum

i: TrackedState<usize>

index for time steps

offset: TrackedState<Length>

Linear-along-track, directional distance of front of train from original starting position of back of train.

If this is provided in InitTrainState::new, it gets set as the train length or the value, whichever is larger, and if it is not provided, then it defaults to the train length.

offset_back: TrackedState<Length>

Linear-along-track, directional distance of back of train from original starting position of back of train.

total_dist: TrackedState<Length>

Linear-along-track, cumulative, absolute distance from initial starting position.

link_idx_front: TrackedState<u32>

Current link containing head end (i.e. pulling locomotives) of train

link_idx_back: TrackedState<u32>

Current link containing tail/back end of train

offset_in_link: TrackedState<Length>

Offset from start of current link

speed: TrackedState<Velocity>

Achieved speed based on consist capabilities and train resistance

speed_limit: TrackedState<Velocity>

Speed limit

speed_target: TrackedState<Velocity>

Speed target from meet-pass planner

dt: TrackedState<Time>

Time step size

length: TrackedState<Length>

Train length

mass_static: TrackedState<Mass>

Static mass of train, including freight

mass_rot: TrackedState<Mass>

Effective additional mass of train due to rotational inertia

mass_freight: TrackedState<Mass>

Mass of freight being hauled by the train (not including railcar empty weight)

weight_static: TrackedState<Force>

Static weight of train

res_rolling: TrackedState<Force>

Rolling resistance force

res_bearing: TrackedState<Force>

Bearing resistance force

res_davis_b: TrackedState<Force>

Davis B term resistance force

res_aero: TrackedState<Force>

Aerodynamic resistance force

res_grade: TrackedState<Force>

Grade resistance force

res_curve: TrackedState<Force>

Curvature resistance force

grade_front: TrackedState<Ratio>

Grade at front of train

grade_back: TrackedState<Ratio>

Grade at back of train of train if strap method is used

elev_front: TrackedState<Length>

Elevation at front of train

elev_back: TrackedState<Length>

Elevation at back of train

pwr_res: TrackedState<Power>

Power to overcome train resistance forces

pwr_accel: TrackedState<Power>

Power to overcome inertial forces

pwr_whl_out: TrackedState<Power>

Total tractive power exerted by locomotive consist

energy_whl_out: TrackedState<Energy>

Integral of Self::pwr_whl_out

energy_whl_out_pos: TrackedState<Energy>

Energy out during positive or zero traction

energy_whl_out_neg: TrackedState<Energy>

Energy out during negative traction (positive value means negative traction)

Implementations

impl TrainState

pub fn new( length: Length, mass_static: Mass, mass_rot: Mass, mass_freight: Mass, init_train_state: Option<InitTrainState>, ) -> Self

pub fn res_net(&self) -> Result<Force>

pub fn mass_compound(&self) -> Result<Mass>

All base, freight, and rotational mass

Trait Implementations

impl CheckAndResetState for TrainState

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

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

impl Clone for TrainState

fn clone(&self) -> TrainState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TrainState

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

Formats the value using the given formatter.

impl Default for TrainState

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TrainState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Init for TrainState

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 TrainState

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

Static mass of train, not including effective rotational 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 ObjState for TrainState

fn validate(&self) -> ValidationResults

fn is_fake(&self) -> bool

impl PartialEq for TrainState

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

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

Implementation for objects without save_interval

impl SerdeAPI for TrainState

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

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

const RESOURCES_SUBDIR: &'static str = ""

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

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 altrios-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<()>

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<()>

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

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 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_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 TrainState

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 TrainState

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

Sets cumulative values based on rate values

impl Step for TrainState

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

Increments i field of this and all contained structs, recursively

impl Valid for TrainState

fn valid() -> Self

impl StateMethods for TrainState

impl StructuralPartialEq for TrainState