interpolation_gen_config.c

Go to the documentation of this file.

// Copyright (c) 2025 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <stdlib.h>
#include <string.h>
 
#include <mpi.h>
 
#include "ppm/ppm_xfuncs.h"
 
#include "interpolation/interp_weights.h"
#include "utils_core.h"
#include "interpolation/interpolation_internal.h"
#include "interpolation/interpolation_gen_config_internal.h"
#include "collection_selection_internal.h"
#include "yac_mpi_internal.h"
 
struct yac_interpolation_gen_config {
 
  enum yac_interp_weights_reorder_type reorder;
 
  struct yac_collection_selection * collection_selection;
 
  double frac_mask_fallback_value;
 
  double scaling_factor;
 
  double scaling_summand;
 
  char * yaxt_exchanger_name;
};
 
struct yac_interpolation_gen_config *
  yac_interpolation_gen_config_new(void) {
 
  struct yac_interpolation_gen_config * config = xmalloc(1 * sizeof(*config));
 
  config->reorder = YAC_MAPPING_ON_SRC;
  config->collection_selection = NULL; // unset
 
  // fractional masking is deactivated by default
  config->frac_mask_fallback_value = YAC_FRAC_MASK_NO_VALUE;
  config->scaling_factor = 1.0;
  config->scaling_summand = 0.0;
  config->yaxt_exchanger_name = NULL;
 
  return config;
}
 
void yac_interpolation_gen_config_delete(
  struct yac_interpolation_gen_config * config) {
 
  if (config == NULL) return;
  yac_collection_selection_delete(config->collection_selection);
  free(config->yaxt_exchanger_name);
  free(config);
}
 
struct yac_interpolation_gen_config * yac_interpolation_gen_config_copy(
  struct yac_interpolation_gen_config const * src) {
 
  if (src == NULL) return NULL;
 
  struct yac_interpolation_gen_config * copy = xmalloc(1 * sizeof(*copy));
 
  memcpy(copy, src, sizeof(*copy));
  copy->collection_selection =
    yac_collection_selection_copy(src->collection_selection);
  if (src->yaxt_exchanger_name != NULL) {
    copy->yaxt_exchanger_name = xstrdup(src->yaxt_exchanger_name);
  }
 
  return copy;
}
 
/* ---------------- Setters ---------------- */
 
void yac_interpolation_gen_config_set_reorder(
  struct yac_interpolation_gen_config * config,
  enum yac_interp_weights_reorder_type reorder) {
 
  YAC_ASSERT(config != NULL, "config is NULL");
  YAC_ASSERT(
    (reorder == YAC_MAPPING_ON_SRC) || (reorder == YAC_MAPPING_ON_TGT),
    "invalid reorder value");
 
  config->reorder = reorder;
}
 
 
void yac_interpolation_gen_config_set_reorder_f2c(
  struct yac_interpolation_gen_config * config, int reorder) {
 
  YAC_ASSERT(config != NULL, "config is NULL");
  YAC_ASSERT(
    (reorder == YAC_MAPPING_ON_SRC) || (reorder == YAC_MAPPING_ON_TGT),
    "invalid reorder value");
 
  yac_interpolation_gen_config_set_reorder(
    config, (enum yac_interp_weights_reorder_type)reorder);
}
 
void yac_interpolation_gen_config_set_collection_size(
  struct yac_interpolation_gen_config * config, size_t collection_size) {
 
  YAC_ASSERT(config != NULL, "config is NULL");
  YAC_ASSERT(
    collection_size != SIZE_MAX, "collection_size must be != SIZE_MAX");
  YAC_ASSERT(collection_size > 0, "collection_size must be > 0");
 
  yac_collection_selection_delete(config->collection_selection);
  config->collection_selection =
    yac_collection_selection_new(collection_size, NULL);
}
 
void yac_interpolation_gen_config_set_collection_selection(
  struct yac_interpolation_gen_config * config,
  struct yac_collection_selection const * collection_selection) {
 
  YAC_ASSERT(config != NULL, "config is NULL");
  YAC_ASSERT(
    collection_selection != NULL, "collection_selection must be != NULL");
  YAC_ASSERT(
    yac_collection_selection_get_collection_size(collection_selection) > 0,
    "collection_size of collection_selection must be > 0");
 
  yac_collection_selection_delete(config->collection_selection);
  config->collection_selection =
    yac_collection_selection_copy(collection_selection);
}
 
void yac_interpolation_gen_config_set_frac_mask_fallback_value(
  struct yac_interpolation_gen_config * config,
  double frac_mask_fallback_value) {
 
  YAC_ASSERT(config != NULL, "config is NULL");
  YAC_ASSERT_F(
    YAC_FRAC_MASK_VALUE_IS_VALID(frac_mask_fallback_value),
    "%lf is not a valid fractional masking fallback value",
    frac_mask_fallback_value);
 
  config->frac_mask_fallback_value = frac_mask_fallback_value;
}
 
void yac_interpolation_gen_config_set_scaling_factor(
  struct yac_interpolation_gen_config * config, double scaling_factor) {
 
  YAC_ASSERT(config != NULL, "config is NULL");
  YAC_ASSERT_F(
    isnormal(scaling_factor) || (fabs(scaling_factor) == 0.0),
    "%lf is not a valid scaling factor", scaling_factor);
 
  config->scaling_factor = scaling_factor;
}
 
void yac_interpolation_gen_config_set_scaling_summand(
  struct yac_interpolation_gen_config * config, double scaling_summand) {
 
  YAC_ASSERT(config != NULL, "config is NULL");
  YAC_ASSERT_F(
    isnormal(scaling_summand) || (fabs(scaling_summand) == 0.0),
    "%lf is not a valid scaling summand", scaling_summand);
 
  config->scaling_summand = scaling_summand;
}
 
void yac_interpolation_gen_config_set_yaxt_exchanger_name(
  struct yac_interpolation_gen_config * config, char const * name) {
 
  YAC_ASSERT(config != NULL, "config is NULL");
 
  free(config->yaxt_exchanger_name);
  config->yaxt_exchanger_name = (name == NULL)?NULL:xstrdup(name);
}
 
void yac_interpolation_gen_config_set_yaxt_exchanger_name_f2c(
  struct yac_interpolation_gen_config * config, char const * name) {
 
  YAC_ASSERT(config != NULL, "config is NULL");
 
  if ((name != NULL) && strlen(name) == 0) name = NULL;
  yac_interpolation_gen_config_set_yaxt_exchanger_name(config, name);
}
 
/* ---------------- Getters ---------------- */
 
enum yac_interp_weights_reorder_type yac_interpolation_gen_config_get_reorder(
  struct yac_interpolation_gen_config const * config) {
 
  YAC_ASSERT(config != NULL, "config is NULL");
 
  return config->reorder;
}
 
struct yac_collection_selection const *
  yac_interpolation_gen_config_get_collection_selection(
  struct yac_interpolation_gen_config const * config) {
 
  YAC_ASSERT(config != NULL, "config is NULL");
  YAC_ASSERT(
    config->collection_selection != NULL, "collection_selection is unset");
 
  return config->collection_selection;
}
 
double yac_interpolation_gen_config_get_frac_mask_fallback_value(
  struct yac_interpolation_gen_config const * config) {
 
  YAC_ASSERT(config != NULL, "config is NULL");
 
  return config->frac_mask_fallback_value;
}
 
double yac_interpolation_gen_config_get_scaling_factor(
  struct yac_interpolation_gen_config const * config) {
 
  YAC_ASSERT(config != NULL, "config is NULL");
 
  return config->scaling_factor;
}
 
double yac_interpolation_gen_config_get_scaling_summand(
  struct yac_interpolation_gen_config const * config) {
 
  YAC_ASSERT(config != NULL, "config is NULL");
 
  return config->scaling_summand;
}
 
const char * yac_interpolation_gen_config_get_yaxt_exchanger_name(
  struct yac_interpolation_gen_config const * config) {
 
  YAC_ASSERT(config != NULL, "config is NULL");
 
  return config->yaxt_exchanger_name;
}
 
int yac_interpolation_gen_config_compare(
    struct yac_interpolation_gen_config const * a,
    struct yac_interpolation_gen_config const * b) {
 
  // Same pointer or both NULL
  int ret = (a == b);
  if (ret) return 0;
 
  // One is NULL, the other is not
  ret = (a == NULL) - (b == NULL);
  if (ret) return ret;
 
  // Different reorder types
  ret = (a->reorder > b->reorder) - (a->reorder < b->reorder);
  if (ret) return ret;
 
  // Different collection selections
  ret =
    yac_collection_selection_compare(
      a->collection_selection, b->collection_selection);
  if (ret) return ret;
 
  // Different scaling factor
  ret = (a->scaling_factor > b->scaling_factor) -
        (a->scaling_factor < b->scaling_factor);
  if (ret) return ret;
 
  // Different scaling summand
  ret = (a->scaling_summand > b->scaling_summand) -
        (a->scaling_summand < b->scaling_summand);
  if (ret) return ret;
 
  // Different yaxt exchanger
  if (a->yaxt_exchanger_name != b->yaxt_exchanger_name) {
 
    // One is unset (default), the other is set
    ret = (a->yaxt_exchanger_name == NULL) -
          (b->yaxt_exchanger_name == NULL);
    if (ret) return ret;
 
    // Both exchangers are different
    ret = strcmp(a->yaxt_exchanger_name, b->yaxt_exchanger_name);
    if (ret) return ret;
  }
 
  // Different fractional mask values
  // (use memcmp to compare frac_mask_fallback_value, because they can be nan)
  ret =
    memcmp(
      &(a->frac_mask_fallback_value), &(b->frac_mask_fallback_value),
      sizeof(double));
  // if (ret) return ret;
 
  return ret;
}
 
size_t yac_interpolation_gen_config_get_pack_size(
  struct yac_interpolation_gen_config const *cfg, MPI_Comm comm) {
 
  YAC_ASSERT(cfg != NULL, "config is NULL");
 
  int pack_size_int, pack_size_dble;
  yac_mpi_call(MPI_Pack_size(1, MPI_INT, comm, &pack_size_int), comm);
  yac_mpi_call(MPI_Pack_size(1, MPI_DOUBLE, comm, &pack_size_dble), comm);
 
  return pack_size_int +  // reorder
         pack_size_dble + // frac_mask_fallback_value
         pack_size_dble + // scaling_factor
         pack_size_dble + // scaling_summand
         yac_collection_selection_get_pack_size(
           (cfg != NULL)?cfg->collection_selection:NULL, comm) +
         yac_string_get_pack_size(
           "yac_interpolation_gen_config_get_pack_size",
           (cfg != NULL)?cfg->yaxt_exchanger_name:NULL, comm, 1);
}
 
void yac_interpolation_gen_config_pack(
  struct yac_interpolation_gen_config const * cfg,
  void * buffer, int buffer_size, int * position, MPI_Comm comm) {
 
  YAC_ASSERT(cfg != NULL, "config is NULL");
 
  int reorder = (int)cfg->reorder;
  yac_mpi_call(
    MPI_Pack(&reorder, 1, MPI_INT, buffer, buffer_size, position, comm), comm);
 
  yac_mpi_call(
    MPI_Pack(
      &cfg->frac_mask_fallback_value, 1, MPI_DOUBLE, buffer, buffer_size,
      position, comm), comm);
  yac_mpi_call(
    MPI_Pack(
      &cfg->scaling_factor, 1, MPI_DOUBLE, buffer, buffer_size,
      position, comm), comm);
  yac_mpi_call(
    MPI_Pack(
      &cfg->scaling_summand, 1, MPI_DOUBLE, buffer, buffer_size,
      position, comm), comm);
 
  yac_collection_selection_pack(
    cfg->collection_selection, buffer, buffer_size, position, comm);
 
  yac_string_pack(
    "yac_interpolation_gen_config_pack",
    cfg->yaxt_exchanger_name, buffer, buffer_size, position, comm, 1);
}
 
struct yac_interpolation_gen_config * yac_interpolation_gen_config_unpack(
  void const * buffer, int buffer_size, int *position, MPI_Comm comm) {
 
  struct yac_interpolation_gen_config * cfg = xmalloc(1 * sizeof(*cfg));
 
  int reorder_int;
  yac_mpi_call(
    MPI_Unpack(buffer, buffer_size, position, &reorder_int, 1, MPI_INT, comm),
    comm);
  cfg->reorder = (enum yac_interp_weights_reorder_type)reorder_int;
 
  yac_mpi_call(
    MPI_Unpack(
      buffer, buffer_size, position,
      &cfg->frac_mask_fallback_value, 1, MPI_DOUBLE, comm), comm);
  yac_mpi_call(
    MPI_Unpack(
      buffer, buffer_size, position,
      &cfg->scaling_factor, 1, MPI_DOUBLE, comm), comm);
  yac_mpi_call(
    MPI_Unpack(
      buffer, buffer_size, position,
      &cfg->scaling_summand, 1, MPI_DOUBLE, comm), comm);
 
  cfg->collection_selection =
    yac_collection_selection_unpack(buffer, buffer_size, position, comm);
 
  cfg->yaxt_exchanger_name =
    yac_string_unpack(buffer, buffer_size, position, comm);
 
  return cfg;
}