stroemung 0.1.2

A Computational Fluid Dynamics (CFD) simulator in Rust
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use crate::cell::{BoundaryCell, Cell};
use crate::grid::{SimulationGrid, UnfinalizedSimulationGrid};
use crate::math::Real;
use crate::types::GridSize;
use ndarray::{Array, Ix2};

/// Generate an empty simulation grid
pub fn empty(size: GridSize) -> SimulationGrid {
    SimulationGrid::try_from(UnfinalizedSimulationGrid {
        size,
        pressure: Array::zeros(size),
        u: Array::zeros(size),
        v: Array::zeros(size),
        cell_type: Array::from_elem(size, Cell::Fluid),
    })
    .unwrap()
}

pub fn simple_inflow(size: GridSize) -> SimulationGrid {
    let mut cell_array = Array::from_elem(size, Cell::Fluid);
    for x in 0..size[0] {
        cell_array[(x, 0)] = Cell::Boundary(BoundaryCell::NoSlip);
        cell_array[(x, size[1] - 1)] = Cell::Boundary(BoundaryCell::NoSlip);
    }
    for y in 1..(size[1] - 1) {
        cell_array[(0, y)] = Cell::Boundary(BoundaryCell::Inflow {
            velocity: [1.0, 0.0],
        });
        cell_array[(size[0] - 1, y)] = Cell::Boundary(BoundaryCell::Outflow);
    }

    SimulationGrid::try_from(UnfinalizedSimulationGrid {
        size,
        pressure: Array::zeros(size),
        u: Array::zeros(size),
        v: Array::zeros(size),
        cell_type: cell_array,
    })
    .unwrap()
}

fn draw_circle(cell_array: &mut Array<Cell, Ix2>, x: usize, y: usize, radius: Real) {
    let (x_size, y_size) = cell_array.dim();
    for xi in (x.saturating_sub(radius as usize))..(x.saturating_add(radius as usize)) {
        if xi >= x_size {
            continue;
        }
        let x_dist = xi as i32 - x as i32;
        for yi in (y.saturating_sub(radius as usize))..(y.saturating_add(radius as usize))
        {
            if yi >= y_size {
                continue;
            }
            let y_dist = yi as i32 - y as i32;
            let distance = ((x_dist * x_dist + y_dist * y_dist) as f64).sqrt();

            if distance < radius {
                cell_array[(xi, yi)] = Cell::Boundary(BoundaryCell::NoSlip);
            }
        }
    }
}

pub fn obstacle(size: GridSize) -> SimulationGrid {
    let mut cell_array = Array::from_elem(size, Cell::Fluid);
    for x in 0..size[0] {
        cell_array[(x, 0)] = Cell::Boundary(BoundaryCell::NoSlip);
        cell_array[(x, size[1] - 1)] = Cell::Boundary(BoundaryCell::NoSlip);
    }
    for y in 1..(size[1] - 1) {
        cell_array[(0, y)] = Cell::Boundary(BoundaryCell::Inflow {
            velocity: [1.0, 0.0],
        });
        cell_array[(size[0] - 1, y)] = Cell::Boundary(BoundaryCell::Outflow);
    }

    draw_circle(&mut cell_array, 20, size[1] / 2, 5.0);

    SimulationGrid::try_from(UnfinalizedSimulationGrid {
        size,
        pressure: Array::zeros(size),
        u: Array::zeros(size),
        v: Array::zeros(size),
        cell_type: cell_array,
    })
    .unwrap()
}