test_instance_parallel5.c

Go to the documentation of this file.

// Copyright (c) 2026 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#include <mpi.h>
 
#include "tests.h"
#include "test_common.h"
#include "instance.h"
#include "yac.h"
#include "yac_mpi.h"
#include "event.h"
 
static void utest_shared_comp_couple();
 
int main(void) {
 
  yac_mpi_init();
  yac_yaxt_init(MPI_COMM_WORLD);
 
  int size;
  MPI_Comm_size(MPI_COMM_WORLD, &size);
 
  enum {NUM_PROCS = 4};
  if (size != NUM_PROCS) {
    PUT_ERR("ERROR: wrong number of processes\n");
    return TEST_EXIT_CODE;
  }
 
  yac_cdef_calendar(YAC_PROLEPTIC_GREGORIAN);
 
  utest_shared_comp_couple();
 
  yac_mpi_finalize();
 
  return TEST_EXIT_CODE;
}
 
static void utest_shared_comp_couple() {
 
  struct yac_instance * instance =
    yac_instance_new(MPI_COMM_WORLD);
  yac_instance_def_datetime(
    instance, "2008-03-09T16:05:07", "2008-03-10T16:05:07");
 
  char const * comp_names[] = {"comp_0", "comp_1", "comp_2"};
  yac_instance_def_components(instance, comp_names, 3);
 
  size_t num_vertices[2] = {2, 2};
  int cyclic[2] = {0, 0};
  double coordinates_x[2] = {0.0, 1.0};
  double coordinates_y[2] = {0.0, 1.0};
  yac_int global_cell_ids[1] = {0};
  yac_int global_corner_ids[4] = {0, 1, 2, 3};
  int cell_core_mask[1] = {1};
  int corner_core_mask[4] = {1, 1, 1, 1};
 
  char const * src_grid_name = "shared_src_grid";
  char const * tgt_grid_name = "shared_tgt_grid";
  struct yac_basic_grid_data src_grid_data =
      yac_generate_basic_grid_data_reg_2d_deg(
        num_vertices, cyclic, coordinates_x, coordinates_y);
    src_grid_data.cell_ids = TO_POINTER(global_cell_ids);
    src_grid_data.vertex_ids = TO_POINTER(global_corner_ids);
    src_grid_data.core_cell_mask = TO_POINTER(cell_core_mask);
    src_grid_data.core_vertex_mask = TO_POINTER(corner_core_mask);
  struct yac_basic_grid_data tgt_grid_data =
      yac_generate_basic_grid_data_reg_2d_deg(
        num_vertices, cyclic, coordinates_x, coordinates_y);
    tgt_grid_data.cell_ids = TO_POINTER(global_cell_ids);
    tgt_grid_data.vertex_ids = TO_POINTER(global_corner_ids);
    tgt_grid_data.core_cell_mask = TO_POINTER(cell_core_mask);
    tgt_grid_data.core_vertex_mask = TO_POINTER(corner_core_mask);
  struct yac_basic_grid * src_grid =
    yac_basic_grid_new(src_grid_name, src_grid_data);
  struct yac_basic_grid * tgt_grid =
    yac_basic_grid_new(tgt_grid_name, tgt_grid_data);
 
  char * timestep = strdup(yac_time_to_ISO("10", C_SECOND));
  char const * field_name = "field_a";
  struct yac_interp_field interp_field;
  interp_field.location = YAC_LOC_CORNER;
  interp_field.coordinates_idx =
    yac_basic_grid_add_coordinates(
      src_grid, YAC_LOC_CORNER,
      src_grid_data.vertex_coordinates, src_grid_data.num_vertices);
  interp_field.masks_idx = SIZE_MAX;
  yac_instance_add_field(
    instance, field_name, comp_names[0], src_grid,
    &interp_field, 1, 1, timestep);
  interp_field.coordinates_idx =
    yac_basic_grid_add_coordinates(
      tgt_grid, YAC_LOC_CORNER,
      tgt_grid_data.vertex_coordinates, tgt_grid_data.num_vertices);
  yac_instance_add_field(
    instance, field_name, comp_names[1], tgt_grid,
    &interp_field, 1, 1, timestep);
  yac_instance_add_field(
    instance, field_name, comp_names[2], tgt_grid,
    &interp_field, 1, 1, timestep);
 
  struct yac_interp_stack_config * interp_stack =
    yac_interp_stack_config_new();
  char const * coupling_period = timestep;
  yac_interp_stack_config_add_fixed(interp_stack, -1.0);
 
  // Same source/grid/field, only target component differs.
  yac_instance_def_couple(instance,
    comp_names[0], src_grid_name, field_name,
    comp_names[1], tgt_grid_name, field_name,
    coupling_period, YAC_REDUCTION_TIME_NONE, interp_stack, 0, 0, NULL,
    YAC_WEIGHT_FILE_ON_EXISTING_DEFAULT_VALUE, 0, 1.0, 0.0, 0, NULL, NULL,
    NULL, NULL, 0);
  yac_instance_def_couple(instance,
    comp_names[0], src_grid_name, field_name,
    comp_names[2], tgt_grid_name, field_name,
    coupling_period, YAC_REDUCTION_TIME_NONE, interp_stack, 0, 0, NULL,
    YAC_WEIGHT_FILE_ON_EXISTING_DEFAULT_VALUE, 0, 1.0, 0.0, 0, NULL, NULL,
    NULL, NULL, 0);
 
  free(timestep);
  yac_interp_stack_config_delete(interp_stack);
 
  struct yac_basic_grid * grids[2] = {src_grid, tgt_grid};
  yac_instance_setup(instance, grids, 2);
 
  yac_instance_delete(instance);
  if (tgt_grid != NULL) yac_basic_grid_delete(tgt_grid);
  if (src_grid != NULL) yac_basic_grid_delete(src_grid);
}