rdbench 0.1.0

Reaction-diffusion simulation based on Gray-Scott model.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

use mpi::traits::Communicator;

use crate::{
    args::{Args, IoField},
    io::{self, IOStrategy},
    model::{FieldType, GrayScott},
    Result,
};

pub struct Driver<'a> {
    model: GrayScott,
    io_strategy: Box<dyn IOStrategy>,
    args: &'a Args,
}

impl<'a> Driver<'a> {
    pub fn new(model: GrayScott, args: &'a Args) -> Result<Self> {
        let io_strategy = io::create_io_strategy(args, &model.domain)?;
        Ok(Self {
            model,
            io_strategy,
            args,
        })
    }

    pub fn run(&mut self) -> Result<()> {
        let mut ckpt_idx = 0;
        let steps = self.args.steps;
        let interval = self.args.interval;

        if self.args.init_output {
            self.ckpt(ckpt_idx, 0)?;
            ckpt_idx += 1;
        }

        for step in 1..=steps {
            self.model.step();

            if interval != 0 && step % interval == 0 {
                self.ckpt(ckpt_idx, step)?;
                ckpt_idx += 1;
            }
        }

        Ok(())
    }

    fn ckpt(&self, idx: usize, step: usize) -> Result<()> {
        let comm = &self.model.cart_comm;

        if self.args.io_field.should_io_u() {
            self.model
                .checkpoint(&*self.io_strategy, idx, FieldType::U)?;
        }
        if self.args.io_field.should_io_v() {
            self.model
                .checkpoint(&*self.io_strategy, idx, FieldType::V)?;
        }

        if self.args.verbose && comm.rank() == 0 {
            if self.args.io_field != IoField::None {
                println!("Step: {}, Checkpoint: {}", step, idx);
            }
        }

        Ok(())
    }
}