test_interp_operator_fixed.c

Go to the documentation of this file.

// Copyright (c) 2025 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
 
#include <mpi.h>
#include <yaxt.h>
 
#include "tests.h"
#include "interpolation/interpolation.h"
#include "yac_mpi.h"
#include "test_common.h"
#include "interpolation/operators/interp_operator_fixed.h"
 
static void utest_init_data();
static void utest_check_fixed();
 
enum {
  MAX_COLLECTION_SIZE = 4, NUM_SRC_FIELDS = 1,
  NUM_SRC_POINTS = 1, NUM_TGT_POINTS = 8};
static double src_fields_data[MAX_COLLECTION_SIZE][NUM_SRC_FIELDS][NUM_SRC_POINTS];
static double tgt_field_data[MAX_COLLECTION_SIZE][NUM_TGT_POINTS];
static double ref_tgt_field_data[MAX_COLLECTION_SIZE][NUM_TGT_POINTS];
 
int main(void) {
 
  MPI_Init(NULL, NULL);
  xt_initialize(MPI_COMM_WORLD);
 
  int comm_rank, comm_size;
  MPI_Comm_rank(MPI_COMM_WORLD, &comm_rank);
  MPI_Comm_size(MPI_COMM_WORLD, &comm_size);
 
  if (comm_size != 2) {
    PUT_ERR("ERROR: test requires 2 processes");
    xt_finalize();
    MPI_Finalize();
    return TEST_EXIT_CODE;
  }
 
  // set up source field data structure
  double * src_fields[MAX_COLLECTION_SIZE][NUM_SRC_FIELDS];
  double ** src_fields_collection[MAX_COLLECTION_SIZE];
  for (size_t i = 0; i < MAX_COLLECTION_SIZE; ++i) {
    for (size_t j = 0; j < NUM_SRC_FIELDS; ++j) {
      src_fields[i][j] = src_fields_data[i][j];
    }
    src_fields_collection[i] = src_fields[i];
  }
 
  // set up target field data structure
  double * tgt_field_collection[MAX_COLLECTION_SIZE];
  for (size_t i = 0; i < MAX_COLLECTION_SIZE; ++i)
    tgt_field_collection[i] = tgt_field_data[i];
 
  struct {
    size_t N;
    size_t * indices;
  } collection_selection_configs[] =
    {{.N = 3, .indices = (size_t[]){0, 2, 3}},
     {.N = 4, .indices = (size_t[]){0, 1, 2, 3}},
     {.N = 2, .indices = NULL}};
  enum {
    NUM_COLL_SEL_CONFIGS =
      sizeof(collection_selection_configs) /
      sizeof(collection_selection_configs[0])};
 
  // for all collection selection configurations
  for (size_t i = 0; i < NUM_COLL_SEL_CONFIGS; ++i) {
 
    // create collection selection
    struct yac_collection_selection * sel =
      yac_collection_selection_new(
        collection_selection_configs[i].N,
        collection_selection_configs[i].indices);
 
    struct {
      double fixed_value;
      size_t num_tgts;
      size_t * tgts;
    } fixed_value_configs[] =
      {{.fixed_value = 1.0, .num_tgts = 0, .tgts = NULL},
       {.fixed_value = 2.0, .num_tgts = 4, .tgts = (size_t[]){0,2,4,6}},
       {.fixed_value = 3.0, .num_tgts = 8,
        .tgts = (size_t[]){0,1,2,3,4,5,6,7}}};
    enum {
      NUM_FIXED_VALUE_CONFIGS =
        sizeof(fixed_value_configs) /
        sizeof(fixed_value_configs[0])};
 
    // for all fixed value configurations
    for (size_t j = 0; j < NUM_FIXED_VALUE_CONFIGS; ++j) {
 
      // create fixed interpolation operators (on rank 1)
      // (dummy operator on rank 0)
      struct yac_interp_operator * interp_fixed =
        (comm_rank == 0)?
          yac_interp_operator_fixed_new(NULL, -1.0, 0, NULL):
          yac_interp_operator_fixed_new(
            sel, fixed_value_configs[j].fixed_value,
            fixed_value_configs[j].num_tgts, fixed_value_configs[j].tgts);
 
      for (int use_interp_fixed_copy = 0; use_interp_fixed_copy <= 1;
           ++use_interp_fixed_copy) {
 
        if (use_interp_fixed_copy) {
          struct yac_interp_operator * interp_fixed_copy =
            yac_interp_operator_copy(interp_fixed);
          yac_interp_operator_delete(interp_fixed);
          interp_fixed = interp_fixed_copy;
        }
 
        // generate reference data
        for (size_t k = 0; k < MAX_COLLECTION_SIZE; ++k) {
          for (size_t l = 0; l < NUM_TGT_POINTS; ++l) {
              ref_tgt_field_data[k][l] = (double)-1;
          }
        }
        if (comm_rank == 1) {
          for (size_t k = 0; k < collection_selection_configs[i].N; ++k) {
            double fixed_value = fixed_value_configs[j].fixed_value;
            for (size_t l = 0; l < fixed_value_configs[j].num_tgts; ++l) {
              ref_tgt_field_data[k][fixed_value_configs[j].tgts[l]] =
                fixed_value;
            }
          }
        }
 
        struct {
          double frac_mask_fallback_value;
        } frac_mask_configs[] =
          {{.frac_mask_fallback_value = YAC_FRAC_MASK_NO_VALUE},
           {.frac_mask_fallback_value = 10.0}};
        enum {
          NUM_FRAC_MASK_CONFIGS =
            sizeof(frac_mask_configs) / sizeof(frac_mask_configs[0])};
 
        for (size_t frac_mask_config_idx = 0;
             frac_mask_config_idx < NUM_FRAC_MASK_CONFIGS;
             ++frac_mask_config_idx) {
 
          double frac_mask_fallback_value =
            frac_mask_configs[frac_mask_config_idx].frac_mask_fallback_value;
 
          { // test synchronous exchange
 
            // initialise source and target fields data
            utest_init_data();
 
            yac_interp_operator_execute(
              interp_fixed, src_fields_collection, NULL, tgt_field_collection,
              frac_mask_fallback_value, 1.0, 0.0);
 
            // check data
            utest_check_fixed();
          }
 
          { // test independent execution of put and get
 
            // initialise source and target fields data
            utest_init_data();
 
            yac_interp_operator_execute_put(
              interp_fixed, src_fields_collection, NULL,
              1, frac_mask_fallback_value, 1.0, 0.0);
            yac_interp_operator_execute_get(
              interp_fixed, tgt_field_collection,
              frac_mask_fallback_value, 1.0, 0.0);
 
            // Before get: execute_put_test result is
            // undefined (can be either true or false)
            if (!yac_interp_operator_execute_put_test(interp_fixed))
              PUT_ERR("error in execute_put_test");
            if (!yac_interp_operator_execute_get_test(interp_fixed))
              PUT_ERR("error in execute_get_test");
 
            // check data
            utest_check_fixed();
          }
 
          { // test independent execution of put and async get
 
            // initialise source and target fields data
            utest_init_data();
 
            yac_interp_operator_execute_put(
              interp_fixed, src_fields_collection, NULL,
              1, frac_mask_fallback_value, 1.0, 0.0);
            yac_interp_operator_execute_get_async(
              interp_fixed, tgt_field_collection,
              frac_mask_fallback_value, 1.0, 0.0);
            yac_interp_operator_execute_wait(interp_fixed);
 
            // Before wait: execute_put_test and execute_get_test result is
            // undefined (can be either true or false)
            if (!yac_interp_operator_execute_put_test(interp_fixed))
              PUT_ERR("error in execute_put_test");
            if (!yac_interp_operator_execute_get_test(interp_fixed))
              PUT_ERR("error in execute_get_test");
 
            // check data
            utest_check_fixed();
          }
 
        } // frac_mask_config_idx
 
      } // use_interp_fixed_copy
 
      yac_interp_operator_delete(interp_fixed);
 
    } // NUM_FIXED_VALUE_CONFIGS
 
    // free collection selection
    yac_collection_selection_delete(sel);
 
  } // NUM_COLL_SEL_CONFIGS
 
  xt_finalize();
  MPI_Finalize();
 
  return TEST_EXIT_CODE;
}
 
static void utest_init_data() {
 
  // initialise source and target fields data
  for (size_t k = 0; k < MAX_COLLECTION_SIZE; ++k) {
    for (size_t l = 0; l < NUM_SRC_FIELDS; ++l) {
      for (size_t m = 0; m < NUM_SRC_POINTS; ++m) {
        src_fields_data[k][l][m] = (double)m;
      }
    }
    for (size_t l = 0; l < NUM_TGT_POINTS; ++l) {
        tgt_field_data[k][l] = (double)-1;
    }
  }
}
 
static void utest_check_fixed() {
 
  for (size_t i = 0; i < MAX_COLLECTION_SIZE; ++i) {
    for (size_t j = 0; j < NUM_TGT_POINTS; ++j) {
      if (tgt_field_data[i][j] != ref_tgt_field_data[i][j])
        PUT_ERR("wrong data");
    }
  }
}