YAC 3.14.0
Yet Another Coupler
Loading...
Searching...
No Matches
generate_cubed_sphere.c
Go to the documentation of this file.
1// Copyright (c) 2024 The YAC Authors
2//
3// SPDX-License-Identifier: BSD-3-Clause
4
5#include <stdio.h>
6#include <stdlib.h>
7#include <math.h>
8#include <limits.h>
9
10#include "generate_cubed_sphere.h"
11#include "generate_reg2d.h"
12#include "geometry.h"
13#include "ppm/ppm_xfuncs.h"
14
15#ifdef YAC_NETCDF_ENABLED
16#include "io_utils.h"
17#include <netcdf.h>
18#endif
19
20void yac_generate_cubed_sphere_grid_information(
21 unsigned n, unsigned * num_cells, unsigned * num_vertices,
22 double ** x_vertices, double ** y_vertices, double ** z_vertices,
23 unsigned ** cell_to_vertex, unsigned ** face_id) {
24
25 YAC_ASSERT((n >= 1) && (n <= 40000), "invalid number of linear subdivisions")
26
27 *num_cells = n * n * 6;
28 *num_vertices = *num_cells + 2;
29
30 // allocation of output variables
31 *x_vertices = xmalloc(*num_vertices * sizeof(**x_vertices));
32 *y_vertices = xmalloc(*num_vertices * sizeof(**y_vertices));
33 *z_vertices = xmalloc(*num_vertices * sizeof(**z_vertices));
34
35 *cell_to_vertex = xmalloc(*num_cells * 4 * sizeof(**cell_to_vertex));
36
37 *face_id = xmalloc(*num_cells * sizeof(**face_id));
38
39 // allocation of temporary coordinate variables
40 unsigned num_edge_coords = n - 1;
41 double * cube_edge_x_vertices = xmalloc(12 * num_edge_coords * sizeof(*cube_edge_x_vertices));
42 double * cube_edge_y_vertices = xmalloc(12 * num_edge_coords * sizeof(*cube_edge_y_vertices));
43 double * cube_edge_z_vertices = xmalloc(12 * num_edge_coords * sizeof(*cube_edge_z_vertices));
44
45 unsigned num_inner_coords = num_edge_coords * num_edge_coords;
46 double * cube_inner_x_vertices = xmalloc(num_inner_coords * sizeof(*cube_inner_x_vertices));
47 double * cube_inner_y_vertices = xmalloc(num_inner_coords * sizeof(*cube_inner_y_vertices));
48 double * cube_inner_z_vertices = xmalloc(num_inner_coords * sizeof(*cube_inner_z_vertices));
49
50 double * temp_x_vertices = xmalloc((n + 1) * (n + 1) * sizeof(*temp_x_vertices));
51 double * temp_y_vertices = xmalloc((n + 1) * (n + 1) * sizeof(*temp_y_vertices));
52 double * temp_z_vertices = xmalloc((n + 1) * (n + 1) * sizeof(*temp_z_vertices));
53
54 {
55 double * theta = xmalloc((n + 1) * sizeof(*theta));
56
57 {
58 double d = (M_PI_2 / (double)n);
59 for (unsigned i = 0; i < n + 1; ++i)
60 theta[i] = tan(- M_PI_4 + d * (double)i);
61 }
62
63 for (unsigned i = 0; i < n + 1; ++i) {
64 for (unsigned j = 0; j < n + 1; ++j) {
65
66 double scale =
67 sqrt(1.0 / (theta[i] * theta[i] + theta[j] * theta[j] + 1.0));
68
69 temp_x_vertices[i * (n + 1) + j] = theta[j] * scale;
70 temp_y_vertices[i * (n + 1) + j] = theta[i] * scale;
71 temp_z_vertices[i * (n + 1) + j] = - scale;
72 }
73 }
74 free(theta);
75 }
76
77 // Store the coordinates for the 4 vertices on face 1
78 (*x_vertices)[0] = temp_x_vertices[ 0 * (n + 1) + 0];
79 (*y_vertices)[0] = temp_y_vertices[ 0 * (n + 1) + 0];
80 (*z_vertices)[0] = temp_z_vertices[ 0 * (n + 1) + 0];
81 (*x_vertices)[1] = temp_x_vertices[ n * (n + 1) + 0];
82 (*y_vertices)[1] = temp_y_vertices[ n * (n + 1) + 0];
83 (*z_vertices)[1] = temp_z_vertices[ n * (n + 1) + 0];
84 (*x_vertices)[2] = temp_x_vertices[ 0 * (n + 1) + n];
85 (*y_vertices)[2] = temp_y_vertices[ 0 * (n + 1) + n];
86 (*z_vertices)[2] = temp_z_vertices[ 0 * (n + 1) + n];
87 (*x_vertices)[3] = temp_x_vertices[ n * (n + 1) + n];
88 (*y_vertices)[3] = temp_y_vertices[ n * (n + 1) + n];
89 (*z_vertices)[3] = temp_z_vertices[ n * (n + 1) + n];
90 // Store the coordinates for the 4 vertices on face 2
91 (*x_vertices)[4] = temp_x_vertices[ 0 * (n + 1) + 0];
92 (*y_vertices)[4] = temp_y_vertices[ 0 * (n + 1) + 0];
93 (*z_vertices)[4] = -temp_z_vertices[ 0 * (n + 1) + 0];
94 (*x_vertices)[5] = temp_x_vertices[ n * (n + 1) + 0];
95 (*y_vertices)[5] = temp_y_vertices[ n * (n + 1) + 0];
96 (*z_vertices)[5] = -temp_z_vertices[ n * (n + 1) + 0];
97 (*x_vertices)[6] = temp_x_vertices[ 0 * (n + 1) + n];
98 (*y_vertices)[6] = temp_y_vertices[ 0 * (n + 1) + n];
99 (*z_vertices)[6] = -temp_z_vertices[ 0 * (n + 1) + n];
100 (*x_vertices)[7] = temp_x_vertices[ n * (n + 1) + n];
101 (*y_vertices)[7] = temp_y_vertices[ n * (n + 1) + n];
102 (*z_vertices)[7] = -temp_z_vertices[ n * (n + 1) + n];
103
104 // Store the coordinates for the edges
105 for (unsigned i = 0; i < num_edge_coords; ++i) {
106 cube_edge_x_vertices[ 0 * num_edge_coords + i] = temp_x_vertices[(1 + i) * (n + 1) + 0];
107 cube_edge_y_vertices[ 0 * num_edge_coords + i] = temp_y_vertices[(1 + i) * (n + 1) + 0];
108 cube_edge_z_vertices[ 0 * num_edge_coords + i] = temp_z_vertices[(1 + i) * (n + 1) + 0];
109 cube_edge_x_vertices[ 1 * num_edge_coords + i] = temp_x_vertices[0 * (n + 1) + (1 + i)];
110 cube_edge_y_vertices[ 1 * num_edge_coords + i] = temp_y_vertices[0 * (n + 1) + (1 + i)];
111 cube_edge_z_vertices[ 1 * num_edge_coords + i] = temp_z_vertices[0 * (n + 1) + (1 + i)];
112 cube_edge_x_vertices[ 2 * num_edge_coords + i] = temp_x_vertices[n * (n + 1) + (1 + i)];
113 cube_edge_y_vertices[ 2 * num_edge_coords + i] = temp_y_vertices[n * (n + 1) + (1 + i)];
114 cube_edge_z_vertices[ 2 * num_edge_coords + i] = temp_z_vertices[n * (n + 1) + (1 + i)];
115 cube_edge_x_vertices[ 3 * num_edge_coords + i] = temp_x_vertices[(1 + i) * (n + 1) + n];
116 cube_edge_y_vertices[ 3 * num_edge_coords + i] = temp_y_vertices[(1 + i) * (n + 1) + n];
117 cube_edge_z_vertices[ 3 * num_edge_coords + i] = temp_z_vertices[(1 + i) * (n + 1) + n];
118 cube_edge_x_vertices[ 4 * num_edge_coords + i] = temp_x_vertices[(1 + i) * (n + 1) + 0];
119 cube_edge_y_vertices[ 4 * num_edge_coords + i] = temp_y_vertices[(1 + i) * (n + 1) + 0];
120 cube_edge_z_vertices[ 4 * num_edge_coords + i] = -temp_z_vertices[(1 + i) * (n + 1) + 0];
121 cube_edge_x_vertices[ 5 * num_edge_coords + i] = temp_x_vertices[0 * (n + 1) + (1 + i)];
122 cube_edge_y_vertices[ 5 * num_edge_coords + i] = temp_y_vertices[0 * (n + 1) + (1 + i)];
123 cube_edge_z_vertices[ 5 * num_edge_coords + i] = -temp_z_vertices[0 * (n + 1) + (1 + i)];
124 cube_edge_x_vertices[ 6 * num_edge_coords + i] = temp_x_vertices[n * (n + 1) + (1 + i)];
125 cube_edge_y_vertices[ 6 * num_edge_coords + i] = temp_y_vertices[n * (n + 1) + (1 + i)];
126 cube_edge_z_vertices[ 6 * num_edge_coords + i] = -temp_z_vertices[n * (n + 1) + (1 + i)];
127 cube_edge_x_vertices[ 7 * num_edge_coords + i] = temp_x_vertices[(1 + i) * (n + 1) + n];
128 cube_edge_y_vertices[ 7 * num_edge_coords + i] = temp_y_vertices[(1 + i) * (n + 1) + n];
129 cube_edge_z_vertices[ 7 * num_edge_coords + i] = -temp_z_vertices[(1 + i) * (n + 1) + n];
130 cube_edge_x_vertices[ 8 * num_edge_coords + i] = temp_z_vertices[0 * (n + 1) + (1 + i)];
131 cube_edge_y_vertices[ 8 * num_edge_coords + i] = temp_y_vertices[0 * (n + 1) + (1 + i)];
132 cube_edge_z_vertices[ 8 * num_edge_coords + i] = temp_x_vertices[0 * (n + 1) + (1 + i)];
133 cube_edge_x_vertices[ 9 * num_edge_coords + i] = temp_z_vertices[n * (n + 1) + (1 + i)];
134 cube_edge_y_vertices[ 9 * num_edge_coords + i] = temp_y_vertices[n * (n + 1) + (1 + i)];
135 cube_edge_z_vertices[ 9 * num_edge_coords + i] = temp_x_vertices[n * (n + 1) + (1 + i)];
136 cube_edge_x_vertices[10 * num_edge_coords + i] = -temp_z_vertices[0 * (n + 1) + (1 + i)];
137 cube_edge_y_vertices[10 * num_edge_coords + i] = temp_y_vertices[0 * (n + 1) + (1 + i)];
138 cube_edge_z_vertices[10 * num_edge_coords + i] = temp_x_vertices[0 * (n + 1) + (1 + i)];
139 cube_edge_x_vertices[11 * num_edge_coords + i] = -temp_z_vertices[n * (n + 1) + (1 + i)];
140 cube_edge_y_vertices[11 * num_edge_coords + i] = temp_y_vertices[n * (n + 1) + (1 + i)];
141 cube_edge_z_vertices[11 * num_edge_coords + i] = temp_x_vertices[n * (n + 1) + (1 + i)];
142 }
143
144 // Move the 12 edges to the final vertices array
145 unsigned Estart = 9 - 1;
146 unsigned Eend = Estart + 12 * num_edge_coords;
147 for (unsigned i = 0; i < 12 * num_edge_coords; ++i) {
148 (*x_vertices)[i + Estart] = cube_edge_x_vertices[i];
149 (*y_vertices)[i + Estart] = cube_edge_y_vertices[i];
150 (*z_vertices)[i + Estart] = cube_edge_z_vertices[i];
151 }
152
153 free(cube_edge_x_vertices);
154 free(cube_edge_y_vertices);
155 free(cube_edge_z_vertices);
156
157 // store the internal vertices for face 1
158 for (unsigned i = 0; i < num_edge_coords; ++i) {
159 for (unsigned j = 0; j < num_edge_coords; ++j) {
160
161 cube_inner_x_vertices[i * num_edge_coords + j] = temp_x_vertices[(1 + i) * (n + 1) + (1 + j)];
162 cube_inner_y_vertices[i * num_edge_coords + j] = temp_y_vertices[(1 + i) * (n + 1) + (1 + j)];
163 cube_inner_z_vertices[i * num_edge_coords + j] = temp_z_vertices[(1 + i) * (n + 1) + (1 + j)];
164 }
165 }
166
167 // Move face 1 to final Vertices array
168 unsigned Fstart = Eend;
169 for (unsigned i = 0; i < num_inner_coords; ++i) {
170 (*x_vertices)[i + Fstart] = cube_inner_x_vertices[i];
171 (*y_vertices)[i + Fstart] = cube_inner_y_vertices[i];
172 (*z_vertices)[i + Fstart] = cube_inner_z_vertices[i];
173 }
174
175 // store the internal vertices for face 2
176 for (unsigned i = 0; i < num_edge_coords; ++i) {
177 for (unsigned j = 0; j < num_edge_coords; ++j) {
178
179 cube_inner_x_vertices[i * num_edge_coords + j] = temp_x_vertices[(1 + i) * (n + 1) + (1 + j)];
180 cube_inner_y_vertices[i * num_edge_coords + j] = temp_y_vertices[(1 + i) * (n + 1) + (1 + j)];
181 cube_inner_z_vertices[i * num_edge_coords + j] = -temp_z_vertices[(1 + i) * (n + 1) + (1 + j)];
182 }
183 }
184
185 // Move face 2 to final Vertices array
186 Fstart += num_inner_coords;
187 for (unsigned i = 0; i < num_inner_coords; ++i) {
188 (*x_vertices)[i + Fstart] = cube_inner_x_vertices[i];
189 (*y_vertices)[i + Fstart] = cube_inner_y_vertices[i];
190 (*z_vertices)[i + Fstart] = cube_inner_z_vertices[i];
191 }
192
193 // store the internal vertices for face 3
194 for (unsigned i = 0; i < num_edge_coords; ++i) {
195 for (unsigned j = 0; j < num_edge_coords; ++j) {
196
197 cube_inner_x_vertices[i * num_edge_coords + j] = temp_z_vertices[(1 + i) * (n + 1) + (1 + j)];
198 cube_inner_y_vertices[i * num_edge_coords + j] = temp_y_vertices[(1 + i) * (n + 1) + (1 + j)];
199 cube_inner_z_vertices[i * num_edge_coords + j] = temp_x_vertices[(1 + i) * (n + 1) + (1 + j)];
200 }
201 }
202
203 // Move face 3 to final Vertices array
204 Fstart += num_inner_coords;
205 for (unsigned i = 0; i < num_inner_coords; ++i) {
206 (*x_vertices)[i + Fstart] = cube_inner_x_vertices[i];
207 (*y_vertices)[i + Fstart] = cube_inner_y_vertices[i];
208 (*z_vertices)[i + Fstart] = cube_inner_z_vertices[i];
209 }
210
211 // store the internal vertices for face 4
212 for (unsigned i = 0; i < num_edge_coords; ++i) {
213 for (unsigned j = 0; j < num_edge_coords; ++j) {
214
215 cube_inner_x_vertices[i * num_edge_coords + j] = -temp_z_vertices[(1 + i) * (n + 1) + (1 + j)];
216 cube_inner_y_vertices[i * num_edge_coords + j] = temp_y_vertices[(1 + i) * (n + 1) + (1 + j)];
217 cube_inner_z_vertices[i * num_edge_coords + j] = temp_x_vertices[(1 + i) * (n + 1) + (1 + j)];
218 }
219 }
220
221 // Move face 4 to final Vertices array
222 Fstart += num_inner_coords;
223 for (unsigned i = 0; i < num_inner_coords; ++i) {
224 (*x_vertices)[i + Fstart] = cube_inner_x_vertices[i];
225 (*y_vertices)[i + Fstart] = cube_inner_y_vertices[i];
226 (*z_vertices)[i + Fstart] = cube_inner_z_vertices[i];
227 }
228
229 // store the internal vertices for face 5
230 for (unsigned i = 0; i < num_edge_coords; ++i) {
231 for (unsigned j = 0; j < num_edge_coords; ++j) {
232
233 cube_inner_x_vertices[i * num_edge_coords + j] = temp_x_vertices[(1 + i) * (n + 1) + (1 + j)];
234 cube_inner_y_vertices[i * num_edge_coords + j] = temp_z_vertices[(1 + i) * (n + 1) + (1 + j)];
235 cube_inner_z_vertices[i * num_edge_coords + j] = temp_y_vertices[(1 + i) * (n + 1) + (1 + j)];
236 }
237 }
238
239 // Move face 5 to final Vertices array
240 Fstart += num_inner_coords;
241 for (unsigned i = 0; i < num_inner_coords; ++i) {
242 (*x_vertices)[i + Fstart] = cube_inner_x_vertices[i];
243 (*y_vertices)[i + Fstart] = cube_inner_y_vertices[i];
244 (*z_vertices)[i + Fstart] = cube_inner_z_vertices[i];
245 }
246
247 // store the internal vertices for face 6
248 for (unsigned i = 0; i < num_edge_coords; ++i) {
249 for (unsigned j = 0; j < num_edge_coords; ++j) {
250
251 cube_inner_x_vertices[i * num_edge_coords + j] = temp_x_vertices[(1 + i) * (n + 1) + (1 + j)];
252 cube_inner_y_vertices[i * num_edge_coords + j] = -temp_z_vertices[(1 + i) * (n + 1) + (1 + j)];
253 cube_inner_z_vertices[i * num_edge_coords + j] = temp_y_vertices[(1 + i) * (n + 1) + (1 + j)];
254 }
255 }
256
257 // Move face 6 to final Vertices array
258 Fstart += num_inner_coords;
259 for (unsigned i = 0; i < num_inner_coords; ++i) {
260 (*x_vertices)[i + Fstart] = cube_inner_x_vertices[i];
261 (*y_vertices)[i + Fstart] = cube_inner_y_vertices[i];
262 (*z_vertices)[i + Fstart] = cube_inner_z_vertices[i];
263 }
264
265 free(temp_x_vertices);
266 free(temp_y_vertices);
267 free(temp_z_vertices);
268 free(cube_inner_x_vertices);
269 free(cube_inner_y_vertices);
270 free(cube_inner_z_vertices);
271
272 for (unsigned i = 0; i < 6; ++i)
273 for (unsigned j = 0; j < n * n; ++j)
274 (*face_id)[i * n * n + j] = i + 1;
275
276 unsigned * edge_vertices = xmalloc(num_edge_coords * 12 * sizeof(*edge_vertices));
277
278 Fstart = Estart + 12 * num_edge_coords;
279
280 for (unsigned i = 0; i < num_edge_coords * 12; ++i) edge_vertices[i] = i + Estart;
281
282 unsigned * F = xmalloc((n + 1) * (n + 1) * sizeof(*F));
283 unsigned cell_to_vertex_offset = 0;
284
285// Calculate the indices for all the vertices on face 1
286// v2-----e3-----v4
287// | |
288// e1 f1 e4
289// | |
290// v1-----e2-----v3
291
292 F[0] = 0; F[n] = 2; F[n * (n + 1) + 0] = 1; F[n * (n + 1) + n] = 3;
293 for (unsigned i = 0; i < num_edge_coords; ++i) {
294 F[i + 1] = edge_vertices[1 * num_edge_coords + i];
295 F[(i + 1) * (n + 1)] = edge_vertices[0 * num_edge_coords + i];
296 F[(i + 1) * (n + 1) + n] = edge_vertices[3 * num_edge_coords + i];
297 F[n * (n + 1) + i + 1] = edge_vertices[2 * num_edge_coords + i];
298 }
299
300 for (unsigned i = 0; i < n-1; ++i)
301 for (unsigned j = 0; j < n-1; ++j)
302 F[(i + 1) * (n + 1) + (j + 1)] = Fstart + i * (n - 1) + j;
303
304 for (unsigned i = 0; i < n; ++i) {
305 for (unsigned j = 0; j < n; ++j) {
306 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 0) * (n + 1) + (j + 0)];
307 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 1) * (n + 1) + (j + 0)];
308 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 1) * (n + 1) + (j + 1)];
309 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 0) * (n + 1) + (j + 1)];
310 }
311 }
312
313// Calculate the indices for all the vertices on face 2
314// v6-----e7-----v8
315// | |
316// e5 f2 e8
317// | |
318// v5-----e6-----v7
319
320 F[0] = 4; F[n] = 6; F[n * (n + 1) + 0] = 5; F[n * (n + 1) + n] = 7;
321 for (unsigned i = 0; i < num_edge_coords; ++i) {
322 F[i + 1] = edge_vertices[5 * num_edge_coords + i];
323 F[(i + 1) * (n + 1)] = edge_vertices[4 * num_edge_coords + i];
324 F[(i + 1) * (n + 1) + n] = edge_vertices[7 * num_edge_coords + i];
325 F[n * (n + 1) + i + 1] = edge_vertices[6 * num_edge_coords + i];
326 }
327
328 for (unsigned i = 0; i < n-1; ++i)
329 for (unsigned j = 0; j < n-1; ++j)
330 F[(i + 1) * (n + 1) + (j + 1)] += (n - 1) * (n - 1);
331
332 for (unsigned i = 0; i < n; ++i) {
333 for (unsigned j = 0; j < n; ++j) {
334 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 0) * (n + 1) + (j + 0)];
335 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 1) * (n + 1) + (j + 0)];
336 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 1) * (n + 1) + (j + 1)];
337 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 0) * (n + 1) + (j + 1)];
338 }
339 }
340
341// Calculate the indices for all the vertices on face 3
342// v2-----e10----v6
343// | |
344// e1 f3 e5
345// | |
346// v1-----e9-----v5
347
348 F[0] = 0; F[n] = 4; F[n * (n + 1) + 0] = 1; F[n * (n + 1) + n] = 5;
349 for (unsigned i = 0; i < num_edge_coords; ++i) {
350 F[i + 1] = edge_vertices[8 * num_edge_coords + i];
351 F[(i + 1) * (n + 1)] = edge_vertices[0 * num_edge_coords + i];
352 F[(i + 1) * (n + 1) + n] = edge_vertices[4 * num_edge_coords + i];
353 F[n * (n + 1) + i + 1] = edge_vertices[9 * num_edge_coords + i];
354 }
355
356 for (unsigned i = 0; i < n-1; ++i)
357 for (unsigned j = 0; j < n-1; ++j)
358 F[(i + 1) * (n + 1) + (j + 1)] += (n - 1) * (n - 1);
359
360 for (unsigned i = 0; i < n; ++i) {
361 for (unsigned j = 0; j < n; ++j) {
362 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 0) * (n + 1) + (j + 0)];
363 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 1) * (n + 1) + (j + 0)];
364 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 1) * (n + 1) + (j + 1)];
365 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 0) * (n + 1) + (j + 1)];
366 }
367 }
368
369// Calculate the indices for all the vertices on face 4
370// v4-----e12----v8
371// | |
372// e4 f4 e8
373// | |
374// v3-----e11----v7
375
376 F[0] = 2; F[n] = 6; F[n * (n + 1) + 0] = 3; F[n * (n + 1) + n] = 7;
377 for (unsigned i = 0; i < num_edge_coords; ++i) {
378 F[i + 1] = edge_vertices[10 * num_edge_coords + i];
379 F[(i + 1) * (n + 1)] = edge_vertices[ 3 * num_edge_coords + i];
380 F[(i + 1) * (n + 1) + n] = edge_vertices[ 7 * num_edge_coords + i];
381 F[n * (n + 1) + i + 1] = edge_vertices[11 * num_edge_coords + i];
382 }
383
384 for (unsigned i = 0; i < n-1; ++i)
385 for (unsigned j = 0; j < n-1; ++j)
386 F[(i + 1) * (n + 1) + (j + 1)] += (n - 1) * (n - 1);
387
388 for (unsigned i = 0; i < n; ++i) {
389 for (unsigned j = 0; j < n; ++j) {
390 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 0) * (n + 1) + (j + 0)];
391 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 1) * (n + 1) + (j + 0)];
392 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 1) * (n + 1) + (j + 1)];
393 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 0) * (n + 1) + (j + 1)];
394 }
395 }
396
397// Calculate the indices for all the vertices on face 5
398// v5-----e6-----v7
399// | |
400// e9 f5 e11
401// | |
402// v1-----e2-----v3
403
404 F[0] = 0; F[n] = 2; F[n * (n + 1) + 0] = 4; F[n * (n + 1) + n] = 6;
405 for (unsigned i = 0; i < num_edge_coords; ++i) {
406 F[i + 1] = edge_vertices[ 1 * num_edge_coords + i];
407 F[(i + 1) * (n + 1)] = edge_vertices[ 8 * num_edge_coords + i];
408 F[(i + 1) * (n + 1) + n] = edge_vertices[10 * num_edge_coords + i];
409 F[n * (n + 1) + i + 1] = edge_vertices[ 5 * num_edge_coords + i];
410 }
411
412 for (unsigned i = 0; i < n-1; ++i)
413 for (unsigned j = 0; j < n-1; ++j)
414 F[(i + 1) * (n + 1) + (j + 1)] += (n - 1) * (n - 1);
415
416 for (unsigned i = 0; i < n; ++i) {
417 for (unsigned j = 0; j < n; ++j) {
418 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 0) * (n + 1) + (j + 0)];
419 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 1) * (n + 1) + (j + 0)];
420 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 1) * (n + 1) + (j + 1)];
421 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 0) * (n + 1) + (j + 1)];
422 }
423 }
424
425// Calculate the indices for all the vertices on face 6
426// v6-----e7-----v8
427// | |
428// e10 f6 e12
429// | |
430// v2-----e3-----v4
431
432 F[0] = 1; F[n] = 3; F[n * (n + 1) + 0] = 5; F[n * (n + 1) + n] = 7;
433 for (unsigned i = 0; i < num_edge_coords; ++i) {
434 F[i + 1] = edge_vertices[ 2 * num_edge_coords + i];
435 F[(i + 1) * (n + 1)] = edge_vertices[ 9 * num_edge_coords + i];
436 F[(i + 1) * (n + 1) + n] = edge_vertices[11 * num_edge_coords + i];
437 F[n * (n + 1) + i + 1] = edge_vertices[ 6 * num_edge_coords + i];
438 }
439
440 for (unsigned i = 0; i < n-1; ++i)
441 for (unsigned j = 0; j < n-1; ++j)
442 F[(i + 1) * (n + 1) + (j + 1)] += (n - 1) * (n - 1);
443
444 for (unsigned i = 0; i < n; ++i) {
445 for (unsigned j = 0; j < n; ++j) {
446 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 0) * (n + 1) + (j + 0)];
447 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 1) * (n + 1) + (j + 0)];
448 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 1) * (n + 1) + (j + 1)];
449 (*cell_to_vertex)[cell_to_vertex_offset++] = F[(i + 0) * (n + 1) + (j + 1)];
450 }
451 }
452
453 free(edge_vertices);
454 free(F);
455}
456
457struct yac_basic_grid_data yac_generate_cubed_sphere_grid(unsigned n) {
458
459 unsigned num_cells, num_vertices;
460 double * x_vertices, * y_vertices, * z_vertices;
461 unsigned * cell_to_vertex;
462 unsigned * face_id;
463
464 yac_generate_cubed_sphere_grid_information(
465 n, &num_cells, &num_vertices, &x_vertices, &y_vertices, &z_vertices,
466 &cell_to_vertex, &face_id);
467
468 free(face_id);
469
470 int * num_vertices_per_cell =
471 xmalloc(num_cells * sizeof(*num_vertices_per_cell));
472 for (unsigned i = 0; i < num_cells; ++i) num_vertices_per_cell[i] = 4;
473
474 struct yac_basic_grid_data grid_data =
475 yac_generate_basic_grid_data_unstruct(
476 (size_t)num_vertices, (size_t)num_cells, num_vertices_per_cell,
477 x_vertices, y_vertices, (int *)cell_to_vertex);
478 grid_data.cell_ids =
479 xmalloc((size_t)num_cells * sizeof(*(grid_data.cell_ids)));
480 grid_data.vertex_ids =
481 xmalloc((size_t)num_vertices * sizeof(*(grid_data.vertex_ids)));
482 grid_data.edge_ids =
483 xmalloc(grid_data.num_edges * sizeof(*(grid_data.edge_ids)));
484 for (size_t i = 0; i < (size_t)num_cells; ++i)
485 grid_data.cell_ids[i] = (yac_int)i;
486 for (size_t i = 0; i < (size_t)num_vertices; ++i) {
487 grid_data.vertex_ids[i] = (yac_int)i;
488 grid_data.vertex_coordinates[i][0] = x_vertices[i];
489 grid_data.vertex_coordinates[i][1] = y_vertices[i];
490 grid_data.vertex_coordinates[i][2] = z_vertices[i];
491 }
492 for (size_t i = 0; i < grid_data.num_edges; ++i)
493 grid_data.edge_ids[i] = (yac_int)i;
494 free(num_vertices_per_cell);
495 free(x_vertices);
496 free(y_vertices);
497 free(z_vertices);
498 free(cell_to_vertex);
499
500 return grid_data;
501}
502
503struct yac_basic_grid * yac_generate_cubed_sphere_basic_grid(
504 char const * name, size_t n) {
505
506 return
507 yac_basic_grid_new(
508 name,
509 yac_generate_cubed_sphere_grid((unsigned)n));
510}
511
512static void decompose_domain_simple(unsigned n, int size, int * cell_owner) {
513
514 unsigned nbr_cells = n * n * 6;
515
516 for (unsigned i = 0; i < nbr_cells; ++i)
517 cell_owner[i] = (i * size + size - 1) / nbr_cells;
518}
519
520static void decompose_domain_2d(unsigned n, int size, int * cell_owner) {
521
522 // distribute processes among all six sides of the cubed sphere
523 int proc_start[6 + 1];
524 for (int i = 0; i < 6 + 1; ++i)
525 proc_start[i] = (size * i) / 6;
526
527 // for each side of the cube
528 for (unsigned i = 0, offset = 0; i < 6; ++i) {
529
530 int num_procs[2];
531 int curr_num_procs = proc_start[i+1] - proc_start[i];
532
533 yac_generate_reg2d_decomp((int[2]){(int)n,(int)n}, curr_num_procs, num_procs);
534
535 int local_start_x[num_procs[0] + 1];
536 int local_start_y[num_procs[1] + 1];
537
538 for (int j = 0; j < num_procs[0] + 1; ++j)
539 local_start_x[j] = (n * j) / num_procs[0];
540 for (int j = 0; j < num_procs[1] + 1; ++j)
541 local_start_y[j] = (n * j) / num_procs[1];
542
543 for (int p_y = 0; p_y < num_procs[1]; ++p_y) {
544 for (int row = local_start_y[p_y]; row < local_start_y[p_y+1]; ++row) {
545 for (int p_x = 0; p_x < num_procs[0]; ++p_x) {
546 for (int column = local_start_x[p_x]; column < local_start_x[p_x+1];
547 ++column) {
548
549 cell_owner[offset++] = proc_start[i] + p_x + num_procs[0] * p_y;
550 }
551 }
552 }
553 }
554 }
555}
556
557static void decompose_domain(unsigned n, int size, int * cell_owner) {
558
559 if (size <= 6) {
560 decompose_domain_simple(n, size, cell_owner);
561 } else {
562 decompose_domain_2d(n, size, cell_owner);
563 }
564}
565
566void yac_generate_part_cube_grid_information(
567 unsigned n, unsigned * nbr_vertices, unsigned * nbr_cells,
568 unsigned ** num_vertices_per_cell, unsigned ** cell_to_vertex,
569 double ** x_vertices, double ** y_vertices, double ** x_cells,
570 double ** y_cells, int ** global_cell_id, int ** cell_core_mask,
571 int ** global_corner_id, int ** corner_core_mask, int rank, int size) {
572
573 double * x_vertices_3d, * y_vertices_3d, * z_vertices_3d;
574 unsigned * dummy;
575
576 // generate global grid
577 yac_generate_cubed_sphere_grid_information(n, nbr_cells, nbr_vertices,
578 &x_vertices_3d, &y_vertices_3d,
579 &z_vertices_3d, cell_to_vertex,
580 &dummy);
581 *num_vertices_per_cell = xmalloc(*nbr_cells * sizeof(**num_vertices_per_cell));
582 for (unsigned i = 0; i < *nbr_cells; ++i) (*num_vertices_per_cell)[i] = 4;
583 free(dummy);
584
585 double * x_cell_3d = xmalloc(*nbr_cells * sizeof(*x_cell_3d));
586 double * y_cell_3d = xmalloc(*nbr_cells * sizeof(*y_cell_3d));
587 double * z_cell_3d = xmalloc(*nbr_cells * sizeof(*z_cell_3d));
588
589 for (unsigned i = 0; i < *nbr_cells; ++i) {
590
591 x_cell_3d[i] = y_cell_3d[i] = z_cell_3d[i] = 0;
592
593 for (unsigned j = 0; j < 4; ++j) {
594
595 x_cell_3d[i] += x_vertices_3d[(*cell_to_vertex)[4 * i + j]];
596 y_cell_3d[i] += y_vertices_3d[(*cell_to_vertex)[4 * i + j]];
597 z_cell_3d[i] += z_vertices_3d[(*cell_to_vertex)[4 * i + j]];
598 }
599
600 double scale = 1.0 / sqrt(x_cell_3d[i] * x_cell_3d[i] +
601 y_cell_3d[i] * y_cell_3d[i] +
602 z_cell_3d[i] * z_cell_3d[i]);
603
604 x_cell_3d[i] *= scale;
605 y_cell_3d[i] *= scale;
606 z_cell_3d[i] *= scale;
607 }
608
609 int * cell_is_on_rank = xmalloc(*nbr_cells * sizeof(*cell_is_on_rank));
610
611 decompose_domain(n, size, cell_is_on_rank);
612
613 // mask for required vertices and cells
614 int * required_vertices = xcalloc(*nbr_vertices, sizeof(*required_vertices));
615 int * required_cells = xcalloc(*nbr_cells, sizeof(*required_cells));
616
617 // mark all local cells and their vertices as required
618 for (unsigned i = 0, offset = 0; i < *nbr_cells;
619 offset += (*num_vertices_per_cell)[i++]) {
620
621 if (cell_is_on_rank[i] != rank) continue;
622
623 cell_is_on_rank[i] = -1;
624
625 required_cells[i] = 1;
626 for (unsigned j = 0; j < (*num_vertices_per_cell)[i]; ++j)
627 required_vertices[(*cell_to_vertex)[offset+j]] = 1;
628 }
629
630 // mark all halo cells as required and generate cell_is_on_rank
631 for (unsigned i = 0, offset = 0; i < *nbr_cells;
632 offset += (*num_vertices_per_cell)[i++]) {
633
634 if (!required_cells[i]) {
635
636 for (unsigned j = 0; j < (*num_vertices_per_cell)[i]; ++j) {
637
638 if (required_vertices[(*cell_to_vertex)[offset+j]]) {
639
640 required_cells[i] = 1;
641 break;
642 }
643 }
644
645 }
646 }
647
648 // mask for halo vertices
649 int * vertex_is_on_rank = xmalloc(*nbr_vertices * sizeof(*vertex_is_on_rank));
650
651 // mark all halo vertices as required and generate vertex_is_on_rank
652 for (unsigned i = 0; i < *nbr_vertices; ++i)
653 if (required_vertices[i])
654 vertex_is_on_rank[i] = -1;
655 for (unsigned i = 0, offset = 0; i < *nbr_cells;
656 offset += (*num_vertices_per_cell)[i++]) {
657
658 if (required_cells[i] && cell_is_on_rank[i] != -1) {
659
660 for (unsigned j = 0; j < (*num_vertices_per_cell)[i]; ++j) {
661
662 if (!required_vertices[(*cell_to_vertex)[offset+j]]) {
663
664 required_vertices[(*cell_to_vertex)[offset+j]] = 1;
665 vertex_is_on_rank[(*cell_to_vertex)[offset+j]] = cell_is_on_rank[i];
666 }
667 }
668 }
669 }
670
671 // count the number of cells and vertices
672 int part_num_vertices = 0;
673 int part_num_cells = 0;
674 for (unsigned i = 0; i < *nbr_vertices; ++i)
675 if (required_vertices[i])
676 part_num_vertices++;
677 for (unsigned i = 0; i < *nbr_cells; ++i)
678 if(required_cells[i])
679 part_num_cells++;
680
681 *global_cell_id = xmalloc(part_num_cells * sizeof(**global_cell_id));
682 *cell_core_mask = xmalloc(part_num_cells * sizeof(**cell_core_mask));
683 *global_corner_id = xmalloc(part_num_vertices * sizeof(**global_corner_id));
684 *corner_core_mask = xmalloc(part_num_vertices * sizeof(**corner_core_mask));
685
686 *x_cells = xmalloc(part_num_cells * sizeof(**x_cells));
687 *y_cells = xmalloc(part_num_cells * sizeof(**y_cells));
688 *x_vertices = xmalloc(part_num_vertices * sizeof(**x_vertices));
689 *y_vertices = xmalloc(part_num_vertices * sizeof(**y_vertices));
690
691 // generate final vertex data
692 part_num_vertices = 0;
693 int * global_to_local_vertex = xmalloc(*nbr_vertices * sizeof(*global_to_local_vertex));
694 for (unsigned i = 0; i < *nbr_vertices; ++i) {
695
696 if (required_vertices[i]) {
697
698 (*global_corner_id)[part_num_vertices] = i;
699 (*corner_core_mask)[part_num_vertices] = vertex_is_on_rank[i] == -1;
700 double p[3] = {x_vertices_3d[i], y_vertices_3d[i], z_vertices_3d[i]};
701 XYZtoLL(p, (*x_vertices) + part_num_vertices, (*y_vertices) + part_num_vertices);
702 global_to_local_vertex[i] = part_num_vertices;
703 part_num_vertices++;
704 }
705 }
706
707 free(vertex_is_on_rank);
708 *nbr_vertices = part_num_vertices;
709 free(required_vertices);
710
711 // generate final cell data
712 int num_cell_vertex_dependencies = 0;
713 part_num_cells = 0;
714 for (unsigned i = 0, offset = 0; i < *nbr_cells;
715 offset += (*num_vertices_per_cell)[i++]) {
716
717 if (required_cells[i]) {
718
719 (*global_cell_id)[part_num_cells] = i;
720 (*cell_core_mask)[part_num_cells] = (cell_is_on_rank[i] == -1);
721 double middle_point[3] = {x_cell_3d[i],y_cell_3d[i],z_cell_3d[i]};
722
723 for (unsigned j = 0; j < (*num_vertices_per_cell)[i]; ++j) {
724 (*cell_to_vertex)[num_cell_vertex_dependencies+j] =
725 global_to_local_vertex[(*cell_to_vertex)[offset+j]];
726 }
727
728 XYZtoLL(middle_point, (*x_cells)+part_num_cells, (*y_cells)+part_num_cells);
729
730 num_cell_vertex_dependencies += (*num_vertices_per_cell)[i];
731
732 (*num_vertices_per_cell)[part_num_cells] = (*num_vertices_per_cell)[i];
733
734 part_num_cells++;
735 }
736 }
737
738 free(x_cell_3d);
739 free(y_cell_3d);
740 free(z_cell_3d);
741 free(x_vertices_3d);
742 free(y_vertices_3d);
743 free(z_vertices_3d);
744
745 *num_vertices_per_cell = xrealloc(*num_vertices_per_cell, part_num_cells *
746 sizeof(**num_vertices_per_cell));
747 *cell_to_vertex = xrealloc(*cell_to_vertex, num_cell_vertex_dependencies *
748 sizeof(**cell_to_vertex));
749 free(cell_is_on_rank);
750 *nbr_cells = part_num_cells;
751 free(required_cells);
752 free(global_to_local_vertex);
753}
754
755#ifdef YAC_NETCDF_ENABLED
756void yac_write_cubed_sphere_grid(unsigned n, char const * filename) {
757
758 // generate basic grid information
759 unsigned num_cells, num_vertices;
760 double * x_vertices, * y_vertices, * z_vertices;
761 unsigned * vertices_of_cell, * dummy;
762 yac_generate_cubed_sphere_grid_information(
763 n, &num_cells, &num_vertices, &x_vertices, &y_vertices, &z_vertices,
764 &vertices_of_cell, &dummy);
765 free(dummy);
766
767 // create file and define dimensions and variables
768 size_t nv = 4, ne = 4;
769 int ncid;
770 int dim_cell_id, dim_vertex_id, dim_nv_id, dim_ne_id;
771 int var_vlon_id, var_vlat_id, var_clon_id, var_clat_id, var_mask_id,
772 var_v2c_id, var_c2v_id;
773 yac_nc_create(filename, NC_CLOBBER | NC_64BIT_OFFSET, &ncid);
774 YAC_HANDLE_ERROR(nc_def_dim(ncid, "cell", (size_t)num_cells, &dim_cell_id));
775 YAC_HANDLE_ERROR(nc_def_dim(ncid, "vertex", (size_t)num_vertices, &dim_vertex_id));
776 YAC_HANDLE_ERROR(nc_def_dim(ncid, "nv", 4, &dim_nv_id));
777 YAC_HANDLE_ERROR(nc_def_dim(ncid, "ne", 4, &dim_ne_id));
778 YAC_HANDLE_ERROR(
779 nc_def_var(ncid, "vlon", NC_DOUBLE, 1, &dim_vertex_id, &var_vlon_id));
780 YAC_HANDLE_ERROR(
781 nc_def_var(ncid, "vlat", NC_DOUBLE, 1, &dim_vertex_id, &var_vlat_id));
782 YAC_HANDLE_ERROR(
783 nc_def_var(ncid, "clon", NC_DOUBLE, 1, &dim_cell_id, &var_clon_id));
784 YAC_HANDLE_ERROR(
785 nc_def_var(ncid, "clat", NC_DOUBLE, 1, &dim_cell_id, &var_clat_id));
786 YAC_HANDLE_ERROR(
787 nc_def_var(
788 ncid, "cell_sea_land_mask", NC_INT, 1, &dim_cell_id, &var_mask_id));
789 YAC_HANDLE_ERROR(
790 nc_def_var(
791 ncid, "vertex_of_cell", NC_INT, 2, (int[]){dim_nv_id, dim_cell_id},
792 &var_c2v_id));
793 YAC_HANDLE_ERROR(
794 nc_def_var(
795 ncid, "cells_of_vertex", NC_INT, 2, (int[]){dim_ne_id, dim_vertex_id},
796 &var_v2c_id));
797 YAC_HANDLE_ERROR(nc_enddef(ncid));
798
799 // generate and write grid data
800
801 double * lon_buffer =
802 xmalloc(MAX(num_cells, num_vertices) * sizeof(*lon_buffer));
803 double * lat_buffer =
804 xmalloc(MAX(num_cells, num_vertices) * sizeof(*lat_buffer));
805
806 for (unsigned i = 0; i < num_vertices; ++i) {
807 double coord_3d[3] = {x_vertices[i], y_vertices[i], z_vertices[i]};
808 XYZtoLL(coord_3d, lon_buffer + i, lat_buffer + i);
809 }
810 YAC_HANDLE_ERROR(nc_put_var_double(ncid, var_vlon_id, lon_buffer));
811 YAC_HANDLE_ERROR(nc_put_var_double(ncid, var_vlat_id, lat_buffer));
812
813 for (unsigned i = 0; i < num_cells; ++i) {
814 double coord_3d[3] = {0.0, 0.0, 0.0};
815 for (unsigned j = 0; j < 4; ++j) {
816 unsigned vertex_idx = vertices_of_cell[4 * i + j];
817 coord_3d[0] += x_vertices[vertex_idx];
818 coord_3d[1] += y_vertices[vertex_idx];
819 coord_3d[2] += z_vertices[vertex_idx];
820 }
821 normalise_vector(coord_3d);
822 XYZtoLL(coord_3d, lon_buffer + i, lat_buffer + i);
823 }
824 YAC_HANDLE_ERROR(nc_put_var_double(ncid, var_clon_id, lon_buffer));
825 YAC_HANDLE_ERROR(nc_put_var_double(ncid, var_clat_id, lat_buffer));
826
827 free(lat_buffer);
828 free(lon_buffer);
829 free(z_vertices);
830 free(y_vertices);
831 free(x_vertices);
832
833 int * int_buffer =
834 xmalloc(MAX(nv, ne) * MAX(num_cells, num_vertices) * sizeof(*int_buffer));
835
836 for (unsigned i = 0; i < num_cells; ++i) int_buffer[i] = 1;
837 YAC_HANDLE_ERROR(nc_put_var_int(ncid, var_mask_id, int_buffer));
838
839 for (unsigned i = 0; i < ne * num_vertices; ++i)
840 int_buffer[i] = INT_MAX;
841 for (unsigned i = 0; i < num_cells; ++i) {
842 int cell_id = (int)(i + 1);
843 for (unsigned j = 0; j < ne; ++j) {
844 unsigned vertex_idx = vertices_of_cell[ne * i + j];
845 for (unsigned k = 0; k < ne; ++k) {
846 if (int_buffer[k * num_vertices + vertex_idx] == INT_MAX) {
847 int_buffer[k * num_vertices + vertex_idx] = cell_id;
848 break;
849 }
850 }
851 }
852 }
853 YAC_HANDLE_ERROR(nc_put_var_int(ncid, var_v2c_id, int_buffer));
854
855 for (unsigned i = 0; i < num_cells; ++i)
856 for (unsigned j = 0; j < nv; ++j)
857 int_buffer[j * num_cells + i] =
858 vertices_of_cell[nv * i + j] + 1;
859 YAC_HANDLE_ERROR(nc_put_var_int(ncid, var_c2v_id, int_buffer));
860
861 free(int_buffer);
862 free(vertices_of_cell);
863
864 YAC_HANDLE_ERROR(nc_close(ncid));
865}
866#else
867void yac_write_cubed_sphere_grid(unsigned n, char const * filename) {
868
869 UNUSED(n);
870 UNUSED(filename);
871 die(
872 "ERROR(yac_write_cubed_sphere_grid): "
873 "YAC is built without the NetCDF support");
874}
875#endif // YAC_NETCDF_ENABLED
YAC_ASSERT
#define YAC_ASSERT(exp, msg)
Definition OASIS3_MCT_example.c:63
yac_basic_grid_new
struct yac_basic_grid * yac_basic_grid_new(char const *name, struct yac_basic_grid_data grid_data)
Definition basic_grid.c:53
yac_generate_basic_grid_data_unstruct
struct yac_basic_grid_data yac_generate_basic_grid_data_unstruct(size_t nbr_vertices, size_t nbr_cells, int *num_vertices_per_cell, double *x_vertices, double *y_vertices, int *cell_to_vertex)
Definition grid_unstruct.c:265
UNUSED
#define UNUSED(x)
Definition core.h:72
yac_generate_part_cube_grid_information
void yac_generate_part_cube_grid_information(unsigned n, unsigned *nbr_vertices, unsigned *nbr_cells, unsigned **num_vertices_per_cell, unsigned **cell_to_vertex, double **x_vertices, double **y_vertices, double **x_cells, double **y_cells, int **global_cell_id, int **cell_core_mask, int **global_corner_id, int **corner_core_mask, int rank, int size)
Definition generate_cubed_sphere.c:566
yac_write_cubed_sphere_grid
void yac_write_cubed_sphere_grid(unsigned n, char const *filename)
Definition generate_cubed_sphere.c:756
decompose_domain
static void decompose_domain(unsigned n, int size, int *cell_owner)
Definition generate_cubed_sphere.c:557
yac_generate_cubed_sphere_basic_grid
struct yac_basic_grid * yac_generate_cubed_sphere_basic_grid(char const *name, size_t n)
Definition generate_cubed_sphere.c:503
decompose_domain_2d
static void decompose_domain_2d(unsigned n, int size, int *cell_owner)
Definition generate_cubed_sphere.c:520
decompose_domain_simple
static void decompose_domain_simple(unsigned n, int size, int *cell_owner)
Definition generate_cubed_sphere.c:512
yac_generate_cubed_sphere_grid
struct yac_basic_grid_data yac_generate_cubed_sphere_grid(unsigned n)
Definition generate_cubed_sphere.c:457
yac_generate_cubed_sphere_grid_information
void yac_generate_cubed_sphere_grid_information(unsigned n, unsigned *num_cells, unsigned *num_vertices, double **x_vertices, double **y_vertices, double **z_vertices, unsigned **cell_to_vertex, unsigned **face_id)
Definition generate_cubed_sphere.c:20
generate_cubed_sphere.h
yac_generate_reg2d_decomp
void yac_generate_reg2d_decomp(int num_points[2], int total_num_procs, int *num_procs)
Definition generate_reg2d.c:8
generate_reg2d.h
normalise_vector
static void normalise_vector(double v[])
Definition geometry.h:728
yac_nc_create
void yac_nc_create(const char *path, int cmode, int *ncidp)
Definition io_utils.c:367
io_utils.h
XYZtoLL
static void XYZtoLL(double const p_in[], double *lon, double *lat)
Definition perf_toy_icon.c:356
ppm_xfuncs.h
add versions of standard API functions not returning on error
xrealloc
#define xrealloc(ptr, size)
Definition ppm_xfuncs.h:67
xcalloc
#define xcalloc(nmemb, size)
Definition ppm_xfuncs.h:64
xmalloc
#define xmalloc(size)
Definition ppm_xfuncs.h:66
grid_data
Definition test_dummy_coupling3_c.c:36
yac_basic_grid_data
Definition basic_grid_data.h:13
yac_basic_grid_data::cell_to_vertex
size_t * cell_to_vertex
Definition basic_grid_data.h:26
yac_basic_grid_data::num_cells
size_t num_cells
Definition basic_grid_data.h:18
yac_basic_grid_data::num_vertices
size_t num_vertices
Definition basic_grid_data.h:19
yac_basic_grid_data::num_vertices_per_cell
int * num_vertices_per_cell
Definition basic_grid_data.h:24
yac_basic_grid
Definition basic_grid.c:20
cell_to_vertex
int * cell_to_vertex
Definition test_dummy_coupling_c.c:61
num_cells
size_t num_cells[2]
Definition test_interpolation_parallel3.c:104
cell_core_mask
int * cell_core_mask
Definition toy_coupling.c:42
YAC_HANDLE_ERROR
#define YAC_HANDLE_ERROR(exp)
Definition toy_output.c:13
name
char const * name
Definition toy_scrip.c:114
p
double(* p)(double lon, double lat)
Definition toy_scrip.c:119
MAX
#define MAX(a, b)
Definition utils_common.h:66
die
#define die(msg)
Definition yac_assert.h:12
yac_int
YAC_INT yac_int
Definition yac_types.h:15