Struct fastsim_core::simdrive::RustSimDriveParams

pub struct RustSimDriveParams {

    pub favor_grade_accuracy: bool,
    pub missed_trace_correction: bool,
    pub max_time_dilation: f64,
    pub min_time_dilation: f64,
    pub time_dilation_tol: f64,
    pub max_trace_miss_iters: u32,
    pub trace_miss_speed_mps_tol: f64,
    pub trace_miss_time_tol: f64,
    pub trace_miss_dist_tol: f64,
    pub sim_count_max: usize,
    pub newton_gain: f64,
    pub newton_max_iter: u32,
    pub newton_xtol: f64,
    pub energy_audit_error_tol: f64,
    pub coast_allow: bool,
    pub coast_allow_passing: bool,
    pub coast_max_speed_m_per_s: f64,
    pub coast_brake_accel_m_per_s2: f64,
    pub coast_brake_start_speed_m_per_s: f64,
    pub coast_start_speed_m_per_s: f64,
    pub coast_time_horizon_for_adjustment_s: f64,
    pub idm_allow: bool,
    pub idm_v_desired_m_per_s: f64,
    pub idm_dt_headway_s: f64,
    pub idm_minimum_gap_m: f64,
    pub idm_delta: f64,
    pub idm_accel_m_per_s2: f64,
    pub idm_decel_m_per_s2: f64,
    pub idm_v_desired_in_m_per_s_by_distance_m: Option<Vec<(f64, f64)>>,
    pub max_epa_adj: f64,
    pub orphaned: bool,
}

Struct containing time trace data

Fields

favor_grade_accuracy: bool

if true, accuracy will be favored over performance for grade per step estimates Specifically, for performance, grade for a step will be assumed to be the grade looked up at step start distance. For accuracy, the actual elevations will be used. This distinciton only makes a difference for CAV maneuvers.

missed_trace_correction: bool

if true, missed trace correction is active, default = False. If missed trace correction is active, time step will be “dilated” to be long enough for vehicle to “catch up” with trace.

max_time_dilation: f64

maximum time dilation factor to “catch up” with trace – e.g. 1.0 means 100% increase in step size

min_time_dilation: f64

minimum time dilation margin to let trace “catch up” – e.g. -0.5 means 50% reduction in step size

time_dilation_tol: f64

convergence criteria for time dilation in iterating on time step size to achieve distance parity

max_trace_miss_iters: u32

number of iterations to achieve time dilation correction

trace_miss_speed_mps_tol: f64

threshold for triggering warning log message if vehicle speed deficit [m/s] relative to prescribed speed exceeds this amount

trace_miss_time_tol: f64

threshold for triggering warning log message if achieved elapsed time relative to prescribed elapsed time exceeds this fractional amount

trace_miss_dist_tol: f64

threshold for triggering warning log message if achieved distance relative to prescribed distance exceeds this fractional amount

sim_count_max: usize

max allowable number of HEV SOC iterations

newton_gain: f64

newton solver gain

newton_max_iter: u32

newton solver max iterations

newton_xtol: f64

newton solver tolerance

energy_audit_error_tol: f64

tolerance for energy audit error warning, i.e. 0.1%

coast_allow: bool

if true, coasting to stops are allowed

coast_allow_passing: bool

if true, coasting vehicle can eclipse the shadow trace (i.e., reference vehicle in front)

coast_max_speed_m_per_s: f64

maximum allowable speed under coast (m/s)

coast_brake_accel_m_per_s2: f64

acceleration assumed during braking for coast maneuvers (m/s2). note: should be negative

coast_brake_start_speed_m_per_s: f64

speed when friction braking will initiate during coasting maneuvers (m/s)

coast_start_speed_m_per_s: f64

initiates coast when vehicle hits this speed if > 0; this is mainly for forceing coasting to initiate for testing. (m/s)

coast_time_horizon_for_adjustment_s: f64

“look-ahead” time for speed changes to be considered to feature coasting to hit a given stopping distance mark (s)

idm_allow: bool

if true, initiates the IDM - Intelligent Driver Model, Adaptive Cruise Control version

idm_v_desired_m_per_s: f64

IDM algorithm: desired speed (m/s)

idm_dt_headway_s: f64

IDM algorithm: headway time desired to vehicle in front (s)

idm_minimum_gap_m: f64

IDM algorithm: minimum desired gap between vehicle and lead vehicle (m)

idm_delta: f64

IDM algorithm: delta parameter

idm_accel_m_per_s2: f64

IDM algorithm: acceleration parameter

idm_decel_m_per_s2: f64

IDM algorithm: deceleration parameter

idm_v_desired_in_m_per_s_by_distance_m: Option<Vec<(f64, f64)>>

IDM algorithm: a way to specify desired speed by course distance traveled. Can simulate changing speed limits over a driving cycle optional list of (distance (m), desired speed (m/s))

max_epa_adj: f64

EPA fuel economy adjustment parameters; maximum EPA adjustment factor

orphaned: bool

Trait Implementations

impl Clone for RustSimDriveParams

fn clone(&self) -> RustSimDriveParams

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RustSimDriveParams

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

Formats the value using the given formatter.

impl Default for RustSimDriveParams

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RustSimDriveParams

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RustSimDriveParams

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

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

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

const RESOURCE_PREFIX: &'static str = ""

const CACHE_FOLDER: &'static str = ""

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

Specialized code to execute upon initialization

fn list_resources() -> Vec<String>

List available (compiled) resources (stored in the rust binary)

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

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

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 to_writer<W: Write>(&self, wtr: W, format: &str) -> Result<()>

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

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

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: R, format: &str, skip_init: bool) -> Result<Self>

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 to a JSON 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

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

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

fn from_url<S: AsRef<str>>(url: S, skip_init: bool) -> Result<Self>

Instantiates an object from a url. Accepts yaml and json file types

fn to_cache<P: AsRef<Path>>(&self, file_path: P) -> Result<()>

Takes an instantiated Rust object and saves it in the FASTSim data directory in a rust_objects folder.
WARNING: If there is a file already in the data subdirectory with the same name, it will be replaced by the new file.

fn from_cache<P: AsRef<Path>>(file_path: P, skip_init: bool) -> Result<Self>

Instantiates a Rust object from the subdirectory within the FASTSim data directory corresponding to the Rust Object (“vehices” for a RustVehice, “cycles” for a RustCycle, and the root folder of the data directory for all other objects).

impl Serialize for RustSimDriveParams

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 RustSimDriveParams