interp_method_fixed.c

Go to the documentation of this file.

// Copyright (c) 2024 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifdef HAVE_CONFIG_H
// Get the definition of the 'restrict' keyword.
#include "config.h"
#endif
 
#include <limits.h>
 
#include "interpolation/methods/interp_method_internal.h"
#include "interpolation/methods/interp_method_config_internal.h"
#include "interpolation/methods/interp_method_fixed.h"
#include "parameter/param_dble.h"
#include "parameter/param_struct.h"
#include "instrument_internal.h"
#include "yac_mpi_common.h"
 
static size_t do_search_fixed(struct interp_method * method,
                              struct yac_interp_grid * interp_grid,
                              size_t * tgt_points, size_t count,
                              struct yac_interp_weights * weights,
                              int * interpolation_complete);
static void delete_fixed(struct interp_method * method);
 
static struct interp_method_vtable
  interp_method_fixed_vtable = {
    .do_search = do_search_fixed,
    .delete = delete_fixed};
 
struct interp_method_fixed {
 
  struct interp_method_vtable * vtable;
  double value;
};
 
static size_t do_search_fixed (struct interp_method * method,
                               struct yac_interp_grid * interp_grid,
                               size_t * tgt_points, size_t count,
                               struct yac_interp_weights * weights,
                               int * interpolation_complete) {
 
  if (*interpolation_complete) return 0;
 
  YAC_INSTRUMENT_START(YAC_INSTR_INTERP_SEARCH_FIXED);
 
  struct remote_points tgts = {
    .data =
      yac_interp_grid_get_tgt_remote_points(interp_grid, tgt_points, count),
    .count = count};
 
  yac_interp_weights_add_fixed(
    weights, &tgts, ((struct interp_method_fixed *)method)->value);
 
  free(tgts.data);
 
  YAC_INSTRUMENT_STOP(YAC_INSTR_INTERP_SEARCH_FIXED);
 
  return count;
}
 
struct interp_method * yac_interp_method_fixed_new(double value) {
 
  struct interp_method_fixed * method = xmalloc(1 * sizeof(*method));
 
  method->vtable = &interp_method_fixed_vtable;
  method->value = value;
 
  return (struct interp_method*)method;
}
 
static void delete_fixed(struct interp_method * method) {
  free(method);
}
 
// --- Modular config struct and vtable for FIXED method ---
 
struct yac_interp_method_config_fixed {
  struct yac_interp_method_config base;
  struct yac_interp_method_fixed_config config;
};
 
static void config_fixed_delete(
  struct yac_interp_method_config *config) {
  free(config);
}
 
static struct yac_interp_method_config * config_fixed_copy(
  const struct yac_interp_method_config *config) {
  DEF_INTERP_METHOD_CONFIG_TYPE(fixed)
  struct yac_interp_method_config_fixed *copy =
    xmalloc(sizeof(*copy));
  copy->base.vtable = config_fixed->base.vtable;
  copy->base.root_param_cache = NULL;
  copy->config = config_fixed->config;
  return (struct yac_interp_method_config *)copy;
}
 
static int config_fixed_compare(
  void const *a_, void const *b_) {
  DEF_INTERP_METHOD_CONFIG_COMPARE_TYPE(fixed)
    // Use memcmp for correct handling of NaNs in fixed values
  CHECK_DOUBLE_NAN(config.value);
  return 0;
}
 
// Gets interpolation method typed_config_hcsbb_get_type
static enum yac_interpolation_list config_fixed_get_type() {
  return YAC_FIXED_VALUE;
}
 
static struct interp_method * config_fixed_generate(
  struct yac_interp_method_config const *config)
{
  const struct yac_interp_method_config_fixed *config_fixed =
    (const struct yac_interp_method_config_fixed *)config;
  return yac_interp_method_fixed_new(config_fixed->config.value);
}
 
static struct yac_param *config_fixed_get_param(
  struct yac_interp_method_config const *config) {
  struct yac_interp_method_config_fixed *config_fixed =
    (struct yac_interp_method_config_fixed *)config;
 
  enum {
    VALUE_HAS_DEFAULT = 1,
    VALUE_IS_DEFINED = 1,
    VALUE_ALLOW_NAN = 1,
    VALUE_ALLOW_INF = 1,
  };
 
  double const value_min = -DBL_MAX;
  double const value_max = DBL_MAX;
 
  struct yac_param *value_param =
    yac_param_dble_new(
      "user_value",
      &config_fixed->config.value,
      YAC_INTERP_FIXED_VALUE_DEFAULT,
      value_min, value_max, VALUE_ALLOW_NAN, VALUE_ALLOW_INF,
      VALUE_HAS_DEFAULT,
      VALUE_IS_DEFINED);
 
  struct yac_param *root_param_array[] = {
    value_param
  };
  enum {
    ROOT_PARAM_ARRAY_SIZE =
      sizeof(root_param_array) / sizeof(root_param_array[0])
  };
 
  return yac_param_struct_new(
    "fixed", root_param_array, ROOT_PARAM_ARRAY_SIZE);
}
 
static struct yac_interp_method_config_vtable yac_interp_method_config_vtable_fixed = {
  .delete = config_fixed_delete,
  .copy = config_fixed_copy,
  .compare = config_fixed_compare,
  .get_type = config_fixed_get_type,
  .generate = config_fixed_generate,
  .get_param = config_fixed_get_param
};
 
struct yac_interp_method_config *yac_interp_method_config_default_fixed_new(void) {
  struct yac_interp_method_config_fixed *config_fixed =
    xmalloc(sizeof(*config_fixed));
  config_fixed->base.vtable = &yac_interp_method_config_vtable_fixed;
  config_fixed->base.root_param_cache = NULL;
  config_fixed->config = (struct yac_interp_method_fixed_config){
    .value = YAC_INTERP_FIXED_VALUE_DEFAULT,
  };
  return (struct yac_interp_method_config *)config_fixed;
}