interp_stack_config.c

Go to the documentation of this file.

// Copyright (c) 2024 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
 
#include <math.h>
#include <string.h>
#include <limits.h>
 
#include "geometry.h"
#include "yac_mpi_internal.h"
#include "interp_stack_config.h"
#include "methods/interp_method_avg.h"
#include "methods/interp_method_check.h"
#include "methods/interp_method_conserv.h"
#include "methods/interp_method_creep.h"
#include "methods/interp_method_ncc.h"
#include "methods/interp_method_nnn.h"
#include "methods/interp_method_dnn.h"
#include "methods/interp_method_fixed.h"
#include "methods/interp_method_file.h"
#include "methods/interp_method_hcsbb.h"
#include "methods/interp_method_spmap.h"
#include "methods/interp_method_callback.h"
#include "methods/interp_method_config.h"
#include "parameter/param.h"
 
struct yac_spmap_ext_cache_entry {
  struct yac_interp_spmap_config * default_config;
  struct yac_spmap_overwrite_config ** overwrite_configs;
};
 
// The union type is used here for compatiblity reasons.
union yac_interp_stack_config_entry {
  struct {
    struct yac_interp_method_config *config;
    /*
     * Temporary compatibility solution: keep one layzily-built SPMAP ext cache.
     */
    struct yac_spmap_ext_cache_entry *spmap_ext_cache;
  } data;
};
 
struct yac_interp_stack_config {
  union yac_interp_stack_config_entry *entries;
  size_t size;
};
 
static void free_spmap_ext_cache_entry(
  struct yac_spmap_ext_cache_entry * entry) {
 
  if (entry == NULL) return;
  yac_interp_spmap_config_delete(entry->default_config);
  yac_spmap_overwrite_configs_delete(entry->overwrite_configs);
  entry->default_config = NULL;
  entry->overwrite_configs = NULL;
  free(entry);
}
 
struct yac_interp_stack_config * yac_interp_stack_config_copy(
  struct yac_interp_stack_config * interp_stack) {
 
  struct yac_interp_stack_config * interp_stack_copy =
    xmalloc(1 * sizeof(*interp_stack_copy));
  interp_stack_copy->size = interp_stack->size;
  interp_stack_copy->entries =
    xmalloc(interp_stack_copy->size * sizeof(*(interp_stack_copy->entries)));
  for (size_t i = 0; i < interp_stack_copy->size; ++i) {
    interp_stack_copy->entries[i].data.config =
      yac_interp_method_config_copy(interp_stack->entries[i].data.config);
    interp_stack_copy->entries[i].data.spmap_ext_cache = NULL;
  }
  return interp_stack_copy;
}
 
int yac_interp_stack_config_compare(void const * a_, void const * b_) {
 
  struct yac_interp_stack_config const * a =
   (struct yac_interp_stack_config const *)a_;
  struct yac_interp_stack_config const * b =
   (struct yac_interp_stack_config const *)b_;
 
  int ret;
  if ((ret = (a->size > b->size) - (a->size < b->size))) return ret;
 
  size_t stack_size = a->size;
  for (size_t method_idx = 0; method_idx < stack_size; ++method_idx)
    if ((ret = yac_interp_method_config_compare(
             a->entries[method_idx].data.config,
             b->entries[method_idx].data.config)))
      return ret;
  return 0;
}
 
struct interp_method ** yac_interp_stack_config_generate(
  struct yac_interp_stack_config * interp_stack) {
 
  size_t interp_stack_size = interp_stack->size;
  struct interp_method ** method_stack =
    xmalloc((interp_stack_size + 1) * sizeof(*method_stack));
  method_stack[interp_stack_size] = NULL;
 
  for (size_t i = 0; i < interp_stack_size; ++i) {
    method_stack[i] =
      yac_interp_method_config_generate(interp_stack->entries[i].data.config);
  }
  return method_stack;
}
 
size_t yac_interp_stack_config_get_pack_size(
  struct yac_interp_stack_config * interp_stack, MPI_Comm comm) {
 
  int size_pack_size;
  yac_mpi_call(MPI_Pack_size(1, MPI_INT, comm, &size_pack_size), comm);
 
  size_t config_pack_size = 0;
 
  for (size_t i = 0; i < interp_stack->size; ++i)
    config_pack_size +=
      yac_interp_method_config_get_pack_size(
        interp_stack->entries[i].data.config, comm);
  return (size_t)size_pack_size + config_pack_size;
}
 
void yac_interp_stack_config_pack(
  struct yac_interp_stack_config * interp_stack,
  void * buffer, int buffer_size, int * position, MPI_Comm comm) {
 
  int stack_size = (int)(interp_stack->size);
  yac_mpi_call(
    MPI_Pack(
      &stack_size, 1, MPI_INT,
      buffer, buffer_size, position, comm), comm);
 
  for (size_t i = 0; i < interp_stack->size; ++i)
    yac_interp_method_config_pack(
      interp_stack->entries[i].data.config,
      buffer, buffer_size, position, comm);
}
 
struct yac_interp_stack_config * yac_interp_stack_config_unpack(
  void * buffer, int buffer_size, int * position, MPI_Comm comm) {
 
  int stack_size;
  yac_mpi_call(
    MPI_Unpack(
      buffer, buffer_size, position, &stack_size, 1, MPI_INT, comm), comm);
 
  YAC_ASSERT(
    stack_size >= 0,
    "ERROR(yac_interp_stack_config_unpack_interp_stack): invalid stack size")
 
  struct yac_interp_stack_config * interp_stack =
    yac_interp_stack_config_new();
 
  interp_stack->size = (size_t)stack_size;
  interp_stack->entries =
    xmalloc((size_t)stack_size * sizeof(*interp_stack->entries));
 
  for (int i = 0; i < stack_size; ++i) {
    interp_stack->entries[i].data.config =
      yac_interp_method_config_unpack(buffer, buffer_size, position, comm);
    interp_stack->entries[i].data.spmap_ext_cache = NULL;
  }
  return interp_stack;
}
 
struct yac_interp_stack_config * yac_interp_stack_config_new() {
 
  struct yac_interp_stack_config * interp_stack_config =
    xmalloc(1 * sizeof(*interp_stack_config));
  interp_stack_config->entries = NULL;
  interp_stack_config->size = 0;
 
  return interp_stack_config;
}
 
void yac_interp_stack_config_delete(
  struct yac_interp_stack_config * interp_stack_config) {
  for (size_t i = 0; i < interp_stack_config->size; ++i) {
    yac_interp_method_config_delete(
      interp_stack_config->entries[i].data.config);
    free_spmap_ext_cache_entry(
      interp_stack_config->entries[i].data.spmap_ext_cache);
  }
  free(interp_stack_config->entries);
  free(interp_stack_config);
}
 
void yac_interp_stack_config_add(
  struct yac_interp_stack_config * interp_stack_config,
  struct yac_interp_method_config * method_config) {
  interp_stack_config->size++;
  interp_stack_config->entries =
    xrealloc(
      interp_stack_config->entries,
      interp_stack_config->size * sizeof(*(interp_stack_config->entries)));
  interp_stack_config->entries[interp_stack_config->size - 1].data.config =
    method_config;
  interp_stack_config->entries[interp_stack_config->size - 1].data.
    spmap_ext_cache = NULL;
}
 
static struct yac_param * get_method_param(
  struct yac_interp_method_config * method_config,
  char const * routine) {
 
  struct yac_param * param =
    yac_interp_method_config_get_param(method_config);
  YAC_ASSERT_F(
    param != NULL,
    "ERROR(%s): failed to get method configuration parameters", routine);
  return param;
}
 
static struct yac_param * get_sub_param(
  struct yac_param * param,
  char const * name,
  char const * routine) {
 
  struct yac_param * sub_param = NULL;
  int ierr =
    yac_param_get_sub_by_name(param, name, &sub_param);
  YAC_ASSERT_F(
    ierr == 0,
    "ERROR(%s): failed to access parameter \"%s\": %s",
    routine, name, yac_param_get_last_error());
  return sub_param;
}
 
static struct yac_param * get_sub_param_by_index(
  struct yac_param * param,
  size_t idx,
  char const * name,
  char const * routine) {
 
  struct yac_param * sub_param = NULL;
  int ierr =
    yac_param_get_sub_by_index(param, idx, &sub_param);
  YAC_ASSERT_F(
    ierr == 0,
    "ERROR(%s): failed to access parameter \"%s\" (idx=%zu): %s",
    routine, name, idx, yac_param_get_last_error());
  return sub_param;
}
 
static size_t get_sub_count(
  struct yac_param * param,
  char const * name,
  char const * routine) {
 
  size_t count = SIZE_MAX;
  int ierr = yac_param_get_sub_count(param, &count);
  YAC_ASSERT_F(
    ierr == 0,
    "ERROR(%s): failed to read sub-parameter count of \"%s\": %s",
    routine, name, yac_param_get_last_error());
  return count;
}
 
static int get_param_int(
  struct yac_param * param,
  char const * name,
  char const * routine) {
 
  int value = INT_MAX;
  int ierr =
    yac_param_get_scalar_int(param, &value);
  YAC_ASSERT_F(
    ierr == 0,
    "ERROR(%s): failed to read parameter \"%s\": %s",
    routine, name, yac_param_get_last_error());
  return value;
}
 
static double get_param_dble(
  struct yac_param * param,
  char const * name,
  char const * routine) {
 
  double value = NAN;
  int ierr =
    yac_param_get_scalar_dble(param, &value);
  YAC_ASSERT_F(
    ierr == 0,
    "ERROR(%s): failed to read parameter \"%s\": %s",
    routine, name, yac_param_get_last_error());
  return value;
}
 
static char * get_param_str_dup(
  struct yac_param * param,
  char const * name,
  char const * routine) {
 
  char value[YAC_MAX_FILE_NAME_LENGTH];
  int ierr =
    yac_param_get_scalar(param, value, sizeof(value));
  YAC_ASSERT_F(
    ierr == 0,
    "ERROR(%s): failed to read parameter \"%s\": %s",
    routine, name, yac_param_get_last_error());
  return xstrdup(value);
}
 
static struct yac_spmap_cell_area_config * make_spmap_cell_area_config(
  struct yac_param * cell_area_oneof_param,
  char const * name, char const * routine) {
 
  struct yac_param * cell_area_param =
    get_sub_param_by_index(cell_area_oneof_param, 0, name, routine);
  char const * cell_area_type_name = yac_param_get_name(cell_area_param);
  YAC_ASSERT_F(
    cell_area_type_name != NULL,
    "ERROR(%s): invalid %s configuration", routine, name);
 
  DEF_NAME_TYPE_PAIRS(
    type_table,
    DEF_NAME_TYPE_PAIR(yac, YAC_INTERP_SPMAP_CELL_AREA_YAC),
    DEF_NAME_TYPE_PAIR(YAC, YAC_INTERP_SPMAP_CELL_AREA_YAC),
    DEF_NAME_TYPE_PAIR(file, YAC_INTERP_SPMAP_CELL_AREA_FILE),
    DEF_NAME_TYPE_PAIR(FILE, YAC_INTERP_SPMAP_CELL_AREA_FILE),
    DEF_NAME_TYPE_PAIR(user_file, YAC_INTERP_SPMAP_CELL_AREA_FILE),
    DEF_NAME_TYPE_PAIR(area_file, YAC_INTERP_SPMAP_CELL_AREA_FILE))
 
  int type =
    yac_name_type_pair_get_type(
      type_table, type_table_size, cell_area_type_name);
 
  struct yac_spmap_cell_area_config * cell_area_config = NULL;
 
  switch(type) {
    YAC_UNREACHABLE_DEFAULT_F(
      "ERROR(%s): invalid cell area configuration type \"%s\"",
      routine, cell_area_type_name);
    case(YAC_INTERP_SPMAP_CELL_AREA_FILE): {
 
      char * filename =
        get_param_str_dup(
          get_sub_param(cell_area_param, "filename", routine),
          "filename", routine);
      char * varname =
        get_param_str_dup(
          get_sub_param(cell_area_param, "varname", routine),
          "varname", routine);
      int min_global_id =
        get_param_int(
          get_sub_param(cell_area_param, "min_global_id", routine),
          "min_global_id", routine);
      cell_area_config =
        yac_spmap_cell_area_config_file_new(filename, varname, min_global_id);
      free(filename);
      free(varname);
      break;
    }
    case(YAC_INTERP_SPMAP_CELL_AREA_YAC): {
 
      cell_area_config =
        yac_spmap_cell_area_config_yac_new(
          get_param_dble(
            get_sub_param(cell_area_param, "sphere_radius", routine),
            "sphere_radius", routine));
      break;
    }
  }
  return cell_area_config;
}
 
static struct yac_spmap_ext_cache_entry *  yac_spmap_ext_cache_entry_new(
  struct yac_param * root_param,
  char const * routine) {
 
  struct yac_spmap_ext_cache_entry * entry = xmalloc(1 * sizeof(*entry));
 
  struct yac_spmap_cell_area_config * src_cell_area_config =
    make_spmap_cell_area_config(
      get_sub_param(root_param, "src_cell_area", routine),
      "src_cell_area", routine);
  struct yac_spmap_cell_area_config * tgt_cell_area_config =
    make_spmap_cell_area_config(
      get_sub_param(root_param, "tgt_cell_area", routine),
      "tgt_cell_area", routine);
  struct yac_spmap_scale_config * scale_config =
    yac_spmap_scale_config_new(
      (enum yac_interp_spmap_scale_type)get_param_int(
        get_sub_param(root_param, "scale", routine),
        "scale", routine),
      src_cell_area_config, tgt_cell_area_config);
 
  yac_spmap_cell_area_config_delete(src_cell_area_config);
  yac_spmap_cell_area_config_delete(tgt_cell_area_config);
 
  entry->default_config =
    yac_interp_spmap_config_new(
      get_param_dble(
        get_sub_param(root_param, "spread_distance", routine),
        "spread_distance", routine),
      get_param_dble(
        get_sub_param(root_param, "max_search_distance", routine),
        "max_search_distance", routine),
      (enum yac_interp_spmap_weight_type)get_param_int(
        get_sub_param(root_param, "weighted", routine),
        "weighted", routine),
      scale_config);
  yac_spmap_scale_config_delete(scale_config);
 
  struct yac_param * overwrite_param =
    get_sub_param(root_param, "overwrite", routine);
  size_t overwrite_count = get_sub_count(overwrite_param, "overwrite", routine);
 
  entry->overwrite_configs =
    (overwrite_count > 0)?
      xcalloc(overwrite_count + 1, sizeof(*(entry->overwrite_configs))):NULL;
 
  for (size_t i = 0; i < overwrite_count; ++i) {
    struct yac_param * overwrite_entry_param =
      get_sub_param_by_index(overwrite_param, i, "overwrite", routine);
 
    struct yac_param * condition_oneof_param =
      get_sub_param(overwrite_entry_param, "condition", routine);
    struct yac_param * condition_param =
      get_sub_param_by_index(
        condition_oneof_param, 0, "condition", routine);
    char const * condition_type =
      yac_param_get_name(condition_param);
    YAC_ASSERT_F(
      (condition_type != NULL) &&
      (!strcmp(condition_type, "bnd_circle") ||
       !strcmp(condition_type, "bounding_circle")),
      "ERROR(%s): unsupported overwrite condition type",
      routine);
 
    struct yac_param * center_param =
      get_sub_param(condition_param, "center", routine);
 
    struct yac_point_selection * src_point_selection =
      yac_point_selection_bnd_circle_new(
        get_param_dble(
          get_sub_param(center_param, "lon", routine),
          "lon", routine),
        get_param_dble(
          get_sub_param(center_param, "lat", routine),
          "lat", routine),
        get_param_dble(
          get_sub_param(condition_param, "radius", routine),
          "radius", routine));
 
    struct yac_interp_spmap_config * overwrite_config =
      yac_interp_spmap_config_new(
        get_param_dble(
          get_sub_param(overwrite_entry_param, "spread_distance", routine),
          "spread_distance", routine),
        get_param_dble(
          get_sub_param(
            overwrite_entry_param, "max_search_distance", routine),
          "max_search_distance", routine),
        (enum yac_interp_spmap_weight_type)get_param_int(
          get_sub_param(overwrite_entry_param, "weighted", routine),
          "weighted", routine),
        YAC_INTERP_SPMAP_SCALE_CONFIG_DEFAULT);
 
    entry->overwrite_configs[i] =
      yac_spmap_overwrite_config_new(src_point_selection, overwrite_config);
 
    yac_point_selection_delete(src_point_selection);
    yac_interp_spmap_config_delete(overwrite_config);
  }
 
  return entry;
}
 
static struct yac_spmap_ext_cache_entry * get_spmap_ext_cache_entry(
  union yac_interp_stack_config_entry * interp_stack_entry,
  struct yac_param * root_param,
  char const * routine) {
 
  if (interp_stack_entry->data.spmap_ext_cache == NULL) {
 
    interp_stack_entry->data.spmap_ext_cache =
      yac_spmap_ext_cache_entry_new(root_param, routine);
  }
 
  return interp_stack_entry->data.spmap_ext_cache;
}
 
static struct yac_interp_method_config * get_entry_method_config(
  union yac_interp_stack_config_entry const * interp_stack_entry) {
 
  return interp_stack_entry->data.config;
}
 
static struct yac_param * get_entry_param(
  union yac_interp_stack_config_entry const * interp_stack_entry,
  char const * routine) {
 
  return get_method_param(get_entry_method_config(interp_stack_entry), routine);
}
 
static void set_sub_param_int(
  struct yac_param * param, char const * name,
  int value, char const * routine) {
 
  int ierr =
    yac_param_set_scalar_int(get_sub_param(param, name, routine), value);
  YAC_ASSERT_F(
    ierr == 0,
    "ERROR(%s): failed to set parameter \"%s\": %s",
    routine, name, yac_param_get_last_error());
}
 
static void set_sub_param_dble(
  struct yac_param * param, char const * name,
  double value, char const * routine) {
 
  int ierr =
    yac_param_set_scalar_dble(get_sub_param(param, name, routine), value);
  YAC_ASSERT_F(
    ierr == 0,
    "ERROR(%s): failed to set parameter \"%s\": %s",
    routine, name, yac_param_get_last_error());
}
 
static void set_sub_param_str(
  struct yac_param * param, char const * name,
  char const * value, char const * routine) {
 
  int ierr =
    yac_param_set_scalar(get_sub_param(param, name, routine), value);
  YAC_ASSERT_F(
    ierr == 0,
    "ERROR(%s): failed to set parameter \"%s\": %s",
    routine, name, yac_param_get_last_error());
}
 
void yac_interp_stack_config_add_average(
  struct yac_interp_stack_config * interp_stack_config,
  enum yac_interp_avg_weight_type reduction_type, int partial_coverage) {
 
  char const * routine = "yac_interp_stack_config_add_average";
 
  struct yac_interp_method_config * method_config =
    yac_interp_method_config_default_from_name_new("average");
  struct yac_param * root_param =
    get_method_param(method_config, routine);
 
  set_sub_param_int(root_param, "weighted", (int)reduction_type, routine);
  set_sub_param_int(root_param, "partial_coverage", partial_coverage, routine);
 
  yac_param_delete(root_param);
  yac_interp_stack_config_add(interp_stack_config, method_config);
}
 
void yac_interp_stack_config_add_average_f2c(
  struct yac_interp_stack_config * interp_stack_config,
  int reduction_type, int partial_coverage) {
 
  YAC_ASSERT(
    (reduction_type == YAC_INTERP_AVG_ARITHMETIC) ||
    (reduction_type == YAC_INTERP_AVG_DIST) ||
    (reduction_type == YAC_INTERP_AVG_BARY),
    "ERROR(yac_interp_stack_config_add_average_f2c): "
    "reduction_type must be one of "
    "YAC_INTERP_AVG_ARITHMETIC/YAC_INTERP_AVG_DIST/YAC_INTERP_AVG_BARY");
 
  yac_interp_stack_config_add_average(
    interp_stack_config, (enum yac_interp_avg_weight_type)reduction_type,
    partial_coverage);
}
 
void yac_interp_stack_config_add_ncc(
  struct yac_interp_stack_config * interp_stack_config,
  enum yac_interp_ncc_weight_type weight_type, int partial_coverage) {
 
  char const * routine = "yac_interp_stack_config_add_ncc";
 
  struct yac_interp_method_config * method_config =
    yac_interp_method_config_default_from_name_new("ncc");
  struct yac_param * root_param =
    get_method_param(method_config, routine);
 
  set_sub_param_int(root_param, "weighted", (int)weight_type, routine);
  set_sub_param_int(root_param, "partial_coverage", partial_coverage, routine);
 
  yac_param_delete(root_param);
  yac_interp_stack_config_add(interp_stack_config, method_config);
}
 
void yac_interp_stack_config_add_ncc_f2c(
  struct yac_interp_stack_config * interp_stack_config,
  int weight_type, int partial_coverage) {
 
  YAC_ASSERT(
    (weight_type == YAC_INTERP_NCC_AVG) ||
    (weight_type == YAC_INTERP_NCC_DIST),
    "ERROR(yac_interp_stack_config_add_ncc_f2c): "
    "weight_type must be one of "
    "YAC_INTERP_NCC_AVG/YAC_INTERP_NCC_DIST");
 
  yac_interp_stack_config_add_ncc(
    interp_stack_config, (enum yac_interp_ncc_weight_type)weight_type,
    partial_coverage);
}
 
void yac_interp_stack_config_add_dnn(
  struct yac_interp_stack_config * interp_stack_config,
  enum yac_interp_dnn_weight_type type,
  enum yac_interp_dnn_search_distance_type search_distance_type,
  double search_distance, double scale) {
 
  char const * routine = "yac_interp_stack_config_add_dnn";
 
  struct yac_interp_method_config * method_config =
    yac_interp_method_config_default_from_name_new("dnn");
  struct yac_param * root_param = get_method_param(method_config, routine);
 
  set_sub_param_int(root_param, "weighted", (int)type, routine);
 
  struct yac_param * search_distance_param =
    get_sub_param( root_param, "search_distance", routine);
  switch (search_distance_type) {
    YAC_UNREACHABLE_DEFAULT_F(
      "ERROR(%s): invalid search distance type", routine);
    case YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED:
      set_sub_param_dble(
        search_distance_param, "fixed", search_distance, routine);
      break;
    case YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA:
      set_sub_param_dble(
        search_distance_param, "cell_area", search_distance, routine);
      break;
  }
  switch (type) {
    YAC_UNREACHABLE_DEFAULT_F(
      "ERROR(%s): invalid weight type", routine);
    case YAC_INTERP_DNN_WEIGHT_AVG: {__attribute__((fallthrough));}
    case YAC_INTERP_DNN_WEIGHT_DIST:
      set_sub_param_dble(
        root_param, "rbf_scale", YAC_INTERP_DNN_DUMMY_SCALE, routine);
      break;
    case YAC_INTERP_DNN_WEIGHT_RBF:
      set_sub_param_dble(
        root_param, "rbf_scale", scale, routine);
      break;
    case YAC_INTERP_DNN_WEIGHT_GAUSS:
      set_sub_param_dble(root_param, "gauss_scale", scale, routine);
      break;
  }
 
  yac_param_delete(root_param);
  yac_interp_stack_config_add(interp_stack_config, method_config);
}
 
void yac_interp_stack_config_add_dnn_f2c(
  struct yac_interp_stack_config * interp_stack_config,
  int type, int search_distance_type, double search_distance, double scale) {
 
  YAC_ASSERT(
    (type == YAC_INTERP_DNN_WEIGHT_AVG) ||
    (type == YAC_INTERP_DNN_WEIGHT_DIST) ||
    (type == YAC_INTERP_DNN_WEIGHT_GAUSS) ||
    (type == YAC_INTERP_DNN_WEIGHT_RBF),
    "ERROR(yac_interp_stack_config_add_dnn_f2c): "
    "type must be one of YAC_INTERP_DNN_WEIGHT_AVG/YAC_INTERP_DNN_WEIGHT_DIST/"
    "YAC_INTERP_DNN_WEIGHT_GAUSS/YAC_INTERP_DNN_WEIGHT_RBF.")
 
  YAC_ASSERT(
    (search_distance_type == YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED) ||
    (search_distance_type == YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA),
    "ERROR(yac_interp_stack_config_add_dnn_f2c): "
    "search_distance_type must be one of "
    "YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED/"
    "YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA.")
 
  yac_interp_stack_config_add_dnn(
    interp_stack_config, (enum yac_interp_dnn_weight_type)type,
    (enum yac_interp_dnn_search_distance_type)search_distance_type,
    search_distance, scale);
}
 
void yac_interp_stack_config_add_nnn(
  struct yac_interp_stack_config * interp_stack_config,
  enum yac_interp_nnn_weight_type type, size_t n,
  double max_search_distance, double scale) {
 
  char const * method_name = (type == YAC_INTERP_NNN_RBF)?"rbf":"nnn";
  char const * routine = "yac_interp_stack_config_add_nnn";
 
  struct yac_interp_method_config * method_config =
    yac_interp_method_config_default_from_name_new(method_name);
  struct yac_param * root_param =
    get_method_param(method_config, routine);
 
  if (type != YAC_INTERP_NNN_RBF)
    set_sub_param_int(root_param, "weighted", (int)type, routine);
 
  set_sub_param_int(root_param, "n", (int)n, routine);
  set_sub_param_dble(
    root_param, "max_search_distance", max_search_distance, routine);
 
  if (type == YAC_INTERP_NNN_RBF)
    set_sub_param_dble(root_param, "rbf_scale", scale, routine);
  else
    set_sub_param_dble(root_param, "gauss_scale", scale, routine);
 
  yac_param_delete(root_param);
  yac_interp_stack_config_add(interp_stack_config, method_config);
}
 
void yac_interp_stack_config_add_rbf(
  struct yac_interp_stack_config * interp_stack_config,
  size_t n, double max_search_distance, double scale) {
 
  yac_interp_stack_config_add_nnn(
    interp_stack_config, YAC_INTERP_NNN_RBF, n, max_search_distance, scale);
}
void yac_interp_stack_config_add_nnn_f2c(
  struct yac_interp_stack_config * interp_stack_config,
  int type, size_t n, double max_search_distance, double scale) {
 
  YAC_ASSERT(
    (type == YAC_INTERP_NNN_AVG) ||
    (type == YAC_INTERP_NNN_DIST) ||
    (type == YAC_INTERP_NNN_GAUSS) ||
    (type == YAC_INTERP_NNN_RBF) ||
    (type == YAC_INTERP_NNN_ZERO),
    "ERROR(yac_interp_stack_config_add_nnn_f2c): "
    "type must be one of YAC_INTERP_NNN_AVG/YAC_INTERP_NNN_DIST/"
    "YAC_INTERP_NNN_GAUSS/YAC_INTERP_NNN_RBF/YAC_INTERP_NNN_ZERO.")
 
  yac_interp_stack_config_add_nnn(
    interp_stack_config, (enum yac_interp_nnn_weight_type)type, n,
    max_search_distance, scale);
}
 
void yac_interp_stack_config_add_conservative(
  struct yac_interp_stack_config * interp_stack_config,
  int order, int enforced_conserv, int partial_coverage,
  enum yac_interp_method_conserv_normalisation normalisation) {
 
  char const * routine = "yac_interp_stack_config_add_conservative";
 
  YAC_ASSERT_F(
    (order == 1) || (order == 2),
    "ERROR(%s): order must be 1 (first order) or 2 (second order), got %d",
    routine, order)
 
  struct yac_interp_method_config * method_config =
    yac_interp_method_config_default_from_name_new("conservative");
  struct yac_param * root_param =
    get_method_param(method_config, routine);
 
  set_sub_param_int(
    root_param, "order", order, routine);
  set_sub_param_int(
    root_param, "enforced_conservation", enforced_conserv, routine);
  set_sub_param_int(
    root_param, "partial_coverage", partial_coverage, routine);
  set_sub_param_int(
    root_param, "normalisation", (int)normalisation, routine);
 
  yac_param_delete(root_param);
  yac_interp_stack_config_add(interp_stack_config, method_config);
}
 
void yac_interp_stack_config_add_conservative_f2c(
  struct yac_interp_stack_config * interp_stack_config,
  int order, int enforced_conserv, int partial_coverage,
  int normalisation) {
 
  YAC_ASSERT(
    (normalisation == YAC_INTERP_CONSERV_DESTAREA) ||
    (normalisation == YAC_INTERP_CONSERV_FRACAREA),
    "ERROR(yac_interp_stack_config_add_conservative_f2c): "
    "type must be one of "
    "YAC_INTERP_CONSERV_DESTAREA/YAC_INTERP_CONSERV_FRACAREA.")
 
  yac_interp_stack_config_add_conservative(
    interp_stack_config, order, enforced_conserv, partial_coverage,
    (enum yac_interp_method_conserv_normalisation)normalisation);
}
 
static struct yac_spmap_cell_area_config * generate_spmap_cell_area_config(
  double sphere_radius, char const * filename,
  char const * varname, int min_global_id, char const * type) {
 
  char const * routine = "generate_spmap_cell_area_config";
 
  YAC_ASSERT_F(
    (sphere_radius == 0.0) ||
    ((sphere_radius != 0.0) &&
     ((filename == NULL) && (varname == NULL))),
    "ERROR(%s): %s sphere_radius != 0.0, but filename and varname are not NULL",
    routine, type);
  YAC_ASSERT_F(
    (sphere_radius != 0.0) ||
    ((sphere_radius == 0.0) &&
     ((filename != NULL) && (strlen(filename) > 0) && (filename[0] != '\0') &&
      (varname != NULL) && (strlen(varname) > 0) && (varname[0] != '\0'))),
    "ERROR(%s): %s sphere_radius == 0.0, "
    "but filename and/or varname are invalid", routine, type);
 
  return
    (sphere_radius != 0.0)?
      yac_spmap_cell_area_config_yac_new(sphere_radius):
      yac_spmap_cell_area_config_file_new(filename, varname, min_global_id);
}
 
static void set_spmap_cell_area_param(
  struct yac_param * cell_area_param,
  struct yac_spmap_cell_area_config const * cell_area_config,
  char const * name, char const * routine) {
 
  enum yac_interp_spmap_cell_area_provider type =
    yac_spmap_cell_area_config_get_type(cell_area_config);
 
  switch (type) {
    YAC_UNREACHABLE_DEFAULT_F(
      "ERROR(%s): invalid %s type",
      routine, name);
    case(YAC_INTERP_SPMAP_CELL_AREA_YAC): {
      set_sub_param_dble(
        get_sub_param(cell_area_param, "yac", routine),
        "sphere_radius",
        yac_spmap_cell_area_config_get_sphere_radius(cell_area_config),
        routine);
      break;
    }
    case(YAC_INTERP_SPMAP_CELL_AREA_FILE): {
      struct yac_param * file_param =
        get_sub_param(cell_area_param, "file", routine);
      set_sub_param_str(
        file_param, "filename",
        yac_spmap_cell_area_config_get_filename(cell_area_config), routine);
      set_sub_param_str(
        file_param, "varname",
        yac_spmap_cell_area_config_get_varname(cell_area_config), routine);
      set_sub_param_int(
        file_param, "min_global_id",
        (int)yac_spmap_cell_area_config_get_min_global_id(cell_area_config),
        routine);
      break;
    }
  }
}
 
static void set_spmap_config_param(
  struct yac_param * param,
  struct yac_interp_spmap_config const * config,
  int include_scale,
  char const * routine) {
 
  set_sub_param_dble(
    param, "spread_distance",
    yac_interp_spmap_config_get_spread_distance(config), routine);
  set_sub_param_dble(
    param, "max_search_distance",
    yac_interp_spmap_config_get_max_search_distance(config), routine);
  set_sub_param_int(
    param, "weighted",
    (int)yac_interp_spmap_config_get_weight_type(config), routine);
 
  if (!include_scale) return;
 
  struct yac_spmap_scale_config const * scale_config =
    yac_interp_spmap_config_get_scale_config(config);
  set_sub_param_int(
    param, "scale",
    (int)yac_spmap_scale_config_get_type(scale_config), routine);
 
  set_spmap_cell_area_param(
    get_sub_param(param, "src_cell_area", routine),
    yac_spmap_scale_config_get_src_cell_area_config(scale_config),
    "src_cell_area", routine);
  set_spmap_cell_area_param(
    get_sub_param(param, "tgt_cell_area", routine),
    yac_spmap_scale_config_get_tgt_cell_area_config(scale_config),
    "tgt_cell_area", routine);
}
 
void yac_interp_stack_config_add_spmap_ext(
  struct yac_interp_stack_config * interp_stack_config,
  struct yac_interp_spmap_config * default_config,
  struct yac_spmap_overwrite_config ** overwrite_configs) {
 
  char const * routine = "yac_interp_stack_config_add_spmap_ext";
 
  struct yac_interp_method_config * method_config =
    yac_interp_method_config_default_from_name_new("source_to_target_map");
  struct yac_param * root_param =
    get_method_param(method_config, routine);
 
  set_spmap_config_param(root_param, default_config, 1, routine);
 
  struct yac_param * overwrite_param =
    get_sub_param(root_param, "overwrite", routine);
  for (size_t i = 0;
       (overwrite_configs != NULL) && (overwrite_configs[i] != NULL);
       ++i) {
 
    struct yac_param * overwrite_entry_param = NULL;
    int ierr =
      yac_param_append(
        overwrite_param, &overwrite_entry_param);
    YAC_ASSERT_F(
      ierr == 0,
      "ERROR(%s): failed to append overwrite config: %s",
      routine, yac_param_get_last_error());
 
    struct yac_point_selection const * src_point_selection =
      yac_spmap_overwrite_config_get_src_point_selection(overwrite_configs[i]);
    YAC_ASSERT_F(
      yac_point_selection_get_type(src_point_selection) ==
        YAC_POINT_SELECTION_TYPE_BND_CIRCLE,
      "ERROR(%s): unsupported overwrite source point selection type", routine);
 
    double center_lon, center_lat, inc_angle;
    yac_point_selection_bnd_circle_get_config(
      src_point_selection, &center_lon, &center_lat, &inc_angle);
    struct yac_param * condition_oneof_param =
      get_sub_param(overwrite_entry_param, "condition", routine);
    struct yac_param * condition_param =
      get_sub_param(condition_oneof_param, "bounding_circle", routine);
    struct yac_param * center_param =
      get_sub_param(condition_param, "center", routine);
    set_sub_param_dble(center_param, "lon", center_lon, routine);
    set_sub_param_dble(center_param, "lat", center_lat, routine);
    set_sub_param_dble(condition_param, "radius", inc_angle, routine);
 
    set_spmap_config_param(
      overwrite_entry_param,
      yac_spmap_overwrite_config_get_spmap_config(overwrite_configs[i]),
      0, routine);
  }
 
  yac_param_delete(root_param);
  yac_interp_stack_config_add(interp_stack_config, method_config);
}
 
void yac_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,
  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) {
 
  struct yac_spmap_cell_area_config * src_cell_area_config =
    generate_spmap_cell_area_config(
      src_sphere_radius, src_filename, src_varname,
      src_min_global_id, "source");
  struct yac_spmap_cell_area_config * tgt_cell_area_config =
    generate_spmap_cell_area_config(
      tgt_sphere_radius, tgt_filename, tgt_varname,
      tgt_min_global_id, "target");
  struct yac_spmap_scale_config * scale_config =
    yac_spmap_scale_config_new(
      scale_type, src_cell_area_config, tgt_cell_area_config);
  struct yac_interp_spmap_config * default_config =
    yac_interp_spmap_config_new(
      spread_distance, max_search_distance, weight_type, scale_config);
 
  yac_spmap_scale_config_delete(scale_config);
  yac_spmap_cell_area_config_delete(src_cell_area_config);
  yac_spmap_cell_area_config_delete(tgt_cell_area_config);
 
  struct yac_spmap_overwrite_config ** overwrite_configs = NULL;
 
  yac_interp_stack_config_add_spmap_ext(
    interp_stack_config, default_config, overwrite_configs);
  yac_interp_spmap_config_delete(default_config);
}
 
void yac_interp_stack_config_add_spmap_f2c(
  struct yac_interp_stack_config * interp_stack_config,
  double spread_distance, double max_search_distance,
  int weight_type, int 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) {
 
  char const * routine = "yac_interp_stack_config_add_spmap_f2c";
 
  YAC_ASSERT_F(
    (weight_type == YAC_INTERP_SPMAP_AVG) ||
    (weight_type == YAC_INTERP_SPMAP_DIST),
    "ERROR(%s): weight_type must be one of "
    "YAC_INTERP_SPMAP_AVG/YAC_INTERP_SPMAP_DIST.", routine)
 
  YAC_ASSERT_F(
    (scale_type == YAC_INTERP_SPMAP_NONE) ||
    (scale_type == YAC_INTERP_SPMAP_SRCAREA) ||
    (scale_type == YAC_INTERP_SPMAP_INVTGTAREA) ||
    (scale_type == YAC_INTERP_SPMAP_FRACAREA),
    "ERROR(%s): scale_type must be one of "
    "YAC_INTERP_SPMAP_NONE/YAC_INTERP_SPMAP_SRCAREA/"
    "YAC_INTERP_SPMAP_INVTGTAREA/YAC_INTERP_SPMAP_FRACAREA.", routine)
 
  if (src_filename && (src_filename[0] == '\0')) src_filename = NULL;
  if (src_varname && (src_varname[0] == '\0')) src_varname = NULL;
  if (tgt_filename && (tgt_filename[0] == '\0')) tgt_filename = NULL;
  if (tgt_varname && (tgt_varname[0] == '\0')) tgt_varname = NULL;
 
  yac_interp_stack_config_add_spmap(
    interp_stack_config, spread_distance, max_search_distance,
    (enum yac_interp_spmap_weight_type)weight_type,
    (enum yac_interp_spmap_scale_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);
}
 
void yac_interp_stack_config_add_hcsbb(
  struct yac_interp_stack_config * interp_stack_config) {
 
  struct yac_interp_method_config * method_config =
    yac_interp_method_config_default_from_name_new("bernstein_bezier");
 
  yac_interp_stack_config_add(interp_stack_config, method_config);
}
 
static void check_string(
  char const * string, char const * file, int line, char const * routine,
  char const * variable) {
 
  YAC_ASSERT_F(
    string != NULL, "ERROR(%s:%d:%s): %s is NULL",
    file, line, routine, variable)
  YAC_ASSERT_F(
    strlen(string) < YAC_MAX_FILE_NAME_LENGTH,
    "ERROR(%s:%d:%s): %s is too long", file, line, routine, variable)
}
 
void yac_interp_stack_config_add_user_file(
  struct yac_interp_stack_config * interp_stack_config,
  char const * filename,
  enum yac_interp_file_on_missing_file on_missing_file,
  enum yac_interp_file_on_success on_success) {
 
  char const * routine = "yac_interp_stack_config_add_user_file";
 
  check_string(filename, __FILE__, __LINE__, routine, "filename");
 
  struct yac_interp_method_config * method_config =
    yac_interp_method_config_default_from_name_new("file");
  struct yac_param * root_param =
    get_method_param(method_config, routine);
 
  set_sub_param_str(
    root_param, "filename", filename, routine);
  set_sub_param_int(
    root_param, "on_missing_file", (int)on_missing_file, routine);
  set_sub_param_int(
    root_param, "on_success", (int)on_success, routine);
 
  yac_param_delete(root_param);
  yac_interp_stack_config_add(interp_stack_config, method_config);
}
 
void yac_interp_stack_config_add_user_file_f2c(
  struct yac_interp_stack_config * interp_stack_config,
  char const * filename, int on_missing_file, int on_success) {
 
  char const * routine = "yac_interp_stack_config_add_user_file_f2c";
 
  if (filename && (filename[0] == '\0')) filename = NULL;
  YAC_ASSERT_F(
    (on_missing_file == YAC_INTERP_FILE_MISSING_ERROR) ||
    (on_missing_file == YAC_INTERP_FILE_MISSING_CONT),
    "ERROR(%s): on_missing_file must be one of "
    "YAC_INTERP_FILE_MISSING_ERROR/YAC_INTERP_FILE_MISSING_CONT.", routine)
  YAC_ASSERT_F(
    (on_success == YAC_INTERP_FILE_SUCCESS_STOP) ||
    (on_success == YAC_INTERP_FILE_SUCCESS_CONT),
    "ERROR(%s): on_success must be one of "
    "YAC_INTERP_FILE_SUCCESS_STOP/YAC_INTERP_FILE_SUCCESS_CONT.", routine)
 
  yac_interp_stack_config_add_user_file(
    interp_stack_config, filename,
    (enum yac_interp_file_on_missing_file)on_missing_file,
    (enum yac_interp_file_on_success)on_success);
}
 
void yac_interp_stack_config_add_fixed(
  struct yac_interp_stack_config * interp_stack_config, double value) {
 
  char const * routine = "yac_interp_stack_config_add_fixed";
 
  struct yac_interp_method_config * method_config =
    yac_interp_method_config_default_from_name_new("fixed");
  struct yac_param * root_param = get_method_param(method_config, routine);
 
  set_sub_param_dble(root_param, "user_value", value, routine);
 
  yac_param_delete(root_param);
  yac_interp_stack_config_add(interp_stack_config, method_config);
}
 
void yac_interp_stack_config_add_check(
  struct yac_interp_stack_config * interp_stack_config,
  char const * constructor_key, char const * do_search_key) {
 
  char const * routine = "yac_interp_stack_config_add_check";
 
  YAC_ASSERT_F(
    !constructor_key || strlen(constructor_key) < YAC_MAX_ROUTINE_NAME_LENGTH,
    "ERROR(%s): constructor_key name \"%s\" is too long "
    "(has to be smaller than %d)",
    routine, constructor_key, YAC_MAX_ROUTINE_NAME_LENGTH);
  YAC_ASSERT_F(
    !do_search_key || strlen(do_search_key) < YAC_MAX_ROUTINE_NAME_LENGTH,
    "ERROR(%s): do_search_key name \"%s\" is too long "
    "(has to be smaller than %d)",
    routine, do_search_key, YAC_MAX_ROUTINE_NAME_LENGTH);
 
  struct yac_interp_method_config * method_config =
    yac_interp_method_config_default_from_name_new("check");
  struct yac_param * root_param =
    get_method_param(method_config, routine);
 
  set_sub_param_str(
    root_param, "constructor_key", constructor_key?constructor_key:"", routine);
  set_sub_param_str(
    root_param, "do_search_key", do_search_key?do_search_key:"", routine);
 
  yac_param_delete(root_param);
  yac_interp_stack_config_add(interp_stack_config, method_config);
}
 
void yac_interp_stack_config_add_creep(
  struct yac_interp_stack_config * interp_stack_config, int creep_distance) {
 
  char const * routine = "yac_interp_stack_config_add_creep";
 
  struct yac_interp_method_config * method_config =
    yac_interp_method_config_default_from_name_new("creep");
  struct yac_param * root_param = get_method_param(method_config, routine);
 
  set_sub_param_int(root_param, "creep_distance", creep_distance, routine);
 
  yac_param_delete(root_param);
  yac_interp_stack_config_add(interp_stack_config, method_config);
}
 
void yac_interp_stack_config_add_user_callback(
  struct yac_interp_stack_config * interp_stack_config,
  char const * func_compute_weights_key) {
 
  char const * routine = "yac_interp_stack_config_add_user_callback";
 
  check_string(
    func_compute_weights_key, __FILE__, __LINE__,
    routine, "func_compute_weights_key");
 
  struct yac_interp_method_config * method_config =
    yac_interp_method_config_default_from_name_new("user_callback");
  struct yac_param * root_param = get_method_param(method_config, routine);
 
  set_sub_param_str(
    root_param, "func_compute_weights", func_compute_weights_key, routine);
 
  yac_param_delete(root_param);
  yac_interp_stack_config_add(interp_stack_config, method_config);
}
 
size_t yac_interp_stack_config_get_size(
  struct yac_interp_stack_config * interp_stack) {
 
  return interp_stack->size;
}
 
struct yac_interp_method_config const * yac_interp_stack_config_get(
    struct yac_interp_stack_config * interp_stack,
    size_t interp_stack_idx) {
 
  YAC_ASSERT(
    interp_stack_idx < interp_stack->size,
    "ERROR(yac_interp_stack_config_get): invalid interpolation stack index");
 
  return interp_stack->entries[interp_stack_idx].data.config;
}
 
union yac_interp_stack_config_entry const *
  yac_interp_stack_config_get_entry(
    struct yac_interp_stack_config * interp_stack,
    size_t interp_stack_idx) {
 
  YAC_ASSERT(
    interp_stack_idx < interp_stack->size,
    "ERROR(yac_interp_stack_config_get_entry): "
    "invalid interpolation stack index");
 
  return &interp_stack->entries[interp_stack_idx];
}
 
enum yac_interpolation_list yac_interp_stack_config_entry_get_type(
  union yac_interp_stack_config_entry const * interp_stack_entry) {
 
  struct yac_interp_method_config const * config =
    interp_stack_entry->data.config;
  return yac_interp_method_config_get_type(config);
}
 
void yac_interp_stack_config_entry_get_average(
  union yac_interp_stack_config_entry const * interp_stack_entry,
  enum yac_interp_avg_weight_type * reduction_type,
  int * partial_coverage) {
 
  const struct yac_interp_method_config *config =
    interp_stack_entry->data.config;
  char const * routine = "yac_interp_stack_config_entry_get_average";
  YAC_ASSERT(
    yac_interp_method_config_get_type(config) == YAC_AVERAGE,
    "ERROR(yac_interp_stack_config_entry_get_average): "
    "wrong interpolation stack entry type");
 
  struct yac_param * root_param =
    get_entry_param(interp_stack_entry, routine);
 
  *reduction_type =
    (enum yac_interp_avg_weight_type)get_param_int(
      get_sub_param(root_param, "weighted", routine), "weighted", routine);
  *partial_coverage =
    get_param_int(
      get_sub_param(root_param, "partial_coverage", routine),
      "partial_coverage", routine);
 
  yac_param_delete(root_param);
}
 
void yac_interp_stack_config_entry_get_ncc(
  union yac_interp_stack_config_entry const * interp_stack_entry,
  enum yac_interp_ncc_weight_type * type, int * partial_coverage) {
 
  const struct yac_interp_method_config *config =
    interp_stack_entry->data.config;
  char const * routine = "yac_interp_stack_config_entry_get_ncc";
  YAC_ASSERT(
    yac_interp_method_config_get_type(config) == YAC_NEAREST_CORNER_CELLS,
    "ERROR(yac_interp_stack_config_entry_get_ncc): "
    "wrong interpolation stack entry type");
 
  struct yac_param * root_param =
    get_entry_param(interp_stack_entry, routine);
 
  *type =
    (enum yac_interp_ncc_weight_type)get_param_int(
      get_sub_param(root_param, "weighted", routine), "weighted", routine);
  *partial_coverage =
    get_param_int(
      get_sub_param(root_param, "partial_coverage", routine),
      "partial_coverage", routine);
 
  yac_param_delete(root_param);
}
 
void yac_interp_stack_config_entry_get_dnn(
  union yac_interp_stack_config_entry const * interp_stack_entry,
  enum yac_interp_dnn_weight_type * type,
  enum yac_interp_dnn_search_distance_type * search_distance_type,
  double * search_distance, double * scale) {
 
  const struct yac_interp_method_config *config =
    interp_stack_entry->data.config;
  char const * routine = "yac_interp_stack_config_entry_get_dnn";
 
  YAC_ASSERT_F(
    yac_interp_method_config_get_type(config) == YAC_DISTANCE_NEAREST_NEIGHBOR,
    "ERROR(%s): wrong interpolation stack entry type", routine);
 
  struct yac_param * root_param =
    get_entry_param(interp_stack_entry, routine);
 
  *type =
    (enum yac_interp_dnn_weight_type)get_param_int(
      get_sub_param(root_param, "weighted", routine), "weighted", routine);
 
  struct yac_param * search_distance_oneof_param =
    get_sub_param(root_param, "search_distance", routine);
  struct yac_param * search_distance_param =
    get_sub_param_by_index(
      search_distance_oneof_param, 0, "search_distance", routine);
  char const * search_distance_name =
    yac_param_get_name(search_distance_param);
  YAC_ASSERT_F(
    search_distance_name != NULL,
    "ERROR(%s): invalid search_distance parameter", routine);
 
  if (!strcmp(search_distance_name, "fixed")) {
    *search_distance_type = YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED;
  } else if (!strcmp(search_distance_name, "cell_area")) {
    *search_distance_type = YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA;
  } else {
    YAC_UNREACHABLE_F(
      "ERROR(%s): invalid search distance type \"%s\"",
      routine, search_distance_name);
  }
 
  *search_distance =
    get_param_dble(search_distance_param, "search_distance", routine);
 
  switch (*search_distance_type) {
    YAC_UNREACHABLE_DEFAULT_F(
      "ERROR(%s): invalid search distance type", routine);
    case YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED:
    case YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA:
      break;
  }
 
  switch (*type) {
    YAC_UNREACHABLE_DEFAULT_F("ERROR(%s): invalid weight type", routine);
    case YAC_INTERP_DNN_WEIGHT_AVG: {__attribute__((fallthrough));}
    case YAC_INTERP_DNN_WEIGHT_DIST:
      *scale = YAC_INTERP_DNN_DUMMY_SCALE;
      break;
    case YAC_INTERP_DNN_WEIGHT_RBF:
      *scale =
        get_param_dble(
          get_sub_param(root_param, "rbf_scale", routine),
          "rbf_scale", routine);
      break;
    case YAC_INTERP_DNN_WEIGHT_GAUSS:
      *scale =
        get_param_dble(
          get_sub_param(root_param, "gauss_scale", routine),
          "gauss_scale", routine);
      break;
  }
 
  yac_param_delete(root_param);
}
 
void yac_interp_stack_config_entry_get_nnn(
  union yac_interp_stack_config_entry const * interp_stack_entry,
  enum yac_interp_nnn_weight_type * type, size_t * n,
  double * max_search_distance, double * scale) {
 
  const struct yac_interp_method_config *config =
    interp_stack_entry->data.config;
  char const * routine = "yac_interp_stack_config_entry_get_nnn";
 
  enum yac_interpolation_list method_type =
    yac_interp_method_config_get_type(config);
 
  YAC_ASSERT_F(
    method_type == YAC_N_NEAREST_NEIGHBOR ||
    method_type == YAC_RADIAL_BASIS_FUNCTION,
    "ERROR(%s): wrong interpolation stack entry type", routine);
 
  struct yac_param * root_param =
    get_entry_param(interp_stack_entry, routine);
 
  *type = (method_type == YAC_RADIAL_BASIS_FUNCTION)?
    YAC_INTERP_NNN_RBF:
    (enum yac_interp_nnn_weight_type)get_param_int(
      get_sub_param(root_param, "weighted", routine), "weighted", routine);
 
  *n = (size_t)get_param_int(
    get_sub_param(root_param, "n", routine), "n", routine);
  *max_search_distance =
    get_param_dble(
      get_sub_param(root_param, "max_search_distance", routine),
      "max_search_distance", routine);
  if (*type == YAC_INTERP_NNN_RBF)
    *scale =
      get_param_dble(
        get_sub_param(root_param, "rbf_scale", routine),
        "rbf_scale", routine);
  else
    *scale =
      get_param_dble(
        get_sub_param(root_param, "gauss_scale", routine),
        "gauss_scale", routine);
 
  yac_param_delete(root_param);
}
 
void yac_interp_stack_config_entry_get_rbf(
  union yac_interp_stack_config_entry const * interp_stack_entry,
  size_t * n, double * max_search_distance, double * scale) {
 
  const struct yac_interp_method_config *config =
    interp_stack_entry->data.config;
  char const * routine = "yac_interp_stack_config_entry_get_rbf";
  YAC_ASSERT_F(
    yac_interp_method_config_get_type(config) == YAC_RADIAL_BASIS_FUNCTION,
    "ERROR(%s): wrong interpolation stack entry type", routine);
 
  struct yac_param * root_param =
    get_entry_param(interp_stack_entry, routine);
 
  *n = (size_t)get_param_int(
    get_sub_param(root_param, "n", routine), "n", routine);
  *max_search_distance =
    get_param_dble(
      get_sub_param(root_param, "max_search_distance", routine),
      "max_search_distance", routine);
  *scale =
    get_param_dble(
      get_sub_param(root_param, "rbf_scale", routine),
      "rbf_scale", routine);
 
  yac_param_delete(root_param);
}
 
void yac_interp_stack_config_entry_get_conservative(
  union yac_interp_stack_config_entry const * interp_stack_entry,
  int * order, int * enforced_conserv, int * partial_coverage,
  enum yac_interp_method_conserv_normalisation * normalisation) {
 
  const struct yac_interp_method_config *config =
    interp_stack_entry->data.config;
  char const * routine = "yac_interp_stack_config_entry_get_conservative";
  YAC_ASSERT_F(
    yac_interp_method_config_get_type(config) == YAC_CONSERVATIVE,
    "ERROR(%s): wrong interpolation stack entry type", routine);
 
  struct yac_param * root_param =
    get_entry_param(interp_stack_entry, routine);
 
  *order =
    get_param_int(get_sub_param(root_param, "order", routine), "order", routine);
  *enforced_conserv =
    get_param_int(
      get_sub_param(root_param, "enforced_conservation", routine),
      "enforced_conservation", routine);
  *partial_coverage =
    get_param_int(
      get_sub_param(root_param, "partial_coverage", routine),
      "partial_coverage", routine);
  *normalisation =
    (enum yac_interp_method_conserv_normalisation)get_param_int(
      get_sub_param(root_param, "normalisation", routine),
      "normalisation", routine);
 
  yac_param_delete(root_param);
}
 
void yac_interp_stack_config_entry_get_spmap_ext(
  union yac_interp_stack_config_entry const * interp_stack_entry,
  struct yac_interp_spmap_config const ** default_config,
  struct yac_spmap_overwrite_config const *** overwrite_configs) {
 
  const struct yac_interp_method_config *config =
    interp_stack_entry->data.config;
  char const * routine = "yac_interp_stack_config_entry_get_spmap_ext";
  YAC_ASSERT_F(
    yac_interp_method_config_get_type(config) == YAC_SOURCE_TO_TARGET_MAP,
    "ERROR(%s): wrong interpolation stack entry type", routine);
 
  struct yac_param * root_param =
    get_entry_param(interp_stack_entry, routine);
  size_t overwrite_count =
    get_sub_count(
      get_sub_param(root_param, "overwrite", routine),
      "overwrite", routine);
 
  struct yac_spmap_ext_cache_entry * cache_entry =
    get_spmap_ext_cache_entry(
      (union yac_interp_stack_config_entry *)interp_stack_entry,
      root_param, routine);
 
  size_t cache_overwrite_count = 0;
  for (; (cache_entry->overwrite_configs != NULL) &&
         (cache_entry->overwrite_configs[cache_overwrite_count] != NULL);
       ++cache_overwrite_count)
    ;
  YAC_ASSERT_F(
    cache_overwrite_count == overwrite_count,
    "ERROR(%s): inconsistent overwrite configuration count", routine);
 
  *default_config = cache_entry->default_config;
  *overwrite_configs =
    (struct yac_spmap_overwrite_config const **)cache_entry->overwrite_configs;
 
  yac_param_delete(root_param);
}
 
static void yac_interp_stack_config_entry_get_spmap_cell_area_config(
  struct yac_param * cell_area_oneof_param,
  char const * routine,
  char const * name,
  double * sphere_radius,
  char const ** filename, char const ** varname, int * min_global_id) {
 
  struct yac_spmap_cell_area_config * cell_area_config =
    make_spmap_cell_area_config(cell_area_oneof_param, name, routine);
 
  switch (yac_spmap_cell_area_config_get_type(cell_area_config)) {
    YAC_UNREACHABLE_DEFAULT_F(
      "ERROR(%s): invalid %s cell area configuration type",
      routine, name);
    case(YAC_INTERP_SPMAP_CELL_AREA_FILE): {
      *sphere_radius = YAC_INTERP_SPMAP_SPHERE_RADIUS_DEFAULT;
      *filename =
        xstrdup(yac_spmap_cell_area_config_get_filename(cell_area_config));
      *varname =
        xstrdup(yac_spmap_cell_area_config_get_varname(cell_area_config));
      *min_global_id =
        yac_spmap_cell_area_config_get_min_global_id(cell_area_config);
      break;
    }
    case(YAC_INTERP_SPMAP_CELL_AREA_YAC): {
      *sphere_radius =
        yac_spmap_cell_area_config_get_sphere_radius(cell_area_config);
      *filename = YAC_INTERP_SPMAP_FILENAME_DEFAULT;
      *varname = YAC_INTERP_SPMAP_VARNAME_DEFAULT;
      *min_global_id = YAC_INTERP_SPMAP_MIN_GLOBAL_ID_DEFAULT;
      break;
    }
  }
  yac_spmap_cell_area_config_delete(cell_area_config);
}
 
void yac_interp_stack_config_entry_get_spmap(
  union yac_interp_stack_config_entry const * interp_stack_entry,
  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) {
 
  const struct yac_interp_method_config *config =
    interp_stack_entry->data.config;
  char const * routine = "yac_interp_stack_config_entry_get_spmap";
 
  YAC_ASSERT_F(
    yac_interp_method_config_get_type(config) == YAC_SOURCE_TO_TARGET_MAP,
    "ERROR(%s): wrong interpolation stack entry type", routine);
 
  struct yac_param * root_param =
    get_entry_param(interp_stack_entry, routine);
 
  size_t overwrite_count =
    get_sub_count(get_sub_param(root_param, "overwrite", routine),
      "overwrite", routine);
 
  YAC_ASSERT_F(
    overwrite_count == 0,
    "ERROR(%s): contains overwrite configurations, use "
    "yac_interp_stack_config_entry_get_spmap_ext instead", routine);
 
  *spread_distance =
    get_param_dble(
      get_sub_param(root_param, "spread_distance", routine),
      "spread_distance", routine);
  *max_search_distance =
    get_param_dble(
      get_sub_param(root_param, "max_search_distance", routine),
      "max_search_distance", routine);
  *weight_type =
    (enum yac_interp_spmap_weight_type)get_param_int(
      get_sub_param(root_param, "weighted", routine), "weighted", routine);
 
  *scale_type =
    (enum yac_interp_spmap_scale_type)get_param_int(
      get_sub_param(root_param, "scale", routine), "scale", routine);
 
  yac_interp_stack_config_entry_get_spmap_cell_area_config(
    get_sub_param(root_param, "src_cell_area", routine),
    routine, "src_cell_area",
    src_sphere_radius, src_filename, src_varname, src_min_global_id);
  yac_interp_stack_config_entry_get_spmap_cell_area_config(
    get_sub_param(root_param, "tgt_cell_area", routine),
    routine, "tgt_cell_area",
    tgt_sphere_radius, tgt_filename, tgt_varname, tgt_min_global_id);
 
  yac_param_delete(root_param);
}
 
void yac_interp_stack_config_entry_get_user_file(
  union yac_interp_stack_config_entry const * interp_stack_entry,
  char const ** filename,
  enum yac_interp_file_on_missing_file * on_missing_file,
  enum yac_interp_file_on_success * on_success) {
 
  const struct yac_interp_method_config *config =
    interp_stack_entry->data.config;
  char const * routine = "yac_interp_stack_config_entry_get_user_file";
  YAC_ASSERT_F(
    yac_interp_method_config_get_type(config) == YAC_USER_FILE,
    "ERROR(%s): wrong interpolation stack entry type", routine);
 
  struct yac_param * root_param =
    get_entry_param(interp_stack_entry, routine);
 
  *filename =
    get_param_str_dup(
      get_sub_param(root_param, "filename", routine),
      "filename", routine);
  *on_missing_file =
    (enum yac_interp_file_on_missing_file)get_param_int(
      get_sub_param(root_param, "on_missing_file", routine),
      "on_missing_file", routine);
  *on_success =
    (enum yac_interp_file_on_success)get_param_int(
      get_sub_param(root_param, "on_success", routine),
      "on_success", routine);
 
  yac_param_delete(root_param);
}
 
void yac_interp_stack_config_entry_get_fixed(
  union yac_interp_stack_config_entry const * interp_stack_entry,
  double * value) {
 
  const struct yac_interp_method_config *config =
    interp_stack_entry->data.config;
  char const * routine = "yac_interp_stack_config_entry_get_fixed";
  YAC_ASSERT_F(
    yac_interp_method_config_get_type(config) == YAC_FIXED_VALUE,
    "ERROR(%s): wrong interpolation stack entry type", routine);
 
  struct yac_param * root_param =
    get_entry_param(interp_stack_entry, routine);
 
  *value =
    get_param_dble(
      get_sub_param(root_param, "user_value", routine), "user_value", routine);
 
  yac_param_delete(root_param);
}
 
void yac_interp_stack_config_entry_get_check(
  union yac_interp_stack_config_entry const * interp_stack_entry,
  char const ** constructor_key, char const ** do_search_key) {
 
  const struct yac_interp_method_config *config =
    interp_stack_entry->data.config;
  char const * routine = "yac_interp_stack_config_entry_get_check";
  YAC_ASSERT_F(
    yac_interp_method_config_get_type(config) == YAC_CHECK,
    "ERROR(%s): wrong interpolation stack entry type", routine);
 
  struct yac_param * root_param =
    get_entry_param(interp_stack_entry, routine);
 
  *constructor_key =
    get_param_str_dup(
      get_sub_param(root_param, "constructor_key", routine),
      "constructor_key", routine);
  *do_search_key =
    get_param_str_dup(
      get_sub_param(root_param, "do_search_key", routine),
      "do_search_key", routine);
 
  yac_param_delete(root_param);
}
 
void yac_interp_stack_config_entry_get_creep(
  union yac_interp_stack_config_entry const * interp_stack_entry,
  int * creep_distance) {
 
  const struct yac_interp_method_config *config =
    interp_stack_entry->data.config;
  char const * routine = "yac_interp_stack_config_entry_get_creep";
  YAC_ASSERT_F(
    yac_interp_method_config_get_type(config) == YAC_CREEP,
    "ERROR(%s): wrong interpolation stack entry type", routine);
 
  struct yac_param * root_param =
    get_entry_param(interp_stack_entry, routine);
 
  *creep_distance =
    get_param_int(
      get_sub_param(root_param, "creep_distance", routine),
      "creep_distance", routine);
 
  yac_param_delete(root_param);
}
 
void yac_interp_stack_config_entry_get_user_callback(
  union yac_interp_stack_config_entry const * interp_stack_entry,
  char const ** func_compute_weights_key) {
 
  const struct yac_interp_method_config *config =
    interp_stack_entry->data.config;
  char const * routine = "yac_interp_stack_config_entry_get_user_callback";
  YAC_ASSERT_F(
    yac_interp_method_config_get_type(config) == YAC_USER_CALLBACK,
    "ERROR(%s): wrong interpolation stack entry type", routine);
 
  struct yac_param * root_param =
    get_entry_param(interp_stack_entry, routine);
 
  *func_compute_weights_key =
    get_param_str_dup(
      get_sub_param(root_param, "func_compute_weights", routine),
      "func_compute_weights", routine);
 
  yac_param_delete(root_param);
}