Struct FixedStepsize 

pub struct FixedStepsize<F> { /* private fields */ }

Time stepping with a fixed time length

This time-stepper increments the time variable by the same length.

let t0 = 1.0;
let dt = 0.2;
let partial_save_points = vec![3.0, 5.0, 11.0, 20.0];
let time_stepper = FixedStepsize::from_partial_save_points(t0, dt, partial_save_points).unwrap();

Implementations

impl<F> FixedStepsize<F>

where F: Float + ToPrimitive + FromPrimitive,

pub fn from_partial_save_steps( t0: F, dt: F, n_steps: u64, save_interval: u64, ) -> Result<Self, TimeError>

Construct the stepper from initial time, increment, number of steps and save interval

pub fn from_partial_save_interval( t0: F, dt: F, t_max: F, save_interval: F, ) -> Result<Self, TimeError>

Similar to Self::from_partial_save_points but specify the time step between every save point together with the integration step.

pub fn from_partial_save_freq( t0: F, dt: F, t_max: F, save_freq: usize, ) -> Result<Self, TimeError>

Similar to Self::from_partial_save_interval but specify a multiple of the time increment instead of a floating point value. This method is preferred over the one previously mentioned.

pub fn from_partial_save_points( t0: F, dt: F, partial_save_points: Vec<F>, ) -> Result<Self, TimeError>

Simple function to construct the stepper from an initial time point, the time increment and the time points at which the simulation should be saved. Notice that these saves do not cover FullSaves but only PartialSaves.

Trait Implementations

impl<F: Clone> Clone for FixedStepsize<F>

fn clone(&self) -> FixedStepsize<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'de, F> Deserialize<'de> for FixedStepsize<F>

where F: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F> Serialize for FixedStepsize<F>

where F: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<F> TimeStepper<F> for FixedStepsize<F>

where F: Float + FromPrimitive,

fn advance(&mut self) -> Result<Option<NextTimePoint<F>>, TimeError>

Advances the time stepper to the next time point. Also returns if there is an event scheduled to take place and the next time value and iteration number

fn save_initial(&self) -> Option<NextTimePoint<F>>

Indicates if the initial values should be stored

fn get_last_full_save(&self) -> Option<(F, usize)>

Retrieved the last point at which the simulation was fully recovered. This might be helpful in the future when error handling is more mature and able to recover.

fn initialize_bar(&self, title: Option<&str>) -> Result<Bar, TimeError>

Creates a bar that tracks the simulation progress

fn update_bar(&self, bar: &mut Bar) -> Result<(), Error>

Update a given bar to show the current simulation state