Struct Simulator

pub struct Simulator<M: AbstractSimulator> { /* private fields */ }

A DEVS simulator that uses a virtual clock (i.e., no real time is used).

Implementations

impl<M: AbstractSimulator> Simulator<M>

pub const fn new(model: M) -> Self

Examples found in repository

examples/gpt.rs (line 244)

fn main() {
    let period = 1.;
    let proc_time = 1.1;
    let obs_time = 10.;

    let generator = generator::Generator::new(generator::GeneratorState::new(period));
    let processor = processor::Processor::new(processor::ProcessorState::new(proc_time));
    let transducer = transducer::Transducer::new(transducer::TransducerState::new(obs_time));

    let ef = EF::new(generator, transducer);
    let efp = EFP::new(ef, processor);

    let mut simulator = xdevs::simulator::Simulator::new(efp);
    simulator.simulate_rt(
        0.0,
        14.0,
        xdevs::simulator::std::sleep(0.0, 1.0, None),
        |_| {},
    );
}

pub fn simulate_rt( &mut self, t_start: f64, t_stop: f64, wait_until: impl FnMut(f64, &mut M::Input) -> f64, propagate_output: impl FnMut(&M::Output), )

It executes the simulation of the inner DEVS model from t_start to t_stop. It provides support for real time execution via the following arguments:

• wait_until: a closure that is called between state transitions. It receives the time of the next state transition and a mutable reference to the input ports. It returns the actual time “waited”. If the returned time is equal to the input time, an internal/confluent state transition is performed. Otherwise, it assumes that an external event happened and executes the external transition function.
• propagate_output: a closure that is called after output functions. It receives a mutable reference to the output ports so the closure can access to output events. Feel free to ignore this argument if you do not need to propagate output messages.

Examples found in repository

examples/gpt.rs (lines 245-250)

fn main() {
    let period = 1.;
    let proc_time = 1.1;
    let obs_time = 10.;

    let generator = generator::Generator::new(generator::GeneratorState::new(period));
    let processor = processor::Processor::new(processor::ProcessorState::new(proc_time));
    let transducer = transducer::Transducer::new(transducer::TransducerState::new(obs_time));

    let ef = EF::new(generator, transducer);
    let efp = EFP::new(ef, processor);

    let mut simulator = xdevs::simulator::Simulator::new(efp);
    simulator.simulate_rt(
        0.0,
        14.0,
        xdevs::simulator::std::sleep(0.0, 1.0, None),
        |_| {},
    );
}

pub fn simulate_vt(&mut self, t_start: f64, t_stop: f64)

It executes the simulation of the inner DEVS model from t_start to t_stop. It uses a virtual clock (i.e., no real time is used).