Struct TimeDump 

pub struct TimeDump<S = MemorySink> { /* private fields */ }

Time-domain field dump operator: samples a FieldSampler on a Schedule and passes each Snapshot to a DumpSink. See the module docs for when states are sampled.

The default sink is a MemorySink; read it back with Engine::operator(&handle).sink().

Implementations

impl TimeDump<MemorySink>

pub fn new(sampler: FieldSampler) -> Self

In-memory dump of every state (change with schedule).

pub fn write_vtr(&self, dir: impl AsRef<Path>, basename: &str) -> Result<()>

Writes all recorded snapshots as <dir>/<basename>_<step>.vtr plus <dir>/<basename>.pvd (creating dir), like VtrSeries.

impl<S: DumpSink> TimeDump<S>

pub fn with_sink(sampler: FieldSampler, sink: S) -> Self

Dump of every state into sink.

pub fn schedule(self, schedule: Schedule) -> Self

Sets the schedule (default: every step).

pub fn window(self, start: f64, stop: f64) -> Self

Records only states whose quantity time t (FieldSampler::time) satisfies start ≤ t ≤ stop [s]; stop ≤ 0 means no upper limit (the csx StartTime / StopTime convention). The schedule is evaluated only inside the window. Default: no window.

pub fn sampler(&self) -> &FieldSampler

The sampler.

pub fn sink(&self) -> &S

The sink.

pub fn sink_mut(&mut self) -> &mut S

Mutable access to the sink (e.g. MemorySink::take).

pub fn error(&self) -> Option<&Error>

The first sink error, after which the dump stopped.

Trait Implementations

impl<S: Debug> Debug for TimeDump<S>

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

Formats the value using the given formatter.

impl<S: DumpSink> Operator for TimeDump<S>

fn pre_h(&mut self, fields: &mut Fields<'_>, ctx: &StepContext<'_>)

Before the H update of step ctx.step.

fn post_e(&mut self, fields: &mut Fields<'_>, ctx: &StepContext<'_>)

After the E update (u is at ctx.e_time()).

fn post_h(&mut self, _fields: &mut Fields<'_>, _ctx: &StepContext<'_>)

After the H update (i is at ctx.h_time()).

fn pre_e(&mut self, _fields: &mut Fields<'_>, _ctx: &StepContext<'_>)

Before the E update.

fn hooks(&self) -> Hooks

The serial hooks this operator implements (default Hooks::ALL). Queried once, at registration; undeclared hooks are never called. Declaring fewer hooks only saves time: an operator whose hooks are all empty may return Hooks::NONE.

fn slab_hooks( &mut self, _partition: &SlabPartition<'_>, ) -> Option<Arc<dyn SlabHooks>>

Slab-parallel work for the engine’s x-slab partition (default none). Called once, at registration; the returned object is run by the worker threads (see SlabHooks). The operator may keep a clone of the Arc to read results back.

fn energy(&self) -> f64

Energy [J] held in the operator’s own state at t = n·dt, the time of the E voltages after n completed steps (default 0).