43 int * nbr_cells,
int ** num_vertices_per_cell,
44 int ** cell_to_vertex,
double ** x_vertices,
45 double ** y_vertices,
double ** x_cells,
46 double ** y_cells,
int ** cell_mask) {
48#ifndef YAC_NETCDF_ENABLED
53 UNUSED(num_vertices_per_cell);
61 "ERROR(yac_read_mpiom_grid_information): "
62 "YAC is built without the NetCDF support");
75 double * temp_vertex_lon;
76 double * temp_vertex_lat;
77 size_t temp_nbr_vertices;
80 ncid, &temp_vertex_lon, &temp_vertex_lat, &temp_nbr_vertices);
82 *nbr_cells = (int)(temp_nbr_vertices / 4);
84 int * old_to_new_id =
xmalloc(temp_nbr_vertices *
sizeof(*old_to_new_id));
87 temp_vertex_lon, temp_vertex_lat, NULL,
88 &temp_nbr_vertices, old_to_new_id);
90 *nbr_vertices = temp_nbr_vertices;
93 xrealloc(temp_vertex_lon, temp_nbr_vertices *
sizeof(*temp_vertex_lon));
95 xrealloc(temp_vertex_lat, temp_nbr_vertices *
sizeof(*temp_vertex_lat));
97 for (
size_t i = 0; i < temp_nbr_vertices; ++i) {
102 *num_vertices_per_cell =
xmalloc(*nbr_cells *
sizeof(**num_vertices_per_cell));
103 for (
int i = 0; i < *nbr_cells; ++i) (*num_vertices_per_cell)[i] = 4;
105 *cell_to_vertex =
xmalloc(*nbr_cells * 4 *
sizeof(**cell_to_vertex));
108 for (
int i = 0; i < *nbr_cells; ++i)
109 for (
int j = 0; j < 4; ++j)
110 (*cell_to_vertex)[4*i+j] = old_to_new_id[4*i+j];
117 double * temp_cell_lon;
118 double * temp_cell_lat;
119 int * temp_cell_mask;
121 size_t temp_nbr_cells;
122 size_t temp_nbr_masks;
125 ncid, &temp_cell_lon, &temp_cell_lat, &temp_nbr_cells);
130 temp_nbr_cells == temp_nbr_masks,
131 "ERROR(yac_read_mpiom_grid_information): "
132 "missmatch between cell count and mask value count")
134 int * old_to_new_id =
xmalloc(temp_nbr_cells *
sizeof(*old_to_new_id));
137 temp_cell_lon, temp_cell_lat, temp_cell_mask,
138 &temp_nbr_cells, old_to_new_id);
140 *nbr_cells = temp_nbr_cells;
142 *x_cells =
xrealloc(temp_cell_lon, temp_nbr_cells *
sizeof(**x_cells));
143 *y_cells =
xrealloc(temp_cell_lat, temp_nbr_cells *
sizeof(**y_cells));
145 for (
size_t i = 0; i < temp_nbr_cells; ++i) {
150 *cell_mask =
xrealloc(temp_cell_mask,temp_nbr_cells *
sizeof(
int));
151 for (
size_t i = 0; i < temp_nbr_cells; ++i)
152 (*cell_mask)[i] = !(*cell_mask)[i];
161 const char * filename,
int * num_vertices,
int * num_cells,
162 int ** num_vertices_per_cell,
int ** cell_to_vertex,
double ** x_vertices,
163 double ** y_vertices,
double ** x_cells,
164 double ** y_cells,
int ** global_cell_id,
165 int ** cell_mask,
int ** cell_core_mask,
166 int ** global_corner_id,
int ** corner_core_mask,
int rank,
int size) {
170 num_vertices_per_cell, cell_to_vertex,
171 x_vertices, y_vertices, x_cells, y_cells, cell_mask);
174 int num_cells_per_process = (*num_cells + size - 1)/size;
175 int local_start = rank * num_cells_per_process;
176 int num_local_cells =
MIN(num_cells_per_process,
177 *num_cells - local_start);
180 int * required_vertices =
xcalloc(*num_vertices,
sizeof(*required_vertices));
181 int * required_cells =
xcalloc(*num_cells,
sizeof(*required_cells));
184 for (
int i = 0; i < local_start; ++i)
185 offset += (*num_vertices_per_cell)[i];
188 for (
int i = local_start; i < local_start + num_local_cells; ++i) {
190 required_cells[i] = 2;
191 for (
int j = 0; j < (*num_vertices_per_cell)[i]; ++j)
192 required_vertices[(*cell_to_vertex)[offset+j]] = 2;
194 offset += (*num_vertices_per_cell)[i];
199 for (
int i = 0; i < *num_cells; ++i) {
201 if (!required_cells[i]) {
203 for (
int j = 0; j < (*num_vertices_per_cell)[i]; ++j) {
205 if (required_vertices[(*cell_to_vertex)[offset+j]]) {
207 required_cells[i] = 1;
212 offset += (*num_vertices_per_cell)[i];
217 for (
int i = 0; i < *num_cells; ++i) {
219 if (required_cells[i] == 1) {
221 for (
int j = 0; j < (*num_vertices_per_cell)[i]; ++j) {
223 if (!required_vertices[(*cell_to_vertex)[offset+j]]) {
225 required_vertices[(*cell_to_vertex)[offset+j]] = 1;
230 offset += (*num_vertices_per_cell)[i];
234 int part_num_vertices = 0;
235 int part_num_cells = 0;
236 for (
int i = 0; i < *num_vertices; ++i)
237 if (required_vertices[i])
239 for (
int i = 0; i < *num_cells; ++i)
240 if(required_cells[i])
243 *global_cell_id =
xmalloc(part_num_cells *
sizeof(**global_cell_id));
244 *cell_core_mask =
xmalloc(part_num_cells *
sizeof(**cell_core_mask));
245 *global_corner_id =
xmalloc(part_num_vertices *
sizeof(**global_corner_id));
246 *corner_core_mask =
xmalloc(part_num_vertices *
sizeof(**corner_core_mask));
249 part_num_vertices = 0;
250 int * global_to_local_vertex =
xmalloc(*num_vertices *
sizeof(*global_to_local_vertex));
251 for (
int i = 0; i < *num_vertices; ++i) {
253 if (required_vertices[i]) {
255 (*global_corner_id)[part_num_vertices] = i;
256 (*corner_core_mask)[part_num_vertices] = required_vertices[i] == 2;
257 (*x_vertices)[part_num_vertices] = (*x_vertices)[i];
258 (*y_vertices)[part_num_vertices] = (*y_vertices)[i];
259 global_to_local_vertex[i] = part_num_vertices;
264 *x_vertices =
xrealloc(*x_vertices, part_num_vertices *
sizeof(**x_vertices));
265 *y_vertices =
xrealloc(*y_vertices, part_num_vertices *
sizeof(**y_vertices));
266 *num_vertices = part_num_vertices;
267 free(required_vertices);
270 int num_cell_vertex_dependencies = 0;
273 for (
int i = 0; i < *num_cells; ++i) {
275 if (required_cells[i]) {
277 (*global_cell_id)[part_num_cells] = i;
278 (*cell_core_mask)[part_num_cells] = required_cells[i] == 2;
279 (*x_cells)[part_num_cells] = (*x_cells)[i];
280 (*y_cells)[part_num_cells] = (*y_cells)[i];
281 (*cell_mask)[part_num_cells] = (*cell_mask)[i];
283 for (
int j = 0; j < (*num_vertices_per_cell)[i]; ++j)
284 (*cell_to_vertex)[num_cell_vertex_dependencies++] =
285 global_to_local_vertex[(*cell_to_vertex)[offset+j]];
287 (*num_vertices_per_cell)[part_num_cells] = (*num_vertices_per_cell)[i];
292 offset += (*num_vertices_per_cell)[i];
295 *x_cells =
xrealloc(*x_cells, part_num_cells *
sizeof(**x_cells));
296 *y_cells =
xrealloc(*y_cells, part_num_cells *
sizeof(**y_cells));
297 *cell_mask =
xrealloc(*cell_mask, part_num_cells *
sizeof(**cell_mask));
299 *num_vertices_per_cell =
xrealloc(*num_vertices_per_cell, part_num_cells *
300 sizeof(**num_vertices_per_cell));
301 *cell_to_vertex =
xrealloc(*cell_to_vertex, num_cell_vertex_dependencies *
302 sizeof(**cell_to_vertex));
303 *num_cells = part_num_cells;
304 free(required_cells);
305 free(global_to_local_vertex);
356 int ncid,
double ** vertex_lon,
double ** vertex_lat,
357 size_t * nbr_vertices) {
363 if (nc_inq_varid(ncid,
"lon_bounds", &glon_id) != NC_NOERR)
366 if (nc_inq_varid(ncid,
"lat_bounds", &glat_id) != NC_NOERR)
376 (glon_ndims == 3) && (glat_ndims == 3),
377 "ERROR(get_mpiom_vertices): "
378 "number of dimensions for lon and lat does not match")
387 size_t dimlen_lat[3];
388 size_t dimlen_lon[3];
391 for (
int i = 0; i < 3; ++i) {
395 dimlen_lon[i] == dimlen_lat[i],
396 "ERROR(get_mpiom_vertices): dimlen_lon[i] != dimlen_lat[i]")
399 dimlen_lon[2] == 4,
"ERROR(get_mpiom_vertices): dimlen_lon[2] has to be 4")
401 *nbr_vertices = dimlen_lon[0] * dimlen_lon[1] * dimlen_lon[2];
403 *vertex_lon =
xmalloc(*nbr_vertices *
sizeof(**vertex_lon));
404 *vertex_lat =
xmalloc(*nbr_vertices *
sizeof(**vertex_lat));
415 size_t *nbr_cells ) {
431 (glon_ndims == 2) && (glat_ndims == 2),
432 "ERROR(get_mpiom_cell_center): (glon_ndims != 2) || (glat_ndims != 2)")
441 size_t dimlen_lon[2];
442 size_t dimlen_lat[2];
445 for (
int i = 0; i < 2; ++i) {
449 dimlen_lon[i] == dimlen_lat[i],
450 "ERROR(get_mpiom_cell_center): dimlen_lon[i] != dimlen_lat[i]")
453 *nbr_cells = dimlen_lon[0] * dimlen_lon[1];
455 *cell_lon =
xmalloc(*nbr_cells *
sizeof(**cell_lon));
456 *cell_lat =
xmalloc(*nbr_cells *
sizeof(**cell_lat));
465 int ncid,
int **cell_mask,
size_t *nbr_cells ) {
471 status = nc_inq_varid (ncid,
"var1", &mask_id);
478 (mask_ndims == 3) || (mask_ndims == 4),
479 "ERROR(get_mpiom_cell_mask): invalid number of dimensions")
486 size_t dimlen_mask[4] = {0, 0, 0, 0};
487 for (
int i = 0; i < mask_ndims; ++i)
490 *nbr_cells = dimlen_mask[mask_ndims - 2] * dimlen_mask[mask_ndims - 1];
492 int * temp_cell_mask =
xmalloc(*nbr_cells *
sizeof(*temp_cell_mask));
497 for (
size_t i = 0; i < *nbr_cells; ++i)
498 temp_cell_mask[i] = !(temp_cell_mask[i] == 1);
500 *cell_mask = temp_cell_mask;
518 double * temp_coords_lon,
double * temp_coords_lat,
int * temp_coords_mask,
519 size_t * temp_nbr_coords,
int * old_to_new_id) {
522 xmalloc(*temp_nbr_coords *
sizeof(*sort_array));
524 double const scale = (double)(2 << 20);
525 int32_t
const periode = (int32_t)(360.0 * scale);
527 for (
size_t i = 0;
i < *temp_nbr_coords; ++
i) {
529 int32_t curr_lon, curr_lat;
531 curr_lon = (int32_t)(temp_coords_lon[
i] * scale);
532 curr_lat = (int32_t)(temp_coords_lat[
i] * scale);
535 curr_lon = curr_lon - (((curr_lon - periode) / periode) * periode);
536 else if (curr_lon > periode)
537 curr_lon = curr_lon - ((curr_lon / periode) * periode);
539 sort_array[
i].
lon = curr_lon;
540 sort_array[
i].
lat = curr_lat;
545 qsort(sort_array, *temp_nbr_coords,
sizeof(*sort_array),
548 old_to_new_id[sort_array[0].
i] = 1;
550 int last_unique_idx = (int)(sort_array[0].
i);
552 for (
size_t i = 1;
i < *temp_nbr_coords; ++
i) {
556 old_to_new_id[sort_array[
i].
i] = 1;
557 last_unique_idx = (int)(sort_array[
i].
i);
561 old_to_new_id[sort_array[
i].
i] = -last_unique_idx;
567 size_t new_nbr_coords = 0;
569 for (
size_t i = 0;
i < *temp_nbr_coords; ++
i) {
571 if (old_to_new_id[
i] == 1) {
573 temp_coords_lon[new_nbr_coords] = temp_coords_lon[
i];
574 temp_coords_lat[new_nbr_coords] = temp_coords_lat[
i];
576 if (temp_coords_mask != NULL)
577 temp_coords_mask[new_nbr_coords] = temp_coords_mask[
i];
579 old_to_new_id[
i] = new_nbr_coords;
585 for (
size_t i = 0;
i < *temp_nbr_coords; ++
i)
586 if (old_to_new_id[
i] <= 0)
587 old_to_new_id[
i] = old_to_new_id[-old_to_new_id[
i]];
589 *temp_nbr_coords = new_nbr_coords;
void yac_read_part_mpiom_grid_information(const char *filename, int *num_vertices, int *num_cells, int **num_vertices_per_cell, int **cell_to_vertex, double **x_vertices, double **y_vertices, double **x_cells, double **y_cells, int **global_cell_id, int **cell_mask, int **cell_core_mask, int **global_corner_id, int **corner_core_mask, int rank, int size)