mantaray 0.2.0

Ray-tracing solver for ocean surface gravity waves that integrates the wave ray equations over spatially varying currents and bathymetry.
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

//! Functions for creating Netcdf3 bathymetry and current files.
//!
//! Note that for the 2d array for depth or velocity, we use `y` variable to
//! represent the row and `x` variable to represent the column.

use std::path::Path;

#[allow(dead_code)]
/// Create a NetCDF3 Bathymetry File
///
/// # Arguments
/// `path` : `&Path` a reference to the path where the file will be created
///
/// `x_num` : `usize` the number of points in the x direction
///
/// `y_num` : `usize` the number of points in the y direction
///
/// `x_step` : `f32` the step size distance between points in the x direction
///
/// `y_step` : `f32` the step size distance between points in the y direction
///
/// `depth_fn` : `fn(f32,f32) -> f64` a function that maps each (x,y) input to
/// the depth, h, at that point.
/// 
/// # Example
/// Create a bathymetry file with a constant depth of 100 m and save to `path`.
///
/// create_netcdf3_bathymetry(&path, 10, 10, 100.0, 100.0, |_, _| 100.0)
pub(crate) fn create_netcdf3_bathymetry(
    path: &Path,
    x_num: usize,
    y_num: usize,
    x_step: f32,
    y_step: f32,
    depth_fn: fn(f32, f32) -> f64,
) {
    let x_data: Vec<f32> = (0..x_num).map(|x| x as f32 * x_step).collect();
    let y_data: Vec<f32> = (0..y_num).map(|y| y as f32 * y_step).collect();

    let mut depth_data: Vec<f64> = Vec::new();
    for y in &y_data {
        for x in &x_data {
            depth_data.push(depth_fn(*x, *y));
        }
    }

    // most below copied from the docs
    use netcdf3::{DataSet, FileWriter, Version};
    let y_dim_name: &str = "y";
    let y_var_name: &str = y_dim_name;
    let y_var_len: usize = y_num;

    let x_dim_name: &str = "x";
    let x_var_name: &str = x_dim_name;
    let x_var_len: usize = x_num;

    let depth_var_name: &str = "depth";
    let depth_var_len: usize = depth_data.len();

    // Create the NetCDF-3 definition
    // ------------------------------
    let data_set: DataSet = {
        let mut data_set: DataSet = DataSet::new();
        // Define the dimensions
        data_set.add_fixed_dim(y_dim_name, y_var_len).unwrap();
        data_set.add_fixed_dim(x_dim_name, x_var_len).unwrap();
        // Define the variable
        data_set.add_var_f32(y_var_name, &[y_dim_name]).unwrap();
        data_set.add_var_f32(x_var_name, &[x_var_name]).unwrap();
        data_set
            .add_var_f64(depth_var_name, &[y_dim_name, x_var_name])
            .unwrap();

        data_set
    };

    // Create and write the NetCDF-3 file
    // ----------------------------------
    let mut file_writer: FileWriter = FileWriter::open(path).unwrap();
    // Set the NetCDF-3 definition
    file_writer.set_def(&data_set, Version::Classic, 0).unwrap();
    assert_eq!(depth_var_len, x_var_len * y_var_len);
    file_writer.write_var_f32(y_var_name, &y_data[..]).unwrap();
    file_writer.write_var_f32(x_var_name, &x_data[..]).unwrap();
    file_writer
        .write_var_f64(depth_var_name, &depth_data[..])
        .unwrap();
    file_writer.close().unwrap();
    // end of copied from docs
}

#[allow(dead_code)]
/// Create a NetCDF3 current snapshot (no time)
///
/// # Arguments
/// `path` : `&Path` a reference to the path where the file will be created
///
/// `x_num` : `usize` the number of points in the x direction
///
/// `y_num` : `usize` the number of points in the y direction
///
/// `x_step` : `f32` the step size distance between points in the x direction
///
/// `y_step` : `f32` the step size distance between points in the y direction
///
/// `current_fn` : `fn(f32,f32)->(f64,f64)` a function thatr maps each (x,y)
/// input to the current (u,v) at that point.
pub(crate) fn create_netcdf3_current(
    path: &Path,
    x_num: usize,
    y_num: usize,
    x_step: f32,
    y_step: f32,
    current_fn: fn(f32, f32) -> (f64, f64),
) {
    let x_data: Vec<f32> = (0..x_num).map(|x| x as f32 * x_step).collect();
    let y_data: Vec<f32> = (0..y_num).map(|y| y as f32 * y_step).collect();

    let mut u_data: Vec<f64> = Vec::new();
    let mut v_data: Vec<f64> = Vec::new();

    for y in &y_data {
        for x in &x_data {
            let (u, v) = current_fn(*x, *y);
            u_data.push(u);
            v_data.push(v);
        }
    }

    // most below copied from the docs
    use netcdf3::{DataSet, FileWriter, Version};
    let y_dim_name: &str = "y";
    let y_var_name: &str = y_dim_name;
    let y_var_len: usize = y_num;

    let x_dim_name: &str = "x";
    let x_var_name: &str = x_dim_name;
    let x_var_len: usize = x_num;

    let u_dim_name: &str = "u";
    let u_var_name: &str = u_dim_name;
    let u_var_len: usize = u_data.len();

    let v_dim_name: &str = "v";
    let v_var_name: &str = v_dim_name;
    let v_var_len: usize = v_data.len();

    // Create the NetCDF-3 definition
    // ------------------------------
    assert_eq!(u_var_len, y_var_len * x_var_len);
    assert_eq!(v_var_len, y_var_len * x_var_len);
    let data_set: DataSet = {
        let mut data_set: DataSet = DataSet::new();
        // Define the dimensions
        data_set.add_fixed_dim(y_dim_name, y_var_len).unwrap();
        data_set.add_fixed_dim(x_dim_name, x_var_len).unwrap();
        // Define the variable
        data_set.add_var_f32(y_var_name, &[y_dim_name]).unwrap();
        data_set.add_var_f32(x_var_name, &[x_var_name]).unwrap();
        data_set
            .add_var_f64(u_var_name, &[y_dim_name, x_var_name])
            .unwrap();
        data_set
            .add_var_f64(v_var_name, &[y_dim_name, x_var_name])
            .unwrap();

        data_set
    };

    // Create and write the NetCDF-3 file
    // ----------------------------------
    let mut file_writer: FileWriter = FileWriter::open(path).unwrap();
    // Set the NetCDF-3 definition
    file_writer.set_def(&data_set, Version::Classic, 0).unwrap();
    file_writer.write_var_f32(y_var_name, &y_data[..]).unwrap();
    file_writer.write_var_f32(x_var_name, &x_data[..]).unwrap();
    file_writer.write_var_f64(u_var_name, &u_data[..]).unwrap();
    file_writer.write_var_f64(v_var_name, &v_data[..]).unwrap();
    file_writer.close().unwrap();
    // end of copied from docs
}