simple_c_plugin.c

Go to the documentation of this file.

/*
  Example plugin for the ICON Community Interface (ComIn)
  with basic (not MPI-parallel) callbacks and accessing variables and
  descriptive data structures.
 
  Note that in order to demonstrate ComIn's language interoperability,
  a similary plugin has been implemented in FORTRAN, see the subdirectory
  "simple".
 
  @authors 11/2023 :: ICON Community Interface  <comin@icon-model.org>
 
  SPDX-License-Identifier: BSD-3-Clause
 
  Please see the file LICENSE in the root of the source tree for this code.
  Where software is supplied by third parties, it is indicated in the
  headers of the routines.
*/
 
#include <comin.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
static int compare_keys(const void *a, const void *b) {
  return strcmp(*(const char **)a, *(const char **)b);
}
 
static int compare_descrs(const void *a, const void *b) {
  const t_comin_var_descriptor *const da = a;
  const t_comin_var_descriptor *const db = b;
 
  int d = strcmp(da->name, db->name);
  if (d != 0)
    return d;
 
  return da->id - db->id;
}
 
// points to the pointer to the buffer (buffer swapping)
void *pres, *simple_c_var, *simple_c_tracer;
 
void simple_c_constructor() {
  unsigned int major, minor, patch;
  comin_setup_get_version(&major, &minor, &patch);
  comin_print_info_f("ComIn v%u.%u.%u simple_c_constructor called!", major,
                     minor, patch);
 
  // Print out known variables. The variable descriptors are read into a list
  // and sorted in order to be independent of the underlying container's
  // iteration order.
  size_t num_descrs = 0, size_descrs = 8;
  t_comin_var_descriptor *descrs = malloc(size_descrs * sizeof(*descrs));
  for (void *it = comin_var_get_descr_list_head(); it != NULL;
       it       = comin_var_get_descr_list_next(it)) {
    if (num_descrs == size_descrs) {
      size_descrs *= 2;
      descrs = realloc(descrs, size_descrs * sizeof(*descrs));
    }
 
    comin_var_get_descr_list_var_desc(it, &descrs[num_descrs++]);
  }
 
  qsort(descrs, num_descrs, sizeof(*descrs), compare_descrs);
 
  for (size_t i = 0; i < num_descrs; ++i) {
    comin_print_info_f("found variable: %s on domain id %d", descrs[i].name,
                       descrs[i].id);
  }
  free(descrs);
 
  // test explicit free'ing of a var descriptor list iterator:
  {
    t_comin_var_descr_list_iterator *descr_it = comin_var_get_descr_list_head();
    descr_it = comin_var_get_descr_list_next(descr_it);
    comin_var_descr_list_iterator_delete(&descr_it);
  }
 
  t_comin_var_descriptor pres_d     = {.name = "pres", .id = 1};
  t_comin_entry_point before_output = EP_ATM_WRITE_OUTPUT_BEFORE;
  pres = comin_var_get(1, &before_output, pres_d, COMIN_FLAG_READ);
  if (pres == NULL) {
    comin_plugin_finish("simple_c_plugin", "Internal error!");
  }
 
  t_comin_var_descriptor var_d = {.name = "simple_c_var", .id = 1};
  simple_c_var = comin_var_get(1, &before_output, var_d, COMIN_FLAG_WRITE);
  if (simple_c_var == NULL) {
    comin_plugin_finish("simple_c_plugin", "Internal error!");
  }
 
  t_comin_var_descriptor tracer_d = {.name = "simple_c_tracer", .id = 1};
  simple_c_tracer =
      comin_var_get(1, &before_output, tracer_d, COMIN_FLAG_WRITE);
  if (simple_c_tracer == NULL) {
    comin_plugin_finish("simple_c_plugin", "Internal error!");
  }
 
  comin_print_info("Metadata:");
 
  // Sort keys to be independent of the underlying container's iteration order.
  const char *metadata_keys[32] = {};
  size_t n_keys                 = 0;
 
  t_comin_metadata_iterator *end_it = comin_metadata_get_iterator_end(pres_d);
  t_comin_metadata_iterator *it     = comin_metadata_get_iterator_begin(pres_d);
  for (; !comin_metadata_iterator_compare(it, end_it);
       comin_metadata_iterator_next(it)) {
    if (n_keys >= sizeof(metadata_keys) / sizeof(metadata_keys[0])) {
      comin_plugin_finish("simple_c_plugin",
                          "Too many metadata items. "
                          "Increase key array size and recompile.");
    }
 
    metadata_keys[n_keys++] = comin_metadata_iterator_get_key(it);
  }
  comin_metadata_iterator_delete(it);
  comin_metadata_iterator_delete(end_it);
 
  qsort(metadata_keys, n_keys, sizeof(metadata_keys[0]), compare_keys);
 
  // iterator over the metadata:
  for (size_t i = 0; i < n_keys; ++i) {
    const char *const key = metadata_keys[i];
    // query the data type of a metadata value (important
    // because there are, for example, integer, decimal, or logical metadata).
    int type              = comin_metadata_get_typeid(pres_d, key);
    comin_print_info_f("%s type:%i", key, type);
    if (type == COMIN_METADATA_TYPEID_INT) {
      int val = comin_metadata_get_int(pres_d, key);
      comin_print_info_f(" value: %i", val);
    }
  }
 
  // test "dim_semantics" auxiliary function, used for
  // interpretation of array dimensions:
  int dim_semantics[5];
  comin_var_get_dim_semantics(pres, dim_semantics);
  if (dim_semantics[0] != COMIN_DIM_SEMANTICS_NPROMA) {
    comin_plugin_finish("simple_c_plugin", "Internal error!");
  }
  if (dim_semantics[1] != COMIN_DIM_SEMANTICS_LEVEL) {
    comin_plugin_finish("simple_c_plugin", "Internal error!");
  }
  if (dim_semantics[2] != COMIN_DIM_SEMANTICS_BLOCK) {
    comin_plugin_finish("simple_c_plugin", "Internal error!");
  }
}
 
void simple_c_diagfct() {
  comin_print_info("simple_c_diagfct called!");
 
  comin_print_info_f("currently on domain %i", comin_current_get_domain_id());
 
  if (comin_current_get_domain_id() != COMIN_DOMAIN_OUTSIDE_LOOP) {
    comin_plugin_finish(
        "simple_c_plugin",
        "simple_c_diagfct called unexpectedly inside domain loop.");
  }
 
  const int jg = 1; // Do diagnostic for domain 1.
 
  const int start_prog_cells = comin_descrdata_get_global_grf_bdywidth_c() + 1;
  const int end_prog_cells   = comin_descrdata_get_global_min_rlcell_int();
 
  int start_block_f, end_block_f;
  comin_descrdata_get_cell_block_limits(jg, start_prog_cells, end_prog_cells,
                                        &start_block_f, &end_block_f);
 
  int pres_shape[5];
  comin_var_get_shape(pres, pres_shape);
 
  const int nproma =
      pres_shape[0]; // Equal to comin_descrdata_get_global_nproma()
  const int nlev =
      pres_shape[1]; // Equal to comin_descrdata_get_domain_nlev(jg)
 
  // Convenience cast to 3d array (actually pointer to array of 2d arrays).
  typedef double(*double_3d)[nlev][nproma];
  double_3d simple_c_var_data =
      (double_3d)comin_var_get_ptr_double(simple_c_var);
  double_3d pres_data = (double_3d)comin_var_get_ptr_double(pres);
 
  for (int blk = start_block_f - 1; blk <= end_block_f - 1; ++blk) {
    int start_cell_f, end_cell_f;
    comin_descrdata_get_cell_indices(jg, blk + 1, start_block_f, end_block_f,
                                     &start_cell_f, &end_cell_f,
                                     start_prog_cells, end_prog_cells);
 
    for (int lev = 0; lev < nlev; ++lev) {
      for (int i = start_cell_f - 1; i <= end_cell_f - 1; ++i) {
        simple_c_var_data[blk][lev][i] = pres_data[blk][lev][i] + 42.;
      }
    }
  }
 
  int tracer_shape[5];
  comin_var_get_shape(simple_c_tracer, tracer_shape);
 
  // Both tracers and pres are full-level 3d variables. They must have the same
  // dimensions.
  if (0 != memcmp(tracer_shape, pres_shape, sizeof(pres_shape))) {
    comin_plugin_finish("simple_c_plugin",
                        "simple_c_tracer and pres must have same shape.");
  }
 
  double_3d simple_c_tracer_data =
      (double_3d)comin_var_get_ptr_double(simple_c_tracer);
 
  for (int blk = start_block_f - 1; blk <= end_block_f - 1; ++blk) {
    int start_cell_f, end_cell_f;
    comin_descrdata_get_cell_indices(jg, blk + 1, start_block_f, end_block_f,
                                     &start_cell_f, &end_cell_f,
                                     start_prog_cells, end_prog_cells);
 
    for (int lev = 0; lev < nlev; ++lev) {
      for (int i = start_cell_f - 1; i <= end_cell_f - 1; ++i) {
        simple_c_tracer_data[blk][lev][i] = 1337. / (lev + 1);
      }
    }
  }
}
 
void simple_c_destructor() { comin_print_info("simple_c_destructor called!"); }
 
void comin_main() {
  const char *plugin_name = comin_current_get_plugin_name();
 
  int plugin_id = comin_current_get_plugin_id();
  comin_print_info_f("plugin %s has id %d", plugin_name, plugin_id);
  t_comin_var_descriptor simple_var_d = {.name = "simple_c_var", .id = 1};
  comin_var_request_add(simple_var_d, true);
 
  comin_metadata_set_integer(simple_var_d, "zaxis_id", COMIN_ZAXIS_3D);
  comin_metadata_set_logical(simple_var_d, "restart", false);
  comin_metadata_set_logical(simple_var_d, "tracer", false);
  comin_metadata_set_integer(simple_var_d, "tracer_vlimit", 0);
  comin_metadata_set_integer(simple_var_d, "tracer_hlimit", 0);
 
  t_comin_var_descriptor simple_tracer_d = {.name = "simple_c_tracer",
                                            .id   = -1};
  comin_var_request_add(simple_tracer_d, false);
  comin_metadata_set_integer(simple_tracer_d, "zaxis_id", COMIN_ZAXIS_3D);
  comin_metadata_set_logical(simple_tracer_d, "restart", false);
  comin_metadata_set_logical(simple_tracer_d, "tracer", true);
  comin_metadata_set_integer(simple_tracer_d, "tracer_vlimit", 0);
  comin_metadata_set_integer(simple_tracer_d, "tracer_hlimit", 0);
 
  comin_callback_register(EP_SECONDARY_CONSTRUCTOR, &simple_c_constructor);
  comin_callback_register(EP_ATM_WRITE_OUTPUT_BEFORE, &simple_c_diagfct);
  comin_callback_register(EP_DESTRUCTOR, &simple_c_destructor);
 
  const char *ep_name = comin_callback_get_ep_name(EP_DESTRUCTOR);
  if (strncmp(ep_name, "EP_DESTRUCTOR", (size_t)13)) {
    comin_plugin_finish_f("simple_c: comin_main",
                          "Expected EP_DESTRUCTOR; got |%s|", ep_name);
  }
  // TODO: Access descriptive data structures
 
  /* access to comin descriptive global data (exemplary)*/
  int n_dom = comin_descrdata_get_global_n_dom();
  comin_print_info_f("n_dom: %d", n_dom);
  int max_dom = comin_descrdata_get_global_max_dom();
  comin_print_info_f("max_dom: %d", max_dom);
  int nproma = comin_descrdata_get_global_nproma();
  comin_print_info_f("nproma: %d", nproma);
  int min_rlcell_int = comin_descrdata_get_global_min_rlcell_int();
  comin_print_info_f("min_rlcell_int: %d", min_rlcell_int);
}