basic_grid.c

Go to the documentation of this file.

// Copyright (c) 2024 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <stdio.h>
#include <string.h>
 
#include "basic_grid.h"
#include "grid_cell.h"
#include "field_data_set.h"
 
struct yac_basic_grid {
  char * name;
  int is_empty;
  struct yac_field_data_set * field_data_set;
  struct yac_basic_grid_data data;
};
 
static struct yac_basic_grid_data yac_basic_grid_data_empty = {
  .vertex_coordinates = NULL,
  .cell_ids = NULL,
  .vertex_ids = NULL,
  .edge_ids = NULL,
  .num_cells = 0,
  .num_vertices = 0,
  .num_edges = 0,
  .core_cell_mask = NULL,
  .core_vertex_mask = NULL,
  .core_edge_mask = NULL,
  .num_vertices_per_cell = NULL,
  .num_cells_per_vertex = NULL,
  .cell_to_vertex = NULL,
  .cell_to_vertex_offsets = NULL,
  .cell_to_edge = NULL,
  .cell_to_edge_offsets = NULL,
  .vertex_to_cell = NULL,
  .vertex_to_cell_offsets = NULL,
  .edge_to_vertex = NULL,
  .edge_type = NULL,
  .num_total_cells = 0,
  .num_total_vertices = 0,
  .num_total_edges = 0
};
 
struct yac_basic_grid * yac_basic_grid_new(
  char const * name, struct yac_basic_grid_data grid_data) {
 
  struct yac_basic_grid * grid = xmalloc(1 * sizeof(*grid));
 
  grid->name = strdup(name);
  grid->is_empty = 0;
  grid->field_data_set = yac_field_data_set_empty_new();
  grid->data = grid_data;
 
  return grid;
};
 
struct yac_basic_grid * yac_basic_grid_empty_new(char const * name) {
  struct yac_basic_grid * grid =
    yac_basic_grid_new(name, yac_basic_grid_data_empty);
  grid->is_empty = 1;
  return grid;
}
 
void yac_basic_grid_delete(struct yac_basic_grid * grid) {
 
  YAC_ASSERT(
    grid, "ERROR(yac_basic_grid_delete): "
    "NULL is not a valid value for argument grid")
  free(grid->name);
  yac_field_data_set_delete(grid->field_data_set);
  yac_basic_grid_data_free(grid->data);
  free(grid);
}
 
yac_const_coordinate_pointer yac_basic_grid_get_field_coordinates(
  struct yac_basic_grid * grid, struct yac_interp_field field) {
 
  YAC_ASSERT(
    grid, "ERROR(yac_basic_grid_get_field_coordinates): "
    "NULL is not a valid value for argument grid")
 
  yac_const_coordinate_pointer coords =
    (field.coordinates_idx != SIZE_MAX)?
      yac_field_data_get_coordinates_data(
        yac_basic_grid_get_field_data(grid, field.location),
        field.coordinates_idx):NULL;
 
  // if no field coordinates are defined, but the location is at the corners of
  // of the grid cells, return coordinates of them
  return
    ((coords != NULL) || (field.location != YAC_LOC_CORNER))?
       coords:((yac_const_coordinate_pointer)(grid->data.vertex_coordinates));
}
 
int const * yac_basic_grid_get_core_mask(
  struct yac_basic_grid * grid, enum yac_location location) {
 
  YAC_ASSERT(
    (location == YAC_LOC_CELL) ||
    (location == YAC_LOC_CORNER) ||
    (location == YAC_LOC_EDGE),
    "ERROR(yac_basic_grid_get_core_mask): invalid location")
 
  switch (location) {
    default:
    case(YAC_LOC_CELL): return grid->data.core_cell_mask;
    case(YAC_LOC_CORNER): return grid->data.core_vertex_mask;
    case(YAC_LOC_EDGE): return grid->data.core_edge_mask;
  };
}
 
int const * yac_basic_grid_get_field_mask(
  struct yac_basic_grid * grid, struct yac_interp_field field) {
 
  if (field.masks_idx == SIZE_MAX) return NULL;
 
  return
    yac_field_data_get_mask_data(
      yac_basic_grid_get_field_data(grid, field.location), field.masks_idx);
}
 
char const * yac_basic_grid_get_name(struct yac_basic_grid * grid) {
 
  YAC_ASSERT(
    grid, "ERROR(yac_basic_grid_get_name): "
    "NULL is not a valid value for argument grid")
 
  return grid->name;
}
 
struct yac_basic_grid_data * yac_basic_grid_get_data(
  struct yac_basic_grid * grid) {
 
  YAC_ASSERT(
    grid, "ERROR(yac_basic_grid_get_data): "
    "NULL is not a valid value for argument grid")
 
  return &(grid->data);
}
 
size_t yac_basic_grid_get_data_size(
  struct yac_basic_grid * grid, enum yac_location location) {
 
  YAC_ASSERT(
    grid, "ERROR(yac_basic_grid_get_data_size): "
    "NULL is not a valid value for argument grid")
  YAC_ASSERT(
    (location == YAC_LOC_CELL) ||
    (location == YAC_LOC_CORNER) ||
    (location == YAC_LOC_EDGE),
    "ERROR(yac_basic_grid_get_data_size): invalid location")
 
  switch (location) {
    default:
    case (YAC_LOC_CELL):
      return grid->data.num_cells;
    case (YAC_LOC_CORNER):
      return grid->data.num_vertices;
    case (YAC_LOC_EDGE):
      return grid->data.num_edges;
  };
}
 
size_t yac_basic_grid_get_data_size_f2c(
  struct yac_basic_grid * grid, int location) {
 
  return
    yac_basic_grid_get_data_size(grid, yac_get_location(location));
}
 
size_t yac_basic_grid_get_named_mask_idx(
  struct yac_basic_grid * grid, enum yac_location location,
  char const * mask_name) {
 
  if (mask_name == NULL) return SIZE_MAX;
 
  struct yac_field_data * data =
    yac_basic_grid_get_field_data(grid, location);
 
  if (data == NULL) return SIZE_MAX;
 
  size_t mask_idx = SIZE_MAX;
  size_t masks_count = yac_field_data_get_masks_count(data);
 
  for (size_t i = 0; (i < masks_count) && (mask_idx == SIZE_MAX); ++i) {
    char const * curr_mask_name =
      yac_field_data_get_mask_name(data, i);
    if ((curr_mask_name != NULL) &&
        (!strcmp(mask_name, curr_mask_name)))
      mask_idx = i;
  }
 
  YAC_ASSERT_F(
    mask_idx != SIZE_MAX,
    "ERROR(yac_basic_grid_get_named_mask_idx): grid \"%s\" does not contain "
    "%s-mask with the name \"%s\"",
    grid->name, yac_loc2str(location), mask_name)
 
  return mask_idx;
}
 
size_t yac_basic_grid_add_coordinates_nocpy(
  struct yac_basic_grid * grid,
  enum yac_location location, yac_coordinate_pointer coordinates) {
 
  YAC_ASSERT(
    grid, "ERROR(yac_basic_grid_add_coordinates_nocpy): "
    "NULL is not a valid value for argument grid")
  YAC_ASSERT_F(
    !grid->is_empty, "ERROR(yac_basic_grid_add_coordinates_nocpy): "
    "grid \"%s\" is an empty grid", grid->name)
 
  return
    yac_field_data_set_add_coordinates_nocpy(
      grid->field_data_set, location, coordinates);
}
 
size_t yac_basic_grid_add_coordinates_nocpy_f2c(
  struct yac_basic_grid * grid, int location, double * coordinates) {
 
  return
    yac_basic_grid_add_coordinates_nocpy(
      grid, yac_get_location(location), (yac_coordinate_pointer)coordinates);
}
 
size_t yac_basic_grid_add_coordinates(
  struct yac_basic_grid * grid, enum yac_location location,
  yac_coordinate_pointer coordinates, size_t count) {
 
  YAC_ASSERT(
    grid, "ERROR(yac_basic_grid_add_coordinates): "
    "NULL is not a valid value for argument grid")
  YAC_ASSERT_F(
    !grid->is_empty, "ERROR(yac_basic_grid_add_coordinates): "
    "grid \"%s\" is an empty grid", grid->name)
 
  return
    yac_field_data_set_add_coordinates(
      grid->field_data_set, location, coordinates, count);
}
 
size_t yac_basic_grid_add_coordinates_f2c(
  struct yac_basic_grid * grid, int location,
  double * coordinates, size_t count) {
 
  return
    yac_basic_grid_add_coordinates(
      grid, yac_get_location(location),
      (yac_coordinate_pointer)coordinates, count);
}
 
size_t yac_basic_grid_add_mask_nocpy(
  struct yac_basic_grid * grid,
  enum yac_location location, int const * mask,
  char const * mask_name) {
 
  YAC_ASSERT(
    grid, "ERROR(yac_basic_grid_add_mask_nocpy): "
    "NULL is not a valid value for argument grid")
  YAC_ASSERT_F(
    !grid->is_empty, "ERROR(yac_basic_grid_add_mask_nocpy): "
    "grid \"%s\" is an empty grid", grid->name)
 
  return
    yac_field_data_set_add_mask_nocpy(
      grid->field_data_set, location, mask, mask_name);
}
 
size_t yac_basic_grid_add_mask_nocpy_f2c(
  struct yac_basic_grid * grid, int location,
  int const * mask, char const * mask_name) {
 
  return
    yac_basic_grid_add_mask_nocpy(
      grid, yac_get_location(location), mask, mask_name);
}
 
size_t yac_basic_grid_add_mask(
  struct yac_basic_grid * grid, enum yac_location location,
  int const * mask, size_t count, char const * mask_name) {
 
  YAC_ASSERT(
    grid, "ERROR(yac_basic_grid_add_mask): "
    "NULL is not a valid value for argument grid")
  YAC_ASSERT_F(
    !grid->is_empty, "ERROR(yac_basic_grid_add_mask): "
    "grid \"%s\" is an empty grid", grid->name)
 
  return
    yac_field_data_set_add_mask(
      grid->field_data_set, location, mask, count, mask_name);
}
 
size_t yac_basic_grid_add_mask_f2c(
  struct yac_basic_grid * grid, int location,
  int const * mask, size_t count, char const * mask_name) {
 
  return
    yac_basic_grid_add_mask(
      grid, yac_get_location(location), mask, count, mask_name);
}
 
struct yac_field_data * yac_basic_grid_get_field_data(
  struct yac_basic_grid * grid, enum yac_location location) {
 
  YAC_ASSERT(
    grid, "ERROR(yac_basic_grid_get_field_data): "
    "NULL is not a valid value for argument grid")
 
  if (grid->is_empty)
    return NULL;
  else
    return
      yac_field_data_set_get_field_data(
        grid->field_data_set, location);
}
 
struct yac_basic_grid * yac_basic_grid_reg_2d_new(
  char const * name, size_t nbr_vertices[2], int cyclic[2],
  double *lon_vertices, double *lat_vertices) {
 
  return
    yac_basic_grid_new(
      name,
      yac_generate_basic_grid_data_reg_2d(
        nbr_vertices, cyclic, lon_vertices, lat_vertices));
}
 
struct yac_basic_grid * yac_basic_grid_reg_2d_deg_new(
  char const * name, size_t nbr_vertices[2], int cyclic[2],
  double *lon_vertices, double *lat_vertices) {
 
  return
    yac_basic_grid_new(
      name,
      yac_generate_basic_grid_data_reg_2d_deg(
        nbr_vertices, cyclic, lon_vertices, lat_vertices));
}
 
struct yac_basic_grid * yac_basic_grid_curve_2d_new(
  char const * name, size_t nbr_vertices[2], int cyclic[2],
  double *lon_vertices, double *lat_vertices) {
 
  return
    yac_basic_grid_new(
      name,
      yac_generate_basic_grid_data_curve_2d(
        nbr_vertices, cyclic, lon_vertices, lat_vertices));
}
 
struct yac_basic_grid * yac_basic_grid_curve_2d_deg_new(
  char const * name, size_t nbr_vertices[2], int cyclic[2],
  double *lon_vertices, double *lat_vertices) {
 
  return
    yac_basic_grid_new(
      name,
      yac_generate_basic_grid_data_curve_2d_deg(
        nbr_vertices, cyclic, lon_vertices, lat_vertices));
}
 
struct yac_basic_grid * yac_basic_grid_unstruct_new(
  char const * name, size_t nbr_vertices, size_t nbr_cells,
  int *num_vertices_per_cell, double *x_vertices, double *y_vertices,
  int *cell_to_vertex) {
 
  return
    yac_basic_grid_new(
      name,
      yac_generate_basic_grid_data_unstruct(
        nbr_vertices, nbr_cells, num_vertices_per_cell,
        x_vertices, y_vertices, cell_to_vertex));
}
 
struct yac_basic_grid * yac_basic_grid_unstruct_deg_new(
  char const * name, size_t nbr_vertices, size_t nbr_cells,
  int *num_vertices_per_cell, double *x_vertices, double *y_vertices,
  int *cell_to_vertex) {
 
  return
    yac_basic_grid_new(
      name,
      yac_generate_basic_grid_data_unstruct_deg(
        nbr_vertices, nbr_cells, num_vertices_per_cell,
        x_vertices, y_vertices, cell_to_vertex));
}
 
struct yac_basic_grid * yac_basic_grid_unstruct_ll_new(
  char const * name, size_t nbr_vertices, size_t nbr_cells,
  int *num_vertices_per_cell, double *x_vertices, double *y_vertices,
  int *cell_to_vertex) {
 
  return
    yac_basic_grid_new(
      name,
      yac_generate_basic_grid_data_unstruct_ll(
        nbr_vertices, nbr_cells, num_vertices_per_cell,
        x_vertices, y_vertices, cell_to_vertex));
}
 
struct yac_basic_grid * yac_basic_grid_unstruct_ll_deg_new(
  char const * name, size_t nbr_vertices, size_t nbr_cells,
  int *num_vertices_per_cell, double *x_vertices, double *y_vertices,
  int *cell_to_vertex) {
 
  return
    yac_basic_grid_new(
      name,
      yac_generate_basic_grid_data_unstruct_ll_deg(
        nbr_vertices, nbr_cells, num_vertices_per_cell,
        x_vertices, y_vertices, cell_to_vertex));
}