test_interp_stack_config.c

Go to the documentation of this file.

// Copyright (c) 2024 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <mpi.h>
#include <yaxt.h>
#include "tests.h"
#include "dist_grid_utils.h"
#include "interpolation/interp_stack_config.h"
#include "interpolation/methods/interp_method_spmap.h"
#include "geometry.h"
 
#define ARGS(...) __VA_ARGS__
#define _GET_NTH_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, N, ...) N
#define EXPAND(x) x
#define FOREACH(name, ...) \
  { \
    enum {NUM_ ## name = sizeof( name ) / sizeof( name [0])}; \
    int name ## _idx[2]; \
    for (name ## _idx[0] = 0; name ## _idx[0] < NUM_ ## name; \
         ++ name ## _idx[0]) { \
      for (name ## _idx[1] = 0; name ## _idx[1] < NUM_ ## name; \
           ++ name ## _idx[1]) { \
        configs_differ += (name ## _idx[0]) != (name ## _idx[1]); \
        {__VA_ARGS__} \
        configs_differ -= (name ## _idx[0]) != (name ## _idx[1]); \
      } \
    } \
  }
#define FOREACH_ENUM(name, values, ...) \
  { \
    enum yac_ ## name name [] = {values}; \
    FOREACH(name, __VA_ARGS__) \
  }
#define FOREACH_TYPE(name, type, values, ...) \
  { \
    type name[] = {values}; \
    FOREACH(name, __VA_ARGS__) \
  }
#define FOREACH_INT(name, values, ...) \
  FOREACH_TYPE(name, int, ARGS(values), __VA_ARGS__)
#define FOREACH_DBLE(name, values, ...) \
  FOREACH_TYPE(name, double, ARGS(values), __VA_ARGS__)
#define FOREACH_BOOL(name, ...) FOREACH_INT(name, ARGS(0, 1), __VA_ARGS__)
#define FOREACH_STRING(name, values, ...) \
  FOREACH_TYPE(name, ARGS(char const *), ARGS(values), __VA_ARGS__)
#define FOREACH_STRUCT(name, struct_name, values, ...) \
  FOREACH_TYPE(name, ARGS(struct struct_name), ARGS(values), __VA_ARGS__)
#define _CHECK_STACKS(interp_name, config) \
  { \
    int config_idx; \
    struct yac_interp_stack_config * a = yac_interp_stack_config_new(); \
    struct yac_interp_stack_config * b = yac_interp_stack_config_new(); \
    config_idx = 0, yac_interp_stack_config_add_ ## interp_name ( a, config ); \
    config_idx = 1, yac_interp_stack_config_add_ ## interp_name ( b, config ); \
    utest_check_compare_stacks(a, b, configs_differ); \
  }
#define _CONFIG_ARGS1(arg_name) arg_name[arg_name ## _idx[config_idx]]
#define _CONFIG_ARGS2(arg_name, ...) \
  _CONFIG_ARGS1(arg_name), _CONFIG_ARGS1(__VA_ARGS__)
#define _CONFIG_ARGS3(arg_name, ...) \
  _CONFIG_ARGS1(arg_name), _CONFIG_ARGS2(__VA_ARGS__)
#define _CONFIG_ARGS4(arg_name, ...) \
  _CONFIG_ARGS1(arg_name), _CONFIG_ARGS3(__VA_ARGS__)
#define _CONFIG_ARGS5(arg_name, ...) \
  _CONFIG_ARGS1(arg_name), _CONFIG_ARGS4(__VA_ARGS__)
#define _CONFIG_ARGS6(arg_name, ...) \
  _CONFIG_ARGS1(arg_name), _CONFIG_ARGS5(__VA_ARGS__)
#define _CONFIG_ARGS7(arg_name, ...) \
  _CONFIG_ARGS1(arg_name), _CONFIG_ARGS6(__VA_ARGS__)
#define _CONFIG_ARGS8(arg_name, ...) \
  _CONFIG_ARGS1(arg_name), _CONFIG_ARGS7(__VA_ARGS__)
#define _CONFIG_ARGS9(arg_name, ...) \
  _CONFIG_ARGS1(arg_name), _CONFIG_ARGS8(__VA_ARGS__)
#define _CONFIG_ARGS10(arg_name, ...) \
  _CONFIG_ARGS1(arg_name), _CONFIG_ARGS9(__VA_ARGS__)
#define _CONFIG_ARGS11(arg_name, ...) \
  _CONFIG_ARGS1(arg_name), _CONFIG_ARGS10(__VA_ARGS__)
#define _CONFIG_ARGS12(arg_name, ...) \
  _CONFIG_ARGS1(arg_name), _CONFIG_ARGS11(__VA_ARGS__)
#define CHECK_STACKS(interp_name, ... ) \
  _CHECK_STACKS(interp_name, \
    EXPAND(_GET_NTH_ARG(__VA_ARGS__, _CONFIG_ARGS12, \
                                     _CONFIG_ARGS11, \
                                     _CONFIG_ARGS10, \
                                     _CONFIG_ARGS9, \
                                     _CONFIG_ARGS8, \
                                     _CONFIG_ARGS7, \
                                     _CONFIG_ARGS6, \
                                     _CONFIG_ARGS5, \
                                     _CONFIG_ARGS4, \
                                     _CONFIG_ARGS3, \
                                     _CONFIG_ARGS2, \
                                     _CONFIG_ARGS1)(__VA_ARGS__)))
 
static void utest_check_compare_stacks(
  struct yac_interp_stack_config * a, struct yac_interp_stack_config * b,
  int configs_differ);
 
static void utest_interp_stack_config_add_spmap_(
  struct yac_interp_stack_config * interp_stack_config,
  double spread_distance, double max_search_distance,
  enum yac_interp_spmap_weight_type weight_type,
  enum yac_interp_spmap_scale_type scale_type,
  struct yac_spmap_cell_area_config * src_cell_area_config,
  struct yac_spmap_cell_area_config * tgt_cell_area_config);
 
#define yac_interp_stack_config_add_spmap_ utest_interp_stack_config_add_spmap_
 
int main (void) {
 
  MPI_Init(NULL, NULL);
  xt_initialize(MPI_COMM_WORLD);
 
  int configs_differ = 0;
 
  { // stack with different sizes
    struct yac_interp_stack_config * a = yac_interp_stack_config_new();
    struct yac_interp_stack_config * b = yac_interp_stack_config_new();
    yac_interp_stack_config_add_average(a, YAC_INTERP_AVG_ARITHMETIC, 1);
    yac_interp_stack_config_add_fixed(a, -1.0);
    yac_interp_stack_config_add_average(a, YAC_INTERP_AVG_ARITHMETIC, 1);
    utest_check_compare_stacks(a, b, 1);
  }
 
  { // compare empty config
    struct yac_interp_stack_config * a = yac_interp_stack_config_new();
    struct yac_interp_stack_config * b = yac_interp_stack_config_new();
    utest_check_compare_stacks(a, b, 0);
  }
 
  // compare average config
  FOREACH_ENUM(
    interp_avg_weight_type,
    ARGS(YAC_INTERP_AVG_ARITHMETIC, YAC_INTERP_AVG_DIST, YAC_INTERP_AVG_BARY),
    FOREACH_BOOL(
      partial_coverage,
      CHECK_STACKS(average, interp_avg_weight_type, partial_coverage)))
 
  // compare ncc config
  FOREACH_ENUM(
    interp_ncc_weight_type,
    ARGS(YAC_INTERP_NCC_AVG, YAC_INTERP_NCC_DIST),
    FOREACH_BOOL(
      partial_coverage,
      CHECK_STACKS(ncc, interp_ncc_weight_type, partial_coverage)))
 
  // compare nnn config
  //  for YAC_INTERP_NNN_AVG, YAC_INTERP_NNN_DIST, and YAC_INTERP_NNN_ZERO
  //  the scale parameter is being ignored
  FOREACH_ENUM(
    interp_nnn_weight_type,
    ARGS(YAC_INTERP_NNN_AVG, YAC_INTERP_NNN_DIST, YAC_INTERP_NNN_ZERO),
    FOREACH_INT(
      counts, ARGS(1,3,9),
      FOREACH_DBLE(
        max_search_distance, ARGS(0.0, M_PI_2),
        FOREACH_DBLE(
          scales, -1.0,
          CHECK_STACKS(
            nnn, interp_nnn_weight_type, counts,
            max_search_distance, scales)))))
 
  // compare nnn config
  //   for YAC_INTERP_NNN_GAUSS and YAC_INTERP_NNN_RBF the scale
  //   parameter is being interpreted
  FOREACH_ENUM(
    interp_nnn_weight_type,
    ARGS(YAC_INTERP_NNN_GAUSS, YAC_INTERP_NNN_RBF),
    FOREACH_INT(
      counts, ARGS(1,3,9),
      FOREACH_DBLE(
        max_search_distance, ARGS(0.0, M_PI_2),
        FOREACH_DBLE(
          scales, ARGS(0.5, 1.0),
          CHECK_STACKS(
            nnn, interp_nnn_weight_type, counts,
            max_search_distance, scales)))))
 
  // compare dnn config
  //  for YAC_INTERP_DNN_AVG and YAC_INTERP_DNN_DIST
  //  the scale parameter is being ignored
  FOREACH_ENUM(
    interp_dnn_weight_type,
    ARGS(YAC_INTERP_DNN_WEIGHT_AVG, YAC_INTERP_DNN_WEIGHT_DIST),
    FOREACH_ENUM(
      interp_dnn_search_distance_type,
      ARGS(YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED, YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA),
      FOREACH_DBLE(
        search_distances, ARGS(0.0, M_PI_2),
        FOREACH_DBLE(
          scales, -1.0,
          CHECK_STACKS(
            dnn, interp_dnn_weight_type, interp_dnn_search_distance_type,
            search_distances, scales)))))
 
  // compare dnn config
  //   for YAC_INTERP_DNN_GAUSS and YAC_INTERP_DNN_RBF the scale
  //   parameter is being interpreted
  FOREACH_ENUM(
    interp_dnn_weight_type,
    ARGS(YAC_INTERP_DNN_WEIGHT_GAUSS, YAC_INTERP_DNN_WEIGHT_RBF),
    FOREACH_ENUM(
      interp_dnn_search_distance_type,
      ARGS(YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED, YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA),
      FOREACH_DBLE(
        search_distances, ARGS(0.0, M_PI_2),
        FOREACH_DBLE(
          scales, ARGS(0.5, 1.0),
          CHECK_STACKS(
            dnn, interp_dnn_weight_type, interp_dnn_search_distance_type,
            search_distances, scales)))))
 
  // compare conservative config
  FOREACH_INT(
    order, ARGS(1,2),
    FOREACH_BOOL(
      enforced_conserv,
      FOREACH_BOOL(
        partial_coverage,
        FOREACH_ENUM(
          interp_method_conserv_normalisation,
          ARGS(YAC_INTERP_CONSERV_DESTAREA, YAC_INTERP_CONSERV_FRACAREA),
          CHECK_STACKS(conservative,
            order, enforced_conserv, partial_coverage,
            interp_method_conserv_normalisation)))))
 
  // compare source point mapping
  {
    struct yac_spmap_cell_area_config * cell_area_configs[] = {
        yac_spmap_cell_area_config_yac_new(1.0),
        yac_spmap_cell_area_config_yac_new(2.0),
        yac_spmap_cell_area_config_file_new("area.nc", "cell_area", 0),
        yac_spmap_cell_area_config_file_new("area.nc_", "cell_area", 0),
        yac_spmap_cell_area_config_file_new("area.nc", "cell_area_", 0),
        yac_spmap_cell_area_config_file_new("area.nc", "cell_area", 1),
        yac_spmap_cell_area_config_file_new("area.nc_", "cell_area_", 1),
      };
    enum {
      NUM_CELL_AREA_CONFIGS =
        sizeof(cell_area_configs) / sizeof(cell_area_configs[0])};
 
    FOREACH_TYPE(
      src_cell_area_config, ARGS(struct yac_spmap_cell_area_config *),
      ARGS(
        cell_area_configs[0], cell_area_configs[1], cell_area_configs[2],
        cell_area_configs[3], cell_area_configs[4], cell_area_configs[5],
        cell_area_configs[6]),
      FOREACH_TYPE(
        tgt_cell_area_config, ARGS(struct yac_spmap_cell_area_config *),
        ARGS(
          cell_area_configs[0], cell_area_configs[1], cell_area_configs[2],
          cell_area_configs[3], cell_area_configs[4], cell_area_configs[5],
          cell_area_configs[6]),
        FOREACH_DBLE(
          spread_distance, ARGS(0.0, 0.1),
          FOREACH_DBLE(
            max_search_distance, ARGS(0.0, 0.4),
            FOREACH_ENUM(
              interp_spmap_weight_type,
              ARGS(YAC_INTERP_SPMAP_AVG, YAC_INTERP_SPMAP_DIST),
              FOREACH_ENUM(
                interp_spmap_scale_type,
                ARGS(
                  YAC_INTERP_SPMAP_NONE, YAC_INTERP_SPMAP_SRCAREA,
                  YAC_INTERP_SPMAP_INVTGTAREA, YAC_INTERP_SPMAP_FRACAREA),
                CHECK_STACKS(spmap_,
                  spread_distance, max_search_distance,
                  interp_spmap_weight_type, interp_spmap_scale_type,
                  src_cell_area_config, tgt_cell_area_config)))))))
 
    for (size_t i = 0; i < NUM_CELL_AREA_CONFIGS; ++i)
      yac_spmap_cell_area_config_delete(cell_area_configs[i]);
  }
 
  // compare source point mapping extended
  {
    struct yac_spmap_scale_config * scale_config_custom =
      yac_spmap_scale_config_new(YAC_INTERP_SPMAP_FRACAREA, NULL, NULL);
    struct yac_interp_spmap_config * default_configs[] = {
        YAC_INTERP_SPMAP_DEFAULT_CONFIG,
        yac_interp_spmap_config_new(
          1.0,
          YAC_INTERP_SPMAP_MAX_SEARCH_DISTANCE_DEFAULT,
          YAC_INTERP_SPMAP_WEIGHTED_DEFAULT,
          YAC_INTERP_SPMAP_SCALE_CONFIG_DEFAULT),
        yac_interp_spmap_config_new(
          YAC_INTERP_SPMAP_SPREAD_DISTANCE_DEFAULT,
          1.0,
          YAC_INTERP_SPMAP_WEIGHTED_DEFAULT,
          YAC_INTERP_SPMAP_SCALE_CONFIG_DEFAULT),
        yac_interp_spmap_config_new(
          YAC_INTERP_SPMAP_SPREAD_DISTANCE_DEFAULT,
          YAC_INTERP_SPMAP_MAX_SEARCH_DISTANCE_DEFAULT,
          YAC_INTERP_SPMAP_DIST,
          YAC_INTERP_SPMAP_SCALE_CONFIG_DEFAULT),
        yac_interp_spmap_config_new(
          YAC_INTERP_SPMAP_SPREAD_DISTANCE_DEFAULT,
          YAC_INTERP_SPMAP_MAX_SEARCH_DISTANCE_DEFAULT,
          YAC_INTERP_SPMAP_WEIGHTED_DEFAULT,
          scale_config_custom),
      };
    enum {
      NUM_DEFAULT_CONFIGS =
        sizeof(default_configs)/sizeof(default_configs[0])};
 
    struct yac_point_selection * bnd_point_selection_a =
      yac_point_selection_bnd_circle_new(0.1, 0.1, 1.0);
    struct yac_point_selection * bnd_point_selection_b =
      yac_point_selection_bnd_circle_new(0.1, 0.1, 2.0);
    struct yac_interp_spmap_config * spmap_config_custom =
      yac_interp_spmap_config_new(
          1.0,
          YAC_INTERP_SPMAP_MAX_SEARCH_DISTANCE_DEFAULT,
          YAC_INTERP_SPMAP_DIST,
          YAC_INTERP_SPMAP_SCALE_CONFIG_DEFAULT);
 
    struct yac_spmap_overwrite_config *** overwrite_configs =
      (struct yac_spmap_overwrite_config **[])
        {NULL,
        (struct yac_spmap_overwrite_config *[]) {
          yac_spmap_overwrite_config_new(bnd_point_selection_a, NULL),
          NULL},
        (struct yac_spmap_overwrite_config *[]) {
          yac_spmap_overwrite_config_new(bnd_point_selection_b, NULL),
          NULL},
        (struct yac_spmap_overwrite_config *[]) {
          yac_spmap_overwrite_config_new(
            bnd_point_selection_b, spmap_config_custom),
          NULL},
        (struct yac_spmap_overwrite_config *[]) {
          yac_spmap_overwrite_config_new(
            bnd_point_selection_a, NULL),
          yac_spmap_overwrite_config_new(
            bnd_point_selection_b, NULL),
          NULL},
        (struct yac_spmap_overwrite_config *[]) {
          yac_spmap_overwrite_config_new(bnd_point_selection_a, NULL),
          yac_spmap_overwrite_config_new(
            bnd_point_selection_b, spmap_config_custom),
          NULL}};
  enum {NUM_OVERWRITE_CONFIGS = 6};
 
  FOREACH_TYPE(
    default_config, ARGS(struct yac_interp_spmap_config *),
    ARGS(
      default_configs[0], default_configs[1],
      default_configs[2], default_configs[3]),
    FOREACH_TYPE(
      overwrite_config, ARGS(struct yac_spmap_overwrite_config **),
      ARGS(
        overwrite_configs[0], overwrite_configs[1], overwrite_configs[2],
        overwrite_configs[3], overwrite_configs[4], overwrite_configs[5]),
      CHECK_STACKS(spmap_ext, default_config, overwrite_config)))
 
    for (size_t i = 0; i < NUM_OVERWRITE_CONFIGS; ++i)
      for (size_t j = 0;
           (overwrite_configs[i] != NULL) && (overwrite_configs[i][j] != NULL);
           ++j)
        yac_spmap_overwrite_config_delete(overwrite_configs[i][j]);
    yac_interp_spmap_config_delete(spmap_config_custom);
    yac_point_selection_delete(bnd_point_selection_a);
    yac_point_selection_delete(bnd_point_selection_b);
    for (size_t i = 0; i < NUM_DEFAULT_CONFIGS; ++i)
      yac_interp_spmap_config_delete(default_configs[i]);
    yac_spmap_scale_config_delete(scale_config_custom);
  }
 
  { // round-trip test for non-empty spmap overwrite list
 
    struct yac_point_selection * point_sel_a =
      yac_point_selection_bnd_circle_new(0.1, 0.2, 0.3);
    struct yac_point_selection * point_sel_b =
      yac_point_selection_bnd_circle_new(-0.4, 0.5, 0.6);
 
    struct yac_interp_spmap_config * overwrite_cfg_a =
      yac_interp_spmap_config_new(
        0.11, 0.21, YAC_INTERP_SPMAP_AVG, YAC_INTERP_SPMAP_SCALE_CONFIG_DEFAULT);
    struct yac_interp_spmap_config * overwrite_cfg_b =
      yac_interp_spmap_config_new(
        0.12, 0.22, YAC_INTERP_SPMAP_DIST, YAC_INTERP_SPMAP_SCALE_CONFIG_DEFAULT);
 
    struct yac_spmap_overwrite_config * overwrite_configs[] = {
      yac_spmap_overwrite_config_new(point_sel_a, overwrite_cfg_a),
      yac_spmap_overwrite_config_new(point_sel_b, overwrite_cfg_b),
      NULL,
    };
 
    struct yac_interp_spmap_config * default_cfg =
      yac_interp_spmap_config_new(
        0.01, 0.02, YAC_INTERP_SPMAP_DIST, YAC_INTERP_SPMAP_SCALE_CONFIG_DEFAULT);
 
    struct yac_interp_stack_config * send_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_spmap_ext(
      send_stack, default_cfg, overwrite_configs);
 
    // verify readback before packing
    {
      union yac_interp_stack_config_entry const * entry =
        yac_interp_stack_config_get_entry(send_stack, 0);
      struct yac_interp_spmap_config const * default_cfg_read = NULL;
      struct yac_spmap_overwrite_config const ** overwrite_cfgs_read = NULL;
      yac_interp_stack_config_entry_get_spmap_ext(
        entry, &default_cfg_read, &overwrite_cfgs_read);
 
      if (yac_interp_spmap_config_compare(default_cfg_read, default_cfg) != 0)
        PUT_ERR("ERROR: spmap default config readback mismatch");
      if (overwrite_cfgs_read == NULL || overwrite_cfgs_read[0] == NULL ||
          overwrite_cfgs_read[1] == NULL || overwrite_cfgs_read[2] != NULL)
        PUT_ERR("ERROR: spmap overwrite list readback size mismatch");
      if (yac_spmap_overwrite_config_compare(
            overwrite_cfgs_read[0], overwrite_configs[0]) != 0)
        PUT_ERR("ERROR: spmap overwrite[0] readback mismatch");
      if (yac_spmap_overwrite_config_compare(
            overwrite_cfgs_read[1], overwrite_configs[1]) != 0)
        PUT_ERR("ERROR: spmap overwrite[1] readback mismatch");
    }
 
    // verify pack/unpack round-trip
    size_t pack_size =
      yac_interp_stack_config_get_pack_size(send_stack, MPI_COMM_SELF);
    int mpi_pack_size = (int)pack_size;
    void * sendbuf = malloc(mpi_pack_size);
    void * recvbuf = malloc(mpi_pack_size);
    int pos = 0;
    yac_interp_stack_config_pack(
      send_stack, sendbuf, mpi_pack_size, &pos, MPI_COMM_SELF);
    MPI_Sendrecv(
      sendbuf, mpi_pack_size, MPI_PACKED, 0, 0,
      recvbuf, mpi_pack_size, MPI_PACKED, 0, 0,
      MPI_COMM_SELF, MPI_STATUS_IGNORE);
    int rpos = 0;
    struct yac_interp_stack_config * recv_stack =
      yac_interp_stack_config_unpack(
        recvbuf, mpi_pack_size, &rpos, MPI_COMM_SELF);
 
    if (yac_interp_stack_config_compare(send_stack, recv_stack) != 0)
      PUT_ERR("ERROR: spmap stack pack/unpack compare mismatch");
 
    {
      union yac_interp_stack_config_entry const * entry =
        yac_interp_stack_config_get_entry(recv_stack, 0);
      struct yac_interp_spmap_config const * default_cfg_read = NULL;
      struct yac_spmap_overwrite_config const ** overwrite_cfgs_read = NULL;
      yac_interp_stack_config_entry_get_spmap_ext(
        entry, &default_cfg_read, &overwrite_cfgs_read);
 
      if (yac_interp_spmap_config_compare(default_cfg_read, default_cfg) != 0)
        PUT_ERR("ERROR: unpacked spmap default config mismatch");
      if (overwrite_cfgs_read == NULL || overwrite_cfgs_read[0] == NULL ||
          overwrite_cfgs_read[1] == NULL || overwrite_cfgs_read[2] != NULL)
        PUT_ERR("ERROR: unpacked spmap overwrite list size mismatch");
      if (yac_spmap_overwrite_config_compare(
            overwrite_cfgs_read[0], overwrite_configs[0]) != 0)
        PUT_ERR("ERROR: unpacked spmap overwrite[0] mismatch");
      if (yac_spmap_overwrite_config_compare(
            overwrite_cfgs_read[1], overwrite_configs[1]) != 0)
        PUT_ERR("ERROR: unpacked spmap overwrite[1] mismatch");
    }
 
    free(sendbuf);
    free(recvbuf);
    yac_interp_stack_config_delete(recv_stack);
    yac_interp_stack_config_delete(send_stack);
    yac_interp_spmap_config_delete(default_cfg);
    yac_spmap_overwrite_config_delete(overwrite_configs[0]);
    yac_spmap_overwrite_config_delete(overwrite_configs[1]);
    yac_interp_spmap_config_delete(overwrite_cfg_a);
    yac_interp_spmap_config_delete(overwrite_cfg_b);
    yac_point_selection_delete(point_sel_a);
    yac_point_selection_delete(point_sel_b);
  }
 
  // compare user file
  FOREACH_STRING(
    filename, ARGS(
      "test_interp_stack_config_file_a.nc",
      "test_interp_stack_config_file_b.nc"),
    FOREACH_ENUM(
      interp_file_on_missing_file,
      ARGS(YAC_INTERP_FILE_MISSING_ERROR, YAC_INTERP_FILE_MISSING_CONT),
      FOREACH_ENUM(
        interp_file_on_success,
        ARGS(YAC_INTERP_FILE_SUCCESS_STOP, YAC_INTERP_FILE_SUCCESS_CONT),
        CHECK_STACKS(
          user_file, filename, interp_file_on_missing_file,
          interp_file_on_success))))
 
  // compare fixed
  FOREACH_DBLE(
    fixed_value, ARGS(-1.0, 0.0, 1.0, NAN),
    CHECK_STACKS(fixed, fixed_value))
 
  // compare check
  FOREACH_STRING(
    constructor_key, ARGS(NULL, "constructor_a", "constructor_b"),
    FOREACH_STRING(
      do_search_key, ARGS(NULL, "do_search_key_a", "do_search_key_b"),
      CHECK_STACKS(check, constructor_key, do_search_key)))
 
  // compare creep
  FOREACH_INT(
    creep_distance, ARGS(-1, 0, 1),
    CHECK_STACKS(creep, creep_distance))
 
  // compare user callback
  FOREACH_STRING(
    compute_weights_key, ARGS("compute_weights_a", "compute_weights_b"),
    CHECK_STACKS(user_callback, compute_weights_key))
 
  { // getter: average
    struct yac_interp_stack_config * interp_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_average(interp_stack, YAC_INTERP_AVG_BARY, 1);
 
    if (yac_interp_stack_config_get_size(interp_stack) != 1)
      PUT_ERR("ERROR: unexpected stack size in average getter test");
 
    union yac_interp_stack_config_entry const * entry =
      yac_interp_stack_config_get_entry(interp_stack, 0);
    if (yac_interp_stack_config_entry_get_type(entry) != YAC_AVERAGE)
      PUT_ERR("ERROR: invalid interpolation type in average getter test");
 
    enum yac_interp_avg_weight_type reduction_type = YAC_INTERP_AVG_ARITHMETIC;
    int partial_coverage = 0;
    yac_interp_stack_config_entry_get_average(
      entry, &reduction_type, &partial_coverage);
    if ((reduction_type != YAC_INTERP_AVG_BARY) || (partial_coverage != 1))
      PUT_ERR("ERROR in yac_interp_stack_config_entry_get_average");
 
    yac_interp_stack_config_delete(interp_stack);
  }
 
  { // getter: ncc
    struct yac_interp_stack_config * interp_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_ncc(interp_stack, YAC_INTERP_NCC_DIST, 0);
 
    if (yac_interp_stack_config_get_size(interp_stack) != 1)
      PUT_ERR("ERROR: unexpected stack size in ncc getter test");
 
    union yac_interp_stack_config_entry const * entry =
      yac_interp_stack_config_get_entry(interp_stack, 0);
    if (yac_interp_stack_config_entry_get_type(entry) !=
        YAC_NEAREST_CORNER_CELLS)
      PUT_ERR("ERROR: invalid interpolation type in ncc getter test");
 
    enum yac_interp_ncc_weight_type type = YAC_INTERP_NCC_AVG;
    int partial_coverage = 1;
    yac_interp_stack_config_entry_get_ncc(entry, &type, &partial_coverage);
    if ((type != YAC_INTERP_NCC_DIST) || (partial_coverage != 0))
      PUT_ERR("ERROR in yac_interp_stack_config_entry_get_ncc");
 
    yac_interp_stack_config_delete(interp_stack);
  }
 
  { // getter: dnn avg
    struct yac_interp_stack_config * interp_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_dnn(
      interp_stack, YAC_INTERP_DNN_WEIGHT_AVG,
      YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED, 0.11, -1.0);
 
    if (yac_interp_stack_config_get_size(interp_stack) != 1)
      PUT_ERR("ERROR: unexpected stack size in dnn avg getter test");
 
    union yac_interp_stack_config_entry const * entry =
      yac_interp_stack_config_get_entry(interp_stack, 0);
    if (yac_interp_stack_config_entry_get_type(entry) !=
        YAC_DISTANCE_NEAREST_NEIGHBOR)
      PUT_ERR("ERROR: invalid interpolation type in dnn avg getter test");
 
    enum yac_interp_dnn_weight_type type = YAC_INTERP_DNN_WEIGHT_AVG;
    enum yac_interp_dnn_search_distance_type search_distance_type =
      YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED;
    double search_distance = -1.0;
    double scale = -1.0;
    yac_interp_stack_config_entry_get_dnn(
      entry, &type, &search_distance_type, &search_distance, &scale);
    if ((type != YAC_INTERP_DNN_WEIGHT_AVG) ||
        (search_distance_type != YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED) ||
        (fabs(search_distance - 0.11) > 1e-12) ||
        (fabs(scale - YAC_INTERP_DNN_DUMMY_SCALE) > 1e-12))
      PUT_ERR("ERROR in yac_interp_stack_config_entry_get_dnn (avg)");
 
    yac_interp_stack_config_delete(interp_stack);
  }
 
  { // getter: dnn dist
    struct yac_interp_stack_config * interp_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_dnn(
      interp_stack, YAC_INTERP_DNN_WEIGHT_DIST,
      YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA, 0.12, -1.0);
 
    if (yac_interp_stack_config_get_size(interp_stack) != 1)
      PUT_ERR("ERROR: unexpected stack size in dnn dist getter test");
 
    union yac_interp_stack_config_entry const * entry =
      yac_interp_stack_config_get_entry(interp_stack, 0);
    if (yac_interp_stack_config_entry_get_type(entry) !=
        YAC_DISTANCE_NEAREST_NEIGHBOR)
      PUT_ERR("ERROR: invalid interpolation type in dnn dist getter test");
 
    enum yac_interp_dnn_weight_type type = YAC_INTERP_DNN_WEIGHT_AVG;
    enum yac_interp_dnn_search_distance_type search_distance_type =
      YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED;
    double search_distance = -1.0;
    double scale = -1.0;
    yac_interp_stack_config_entry_get_dnn(
      entry, &type, &search_distance_type, &search_distance, &scale);
    if ((type != YAC_INTERP_DNN_WEIGHT_DIST) ||
        (search_distance_type != YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA) ||
        (fabs(search_distance - 0.12) > 1e-12) ||
        (fabs(scale - YAC_INTERP_DNN_DUMMY_SCALE) > 1e-12))
      PUT_ERR("ERROR in yac_interp_stack_config_entry_get_dnn (dist)");
 
    yac_interp_stack_config_delete(interp_stack);
  }
 
  { // getter: dnn rbf
    struct yac_interp_stack_config * interp_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_dnn(
      interp_stack, YAC_INTERP_DNN_WEIGHT_RBF,
      YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED, 0.13, 0.91);
 
    if (yac_interp_stack_config_get_size(interp_stack) != 1)
      PUT_ERR("ERROR: unexpected stack size in dnn rbf getter test");
 
    union yac_interp_stack_config_entry const * entry =
      yac_interp_stack_config_get_entry(interp_stack, 0);
    if (yac_interp_stack_config_entry_get_type(entry) !=
        YAC_DISTANCE_NEAREST_NEIGHBOR)
      PUT_ERR("ERROR: invalid interpolation type in dnn rbf getter test");
 
    enum yac_interp_dnn_weight_type type = YAC_INTERP_DNN_WEIGHT_AVG;
    enum yac_interp_dnn_search_distance_type search_distance_type =
      YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED;
    double search_distance = -1.0;
    double scale = -1.0;
    yac_interp_stack_config_entry_get_dnn(
      entry, &type, &search_distance_type, &search_distance, &scale);
    if ((type != YAC_INTERP_DNN_WEIGHT_RBF) ||
        (search_distance_type != YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED) ||
        (fabs(search_distance - 0.13) > 1e-12) ||
        (fabs(scale - 0.91) > 1e-12))
      PUT_ERR("ERROR in yac_interp_stack_config_entry_get_dnn (rbf)");
 
    yac_interp_stack_config_delete(interp_stack);
  }
 
  { // getter: dnn gauss
    struct yac_interp_stack_config * interp_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_dnn(
      interp_stack, YAC_INTERP_DNN_WEIGHT_GAUSS,
      YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA, 0.14, 0.92);
 
    if (yac_interp_stack_config_get_size(interp_stack) != 1)
      PUT_ERR("ERROR: unexpected stack size in dnn gauss getter test");
 
    union yac_interp_stack_config_entry const * entry =
      yac_interp_stack_config_get_entry(interp_stack, 0);
    if (yac_interp_stack_config_entry_get_type(entry) !=
        YAC_DISTANCE_NEAREST_NEIGHBOR)
      PUT_ERR("ERROR: invalid interpolation type in dnn gauss getter test");
 
    enum yac_interp_dnn_weight_type type = YAC_INTERP_DNN_WEIGHT_AVG;
    enum yac_interp_dnn_search_distance_type search_distance_type =
      YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED;
    double search_distance = -1.0;
    double scale = -1.0;
    yac_interp_stack_config_entry_get_dnn(
      entry, &type, &search_distance_type, &search_distance, &scale);
    if ((type != YAC_INTERP_DNN_WEIGHT_GAUSS) ||
        (search_distance_type != YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA) ||
        (fabs(search_distance - 0.14) > 1e-12) ||
        (fabs(scale - 0.92) > 1e-12))
      PUT_ERR("ERROR in yac_interp_stack_config_entry_get_dnn (gauss)");
 
    yac_interp_stack_config_delete(interp_stack);
  }
 
  { // getter: nnn gauss
    struct yac_interp_stack_config * interp_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_nnn(interp_stack, YAC_INTERP_NNN_GAUSS, 5, 0.21, 1.31);
 
    if (yac_interp_stack_config_get_size(interp_stack) != 1)
      PUT_ERR("ERROR: unexpected stack size in nnn getter test");
 
    union yac_interp_stack_config_entry const * entry =
      yac_interp_stack_config_get_entry(interp_stack, 0);
    if (yac_interp_stack_config_entry_get_type(entry) != YAC_N_NEAREST_NEIGHBOR)
      PUT_ERR("ERROR: invalid interpolation type in nnn getter test");
 
    enum yac_interp_nnn_weight_type type = YAC_INTERP_NNN_AVG;
    size_t n = 0;
    double max_search_distance = 0.0;
    double scale = 0.0;
    yac_interp_stack_config_entry_get_nnn(
      entry, &type, &n, &max_search_distance, &scale);
    if ((type != YAC_INTERP_NNN_GAUSS) || (n != 5) ||
        (fabs(max_search_distance - 0.21) > 1e-12) ||
        (fabs(scale - 1.31) > 1e-12))
      PUT_ERR("ERROR in yac_interp_stack_config_entry_get_nnn");
 
    yac_interp_stack_config_delete(interp_stack);
  }
 
  { // getter: rbf
    struct yac_interp_stack_config * interp_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_rbf(interp_stack, 6, 0.22, 1.32);
 
    if (yac_interp_stack_config_get_size(interp_stack) != 1)
      PUT_ERR("ERROR: unexpected stack size in rbf getter test");
 
    union yac_interp_stack_config_entry const * entry =
      yac_interp_stack_config_get_entry(interp_stack, 0);
    if (yac_interp_stack_config_entry_get_type(entry) !=
        YAC_RADIAL_BASIS_FUNCTION)
      PUT_ERR("ERROR: invalid interpolation type in rbf getter test");
 
    enum yac_interp_nnn_weight_type type = YAC_INTERP_NNN_AVG;
    size_t n = 0;
    double max_search_distance = 0.0;
    double scale = 0.0;
    yac_interp_stack_config_entry_get_nnn(
      entry, &type, &n, &max_search_distance, &scale);
    if ((type != YAC_INTERP_NNN_RBF) || (n != 6) ||
        (fabs(max_search_distance - 0.22) > 1e-12) ||
        (fabs(scale - 1.32) > 1e-12))
      PUT_ERR("ERROR in yac_interp_stack_config_entry_get_nnn (rbf)");
 
    n = 0;
    max_search_distance = 0.0;
    scale = 0.0;
    yac_interp_stack_config_entry_get_rbf(entry, &n, &max_search_distance, &scale);
    if ((n != 6) || (fabs(max_search_distance - 0.22) > 1e-12) ||
        (fabs(scale - 1.32) > 1e-12))
      PUT_ERR("ERROR in yac_interp_stack_config_entry_get_rbf");
 
    yac_interp_stack_config_delete(interp_stack);
  }
 
  { // getter: conservative
    struct yac_interp_stack_config * interp_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_conservative(
      interp_stack, 2, 1, 0, YAC_INTERP_CONSERV_FRACAREA);
 
    if (yac_interp_stack_config_get_size(interp_stack) != 1)
      PUT_ERR("ERROR: unexpected stack size in conservative getter test");
 
    union yac_interp_stack_config_entry const * entry =
      yac_interp_stack_config_get_entry(interp_stack, 0);
    if (yac_interp_stack_config_entry_get_type(entry) != YAC_CONSERVATIVE)
      PUT_ERR("ERROR: invalid interpolation type in conservative getter test");
 
    int order = -1;
    int enforced_conserv = -1;
    int partial_coverage = -1;
    enum yac_interp_method_conserv_normalisation normalisation =
      YAC_INTERP_CONSERV_DESTAREA;
    yac_interp_stack_config_entry_get_conservative(
      entry, &order, &enforced_conserv, &partial_coverage, &normalisation);
    if ((order != 2) || (enforced_conserv != 1) || (partial_coverage != 0) ||
        (normalisation != YAC_INTERP_CONSERV_FRACAREA))
      PUT_ERR("ERROR in yac_interp_stack_config_entry_get_conservative");
 
    yac_interp_stack_config_delete(interp_stack);
  }
 
  { // getter: user file
    struct yac_interp_stack_config * interp_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_user_file(
      interp_stack, "test_file.nc",
      YAC_INTERP_FILE_MISSING_CONT, YAC_INTERP_FILE_SUCCESS_STOP);
 
    if (yac_interp_stack_config_get_size(interp_stack) != 1)
      PUT_ERR("ERROR: unexpected stack size in user file getter test");
 
    union yac_interp_stack_config_entry const * entry =
      yac_interp_stack_config_get_entry(interp_stack, 0);
    if (yac_interp_stack_config_entry_get_type(entry) != YAC_USER_FILE)
      PUT_ERR("ERROR: invalid interpolation type in user file getter test");
 
    char const * filename = NULL;
    enum yac_interp_file_on_missing_file on_missing_file =
      YAC_INTERP_FILE_MISSING_ERROR;
    enum yac_interp_file_on_success on_success = YAC_INTERP_FILE_SUCCESS_CONT;
    yac_interp_stack_config_entry_get_user_file(
      entry, &filename, &on_missing_file, &on_success);
    if ((filename == NULL) || strcmp(filename, "test_file.nc") ||
        (on_missing_file != YAC_INTERP_FILE_MISSING_CONT) ||
        (on_success != YAC_INTERP_FILE_SUCCESS_STOP))
      PUT_ERR("ERROR in yac_interp_stack_config_entry_get_user_file");
    free((void*)filename);
 
    yac_interp_stack_config_delete(interp_stack);
  }
 
  { // getter: fixed
    struct yac_interp_stack_config * interp_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_fixed(interp_stack, 2.5);
 
    if (yac_interp_stack_config_get_size(interp_stack) != 1)
      PUT_ERR("ERROR: unexpected stack size in fixed getter test");
 
    union yac_interp_stack_config_entry const * entry =
      yac_interp_stack_config_get_entry(interp_stack, 0);
    if (yac_interp_stack_config_entry_get_type(entry) != YAC_FIXED_VALUE)
      PUT_ERR("ERROR: invalid interpolation type in fixed getter test");
 
    double value = -1.0;
    yac_interp_stack_config_entry_get_fixed(entry, &value);
    if (fabs(value - 2.5) > 1e-12)
      PUT_ERR("ERROR in yac_interp_stack_config_entry_get_fixed");
 
    yac_interp_stack_config_delete(interp_stack);
  }
 
  { // getter: check
    struct yac_interp_stack_config * interp_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_check(interp_stack, NULL, "do_search_key");
 
    if (yac_interp_stack_config_get_size(interp_stack) != 1)
      PUT_ERR("ERROR: unexpected stack size in check getter test");
 
    union yac_interp_stack_config_entry const * entry =
      yac_interp_stack_config_get_entry(interp_stack, 0);
    if (yac_interp_stack_config_entry_get_type(entry) != YAC_CHECK)
      PUT_ERR("ERROR: invalid interpolation type in check getter test");
 
    char const * constructor_key = NULL;
    char const * do_search_key = NULL;
    yac_interp_stack_config_entry_get_check(entry, &constructor_key, &do_search_key);
    if ((constructor_key == NULL) || strcmp(constructor_key, "") ||
        (do_search_key == NULL) || strcmp(do_search_key, "do_search_key"))
      PUT_ERR("ERROR in yac_interp_stack_config_entry_get_check");
    free((void*)constructor_key);
    free((void*)do_search_key);
 
    yac_interp_stack_config_delete(interp_stack);
  }
 
  { // getter: creep
    struct yac_interp_stack_config * interp_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_creep(interp_stack, 3);
 
    if (yac_interp_stack_config_get_size(interp_stack) != 1)
      PUT_ERR("ERROR: unexpected stack size in creep getter test");
 
    union yac_interp_stack_config_entry const * entry =
      yac_interp_stack_config_get_entry(interp_stack, 0);
    if (yac_interp_stack_config_entry_get_type(entry) != YAC_CREEP)
      PUT_ERR("ERROR: invalid interpolation type in creep getter test");
 
    int creep_distance = -1;
    yac_interp_stack_config_entry_get_creep(entry, &creep_distance);
    if (creep_distance != 3)
      PUT_ERR("ERROR in yac_interp_stack_config_entry_get_creep");
 
    yac_interp_stack_config_delete(interp_stack);
  }
 
  { // getter: user callback
    struct yac_interp_stack_config * interp_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_user_callback(interp_stack, "compute_weights");
 
    if (yac_interp_stack_config_get_size(interp_stack) != 1)
      PUT_ERR("ERROR: unexpected stack size in user callback getter test");
 
    union yac_interp_stack_config_entry const * entry =
      yac_interp_stack_config_get_entry(interp_stack, 0);
    if (yac_interp_stack_config_entry_get_type(entry) != YAC_USER_CALLBACK)
      PUT_ERR("ERROR: invalid interpolation type in user callback getter test");
 
    char const * func_compute_weights_key = NULL;
    yac_interp_stack_config_entry_get_user_callback(
      entry, &func_compute_weights_key);
    if ((func_compute_weights_key == NULL) ||
        strcmp(func_compute_weights_key, "compute_weights"))
      PUT_ERR("ERROR in yac_interp_stack_config_entry_get_user_callback");
    free((void*)func_compute_weights_key);
 
    yac_interp_stack_config_delete(interp_stack);
  }
 
  { // round-trip via spmap_ext getter with file-based cell area configs
 
    struct yac_interp_stack_config * interp_stack = yac_interp_stack_config_new();
    yac_interp_stack_config_add_spmap(
      interp_stack,
      0.15, 0.45, YAC_INTERP_SPMAP_DIST, YAC_INTERP_SPMAP_FRACAREA,
      0.0, "src_area.nc", "src_cell_area", 7,
      0.0, "tgt_area.nc", "tgt_cell_area", 9);
 
    union yac_interp_stack_config_entry const * entry =
      yac_interp_stack_config_get_entry(interp_stack, 0);
    struct yac_interp_spmap_config const * default_cfg = NULL;
    struct yac_spmap_overwrite_config const ** overwrite_cfgs = NULL;
    yac_interp_stack_config_entry_get_spmap_ext(
      entry, &default_cfg, &overwrite_cfgs);
 
    struct yac_spmap_cell_area_config * src_cell_area_cfg =
      yac_spmap_cell_area_config_file_new("src_area.nc", "src_cell_area", 7);
    struct yac_spmap_cell_area_config * tgt_cell_area_cfg =
      yac_spmap_cell_area_config_file_new("tgt_area.nc", "tgt_cell_area", 9);
    struct yac_spmap_scale_config * ref_scale_cfg =
      yac_spmap_scale_config_new(
        YAC_INTERP_SPMAP_FRACAREA, src_cell_area_cfg, tgt_cell_area_cfg);
    struct yac_interp_spmap_config * ref_default_cfg =
      yac_interp_spmap_config_new(0.15, 0.45, YAC_INTERP_SPMAP_DIST, ref_scale_cfg);
 
    if (yac_interp_spmap_config_compare(default_cfg, ref_default_cfg) != 0)
      PUT_ERR("ERROR: unexpected file-based default spmap config");
    if (overwrite_cfgs != NULL)
      PUT_ERR("ERROR: unexpected overwrite configs for file-based spmap test");
 
    yac_interp_spmap_config_delete(ref_default_cfg);
    yac_spmap_scale_config_delete(ref_scale_cfg);
    yac_spmap_cell_area_config_delete(src_cell_area_cfg);
    yac_spmap_cell_area_config_delete(tgt_cell_area_cfg);
    yac_interp_stack_config_delete(interp_stack);
  }
 
  { // testing spmap interpolation generated from an interp_stack
 
    // trivial 2x2 grid
    double * coords = (double[]){0.0,0.1,0.2};
    struct yac_basic_grid_data grid_data[2] =
      {utest_generate_basic_grid_data_reg2d(
         coords, coords, (size_t[]){2,2},
         (size_t[]){0,0}, (size_t[]){2,2}, 1),
       utest_generate_basic_grid_data_reg2d(
         coords, coords, (size_t[]){2,2},
         (size_t[]){0,0}, (size_t[]){2,2}, 1)};
    yac_coordinate_pointer cell_center_coords =
      malloc(4 * sizeof(*cell_center_coords));
    for (int i = 0, k = 0; i < 2; ++i)
      for (int j = 0; j < 2; ++j, ++k)
        LLtoXYZ(
          (coords[j] + coords[j+1])*0.5, (coords[i] + coords[i+1])*0.5,
          cell_center_coords[k]);
 
    struct yac_basic_grid * grids[2] =
      {yac_basic_grid_new("src_grid", grid_data[0]),
       yac_basic_grid_new("tgt_grid", grid_data[1])};
 
    size_t src_cell_coord_idx =
      yac_basic_grid_add_coordinates(
        grids[0], YAC_LOC_CELL, cell_center_coords, 4);
    size_t tgt_cell_coord_idx =
      yac_basic_grid_add_coordinates(
        grids[1], YAC_LOC_CELL, cell_center_coords, 4);
    free(cell_center_coords);
 
    struct yac_dist_grid_pair * grid_pair =
      yac_dist_grid_pair_new(grids[0], grids[1], MPI_COMM_WORLD);
 
    struct yac_interp_field src_fields[] =
      {{.location = YAC_LOC_CELL, .masks_idx = SIZE_MAX}};
    size_t num_src_fields = sizeof(src_fields) / sizeof(src_fields[0]);
    struct yac_interp_field tgt_field =
      {.location = YAC_LOC_CELL, .masks_idx = SIZE_MAX};
    src_fields[0].coordinates_idx = src_cell_coord_idx;
    tgt_field.coordinates_idx = tgt_cell_coord_idx;
 
    struct yac_interp_grid * interp_grid =
      yac_interp_grid_new(grid_pair, "src_grid", "tgt_grid",
                          num_src_fields, src_fields, tgt_field);
 
    enum {OVERWRITE_CONFIG_COUNT = 1};
    struct yac_spmap_overwrite_config *
      overwrite_configs[OVERWRITE_CONFIG_COUNT+1];
    overwrite_configs[OVERWRITE_CONFIG_COUNT] = NULL;
 
    {
      struct yac_point_selection * src_point_selection =
        yac_point_selection_bnd_circle_new(0.05, 0.05, 0.01);
      struct yac_interp_spmap_config * spmap_config =
        yac_interp_spmap_config_new(
          0.11,
          YAC_INTERP_SPMAP_MAX_SEARCH_DISTANCE_DEFAULT,
          YAC_INTERP_SPMAP_WEIGHTED_DEFAULT,
          YAC_INTERP_SPMAP_SCALE_CONFIG_DEFAULT);
      overwrite_configs[0] =
        yac_spmap_overwrite_config_new(src_point_selection, spmap_config);
      yac_interp_spmap_config_delete(spmap_config);
      yac_point_selection_delete(src_point_selection);
    }
 
    struct yac_interp_stack_config * interp_stack_config =
      yac_interp_stack_config_new();
 
    yac_interp_stack_config_add_spmap_ext(
      interp_stack_config, YAC_INTERP_SPMAP_DEFAULT_CONFIG, overwrite_configs);
 
    struct interp_method ** method_stack =
      yac_interp_stack_config_generate(interp_stack_config);
 
    yac_interp_stack_config_delete(interp_stack_config);
 
    struct yac_interp_weights * weights =
      yac_interp_method_do_search(method_stack, interp_grid);
 
    struct yac_interpolation * interpolation =
      yac_interp_weights_get_interpolation(
        weights, YAC_MAPPING_ON_SRC, 1,
        YAC_FRAC_MASK_NO_VALUE, 1.0, 0.0, NULL, 1, 1);
 
    {
      double * src_field = (double[]){1.0,2.0,3.0,4.0};
      double ** src_fields = &src_field;
      double * tgt_field = (double[]){0.0,0.0,0.0,0.0};
      double const * ref_tgt_field =
        (double[]){1.0/3.0, 2.0+1.0/3.0, 3.0+1.0/3.0, 4.0};
 
      yac_interpolation_execute(interpolation, &src_fields, &tgt_field);
 
      for (int i = 0; i < 4; ++i)
        if (fabs(tgt_field[i] - ref_tgt_field[i]) > 1e-6)
          PUT_ERR("ERROR in yac_interp_stack_config_add_spmap_ext");
    }
 
    yac_interpolation_delete(interpolation);
 
    yac_interp_weights_delete(weights);
    yac_interp_method_delete(method_stack);
    free(method_stack);
    for (size_t i = 0; i < OVERWRITE_CONFIG_COUNT; ++i)
      yac_spmap_overwrite_config_delete(overwrite_configs[i]);
    yac_interp_grid_delete(interp_grid);
    yac_dist_grid_pair_delete(grid_pair);
    yac_basic_grid_delete(grids[1]);
    yac_basic_grid_delete(grids[0]);
  }
 
  xt_finalize();
  MPI_Finalize();
 
  return TEST_EXIT_CODE;
}
 
static void utest_check_compare_stacks_(
  struct yac_interp_stack_config * a, struct yac_interp_stack_config * b,
  int configs_differ) {
 
  configs_differ = configs_differ != 0;
 
  if (yac_interp_stack_config_compare(a, a))
    PUT_ERR("error in yac_interp_stack_config_compare (a != a)")
  if (yac_interp_stack_config_compare(b, b))
    PUT_ERR("error in yac_interp_stack_config_compare (b != b)")
 
  int cmp_a = yac_interp_stack_config_compare(a, b);
  int cmp_b = yac_interp_stack_config_compare(b, a);
 
  if ((cmp_a != cmp_b) ^ configs_differ) {
    PUT_ERR("error in yac_interp_stack_config_compare ((a > b) == (a < b))")
  }
  if ((cmp_a != 0) ^ configs_differ) {
    PUT_ERR("error in yac_interp_stack_config_compare ((a > b) == 0)")
  }
  if ((cmp_b != 0) ^ configs_differ) {
    PUT_ERR("error in yac_interp_stack_config_compare ((a > b) == 0)")
  }
 
  yac_interp_stack_config_delete(b);
  yac_interp_stack_config_delete(a);
}
 
static void utest_check_compare_stacks(
  struct yac_interp_stack_config * a, struct yac_interp_stack_config * b,
  int configs_differ) {
 
  utest_check_compare_stacks_(
    yac_interp_stack_config_copy(a),
    yac_interp_stack_config_copy(b), configs_differ);
  utest_check_compare_stacks_(a, b, configs_differ);
}
 
static void utest_interp_stack_config_add_spmap_(
  struct yac_interp_stack_config * interp_stack_config,
  double spread_distance, double max_search_distance,
  enum yac_interp_spmap_weight_type weight_type,
  enum yac_interp_spmap_scale_type scale_type,
  struct yac_spmap_cell_area_config * src_cell_area_config,
  struct yac_spmap_cell_area_config * tgt_cell_area_config) {
 
  enum yac_interp_spmap_cell_area_provider src_cell_area_config_type =
    yac_spmap_cell_area_config_get_type(src_cell_area_config);
  double src_sphere_radius =
    (src_cell_area_config_type == YAC_INTERP_SPMAP_CELL_AREA_YAC)?
      yac_spmap_cell_area_config_get_sphere_radius(src_cell_area_config):0.0;
  char const * src_filename =
    (src_cell_area_config_type == YAC_INTERP_SPMAP_CELL_AREA_FILE)?
      yac_spmap_cell_area_config_get_filename(src_cell_area_config):NULL;
  char const * src_varname =
    (src_cell_area_config_type == YAC_INTERP_SPMAP_CELL_AREA_FILE)?
      yac_spmap_cell_area_config_get_varname(src_cell_area_config):NULL;
  yac_int src_min_global_id =
    (src_cell_area_config_type == YAC_INTERP_SPMAP_CELL_AREA_FILE)?
      yac_spmap_cell_area_config_get_min_global_id(src_cell_area_config):0;
 
  enum yac_interp_spmap_cell_area_provider tgt_cell_area_config_type =
    yac_spmap_cell_area_config_get_type(tgt_cell_area_config);
  double tgt_sphere_radius =
    (tgt_cell_area_config_type == YAC_INTERP_SPMAP_CELL_AREA_YAC)?
      yac_spmap_cell_area_config_get_sphere_radius(tgt_cell_area_config):0.0;
  char const * tgt_filename =
    (tgt_cell_area_config_type == YAC_INTERP_SPMAP_CELL_AREA_FILE)?
      yac_spmap_cell_area_config_get_filename(tgt_cell_area_config):NULL;
  char const * tgt_varname =
    (tgt_cell_area_config_type == YAC_INTERP_SPMAP_CELL_AREA_FILE)?
      yac_spmap_cell_area_config_get_varname(tgt_cell_area_config):NULL;
  yac_int tgt_min_global_id =
    (tgt_cell_area_config_type == YAC_INTERP_SPMAP_CELL_AREA_FILE)?
      yac_spmap_cell_area_config_get_min_global_id(tgt_cell_area_config):0;
 
  yac_interp_stack_config_add_spmap(
    interp_stack_config,
    spread_distance, max_search_distance, weight_type, scale_type,
    src_sphere_radius,
    src_filename,
    src_varname,
    src_min_global_id,
    tgt_sphere_radius,
    tgt_filename,
    tgt_varname,
    tgt_min_global_id);
 
  // test yac_interp_stack_config_entry_get_spmap
  union yac_interp_stack_config_entry const * interp_stack_entry =
    yac_interp_stack_config_get_entry(
      interp_stack_config,
      yac_interp_stack_config_get_size(interp_stack_config) - 1);
  double spread_distance_;
  double max_search_distance_;
  enum yac_interp_spmap_weight_type weight_type_;
  enum yac_interp_spmap_scale_type scale_type_;
  double src_sphere_radius_;
  char const * src_filename_;
  char const * src_varname_;
  int src_min_global_id_;
  double tgt_sphere_radius_;
  char const * tgt_filename_;
  char const * tgt_varname_;
  int tgt_min_global_id_;
  yac_interp_stack_config_entry_get_spmap(
    interp_stack_entry,
    &spread_distance_, &max_search_distance_, &weight_type_, &scale_type_,
    &src_sphere_radius_, &src_filename_, &src_varname_, &src_min_global_id_,
    &tgt_sphere_radius_, &tgt_filename_, &tgt_varname_, &tgt_min_global_id_);
 
  if (spread_distance_ != spread_distance)
    PUT_ERR("ERROR in yac_interp_stack_config_entry_get_spmap");
  if (max_search_distance_ != max_search_distance)
    PUT_ERR("ERROR in yac_interp_stack_config_entry_get_spmap");
  if (weight_type_ != weight_type)
    PUT_ERR("ERROR in yac_interp_stack_config_entry_get_spmap");
  if (scale_type_ != scale_type)
    PUT_ERR("ERROR in yac_interp_stack_config_entry_get_spmap");
}