C Examples | CMOR 3

These examples are based on the CMOR repository’s examples/c directory. They use the same shared CMIP7 user input file as the Python and Fortran examples and load CMIP7 tables from a local clone of WCRP-CMIP/cmip7-cmor-tables.

Create and activate a Conda or Mamba environment with CMOR and a C compiler:

mamba create -n cmor-c -c conda-forge cmor c-compiler libnetcdf udunits2 json-c libuuid
mamba activate cmor-c

If you use Conda instead of Mamba, use the same package list:

conda create -n cmor-c -c conda-forge cmor c-compiler libnetcdf udunits2 json-c libuuid
conda activate cmor-c

Install the CMIP7 tables in the working directory where you will run the examples:

git clone https://github.com/WCRP-CMIP/cmip7-cmor-tables.git

Run the examples from a working directory that contains the cmip7-cmor-tables repository using the run_examples.sh script:

chmod a+x run_examples.sh
./run_examples.sh

The examples expect tables under ./cmip7-cmor-tables/tables in the directory where you run the script. To use a different table location, set CMOR_TABLES_PATH to the directory containing the CMIP7 table JSON files. To use a different user input file, set CMOR_INPUT_PATH.

Each example builds the CMIP7 compound variable name and uses it to read CMIP7_cell_measures.json and CMIP7_long_name_overrides.json before writing data. The fixed-field example overrides frequency from the shared user input file to fx.

CMOR Input Files

Click to expand shared JSON input

{
  "_AXIS_ENTRY_FILE": "CMIP7_coordinate.json",
  "_FORMULA_VAR_FILE": "CMIP7_formula_terms.json",
  "_cmip7_option": 1,
  "_controlled_vocabulary_file": "../tables-cvs/cmor-cvs.json",
  "activity_id": "CMIP",
  "archive_id": "WCRP",
  "calendar": "360_day",
  "experiment_id": "amip",
  "forcing_index": "f1",
  "frequency": "mon",
  "grid_label": "g999",
  "host_collection": "CMIP7",
  "initialization_index": "i1",
  "institution_id": "MOHC",
  "license_id": "CC-BY-4.0",
  "nominal_resolution": "100 km",
  "outpath": "output",
  "physics_index": "p1",
  "realization_index": "r1",
  "region": "glb",
  "source_id": "ACCESS-ESM1-6"
}

Common C Utilities

Click to expand common C header

#ifndef CMIP7_C_COMMON_H
#define CMIP7_C_COMMON_H

#include "cmor.h"
#include <stddef.h>

#define CMIP7_NLON 4
#define CMIP7_NLAT 3
#define CMIP7_NTIMES 2
#define CMIP7_MISSING_VALUE 1.0e20f
#define CMIP7_PATH_MAX 4096

void cmip7_get_example_args(int argc, char **argv, const char **tables_path,
                            const char **input_path, const char **output_dir);
void cmip7_load_shared_user_input(const char *input_path,
                                  const char *output_dir,
                                  const char *frequency,
                                  const char *realization_index,
                                  const char *forcing_index);
void cmip7_get_cell_measures(const char *tables_path, const char *realm,
                             const char *table_entry, const char *frequency,
                             const char *region, char *value,
                             size_t value_size);
int cmip7_get_long_name_override(const char *tables_path, const char *realm,
                                 const char *table_entry, const char *frequency,
                                 const char *region, char *value,
                                 size_t value_size);

#endif

Click to expand common C code

#include "cmip7_c_common.h"

#include <json-c/json.h>
#include <string.h>

static void copy_string(char *out, size_t out_size, const char *value) {
  if (out_size > 0) {
    snprintf(out, out_size, "%s", value);
  }
}

static void join_path(char *out, size_t out_size, const char *left,
                      const char *right) {
  size_t left_len = strlen(left);

  if (left_len > 0 && left[left_len - 1] == '/') {
    snprintf(out, out_size, "%s%s", left, right);
  } else {
    snprintf(out, out_size, "%s/%s", left, right);
  }
}

static void compound_name(char *out, size_t out_size, const char *realm,
                          const char *table_entry, const char *frequency,
                          const char *region) {
  char normalized[CMOR_MAX_STRING];
  size_t i;

  copy_string(normalized, sizeof(normalized), table_entry);
  for (i = 0; normalized[i] != '\0'; ++i) {
    if (normalized[i] == '_') {
      normalized[i] = '.';
    }
  }
  snprintf(out, out_size, "%s.%s.%s.%s", realm, normalized, frequency, region);
}

static void check_status(const char *call_name, int status) {
  if (status != 0) {
    fprintf(stderr, "%s failed with status %d\n", call_name, status);
    exit(1);
  }
}

void cmip7_get_example_args(int argc, char **argv, const char **tables_path,
                            const char **input_path, const char **output_dir) {
  *tables_path = argc > 1 && argv[1][0] != '\0' ? argv[1]
                                                 : "./cmip7-cmor-tables/tables";
  *input_path = argc > 2 && argv[2][0] != '\0' ? argv[2]
                                               : "./CMIP7_input_example.json";
  *output_dir = argc > 3 && argv[3][0] != '\0' ? argv[3] : "output";
}

void cmip7_load_shared_user_input(const char *input_path,
                                  const char *output_dir,
                                  const char *frequency,
                                  const char *realization_index,
                                  const char *forcing_index) {
  check_status("cmor_dataset_json", cmor_dataset_json((char *)input_path));
  check_status("cmor_set_cur_dataset_attribute(outpath)",
               cmor_set_cur_dataset_attribute("outpath", (char *)output_dir,
                                              1));
  if (frequency != NULL) {
    check_status("cmor_set_cur_dataset_attribute(frequency)",
                 cmor_set_cur_dataset_attribute("frequency", (char *)frequency,
                                                1));
  }
  if (realization_index != NULL) {
    check_status("cmor_set_cur_dataset_attribute(realization_index)",
                 cmor_set_cur_dataset_attribute(
                     "realization_index", (char *)realization_index, 1));
  }
  if (forcing_index != NULL) {
    check_status("cmor_set_cur_dataset_attribute(forcing_index)",
                 cmor_set_cur_dataset_attribute(
                     "forcing_index", (char *)forcing_index, 1));
  }
}

static int lookup_json_string(const char *path, const char *root_name,
                              const char *key, char *value, size_t value_size) {
  json_object *document = json_object_from_file(path);
  json_object *root = NULL;
  json_object *entry = NULL;

  value[0] = '\0';
  if (document == NULL) {
    fprintf(stderr, "Could not open CMIP7 metadata table %s\n", path);
    exit(1);
  }

  if (json_object_object_get_ex(document, root_name, &root) &&
      json_object_object_get_ex(root, key, &entry)) {
    copy_string(value, value_size, json_object_get_string(entry));
    json_object_put(document);
    return 1;
  }

  json_object_put(document);
  return 0;
}

void cmip7_get_cell_measures(const char *tables_path, const char *realm,
                             const char *table_entry, const char *frequency,
                             const char *region, char *value,
                             size_t value_size) {
  char key[CMOR_MAX_STRING];
  char path[CMIP7_PATH_MAX];

  compound_name(key, sizeof(key), realm, table_entry, frequency, region);
  join_path(path, sizeof(path), tables_path, "CMIP7_cell_measures.json");
  lookup_json_string(path, "cell_measures", key, value, value_size);
}

int cmip7_get_long_name_override(const char *tables_path, const char *realm,
                                 const char *table_entry, const char *frequency,
                                 const char *region, char *value,
                                 size_t value_size) {
  char key[CMOR_MAX_STRING];
  char path[CMIP7_PATH_MAX];

  compound_name(key, sizeof(key), realm, table_entry, frequency, region);
  join_path(path, sizeof(path), tables_path, "CMIP7_long_name_overrides.json");
  return lookup_json_string(path, "long_name_overrides", key, value,
                            value_size);
}

Click to expand runner script

#!/usr/bin/env bash
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
RUN_DIR="${RUN_DIR:-$PWD}"
TABLES_PATH="${CMOR_TABLES_PATH:-$RUN_DIR/cmip7-cmor-tables/tables}"
INPUT_PATH="${CMOR_INPUT_PATH:-$RUN_DIR/CMIP7_input_example.json}"
OUTPUT_ROOT="$SCRIPT_DIR/output"
BUILD_DIR="${BUILD_DIR:-$SCRIPT_DIR/build}"

cd "$SCRIPT_DIR"

if [[ -z "${CONDA_PREFIX:-}" ]]; then
  echo "Activate your conda environment or run: conda run -n <env-name> $0" >&2
  exit 2
fi

detect_c_compiler() {
  if [[ -n "${CC:-}" ]]; then
    command -v "$CC" >/dev/null 2>&1 || {
      echo "CC is set to '$CC', but that compiler was not found" >&2
      exit 2
    }
    echo "$CC"
    return
  fi

  local compiler
  for compiler in "$CONDA_PREFIX"/bin/*-cc "$CONDA_PREFIX"/bin/*-gcc "$CONDA_PREFIX"/bin/clang "$CONDA_PREFIX"/bin/gcc "$CONDA_PREFIX"/bin/cc; do
    if [[ -x "$compiler" ]]; then
      echo "$compiler"
      return
    fi
  done

  if command -v cc >/dev/null 2>&1; then
    command -v cc
    return
  fi

  echo "Could not find a C compiler. Install c-compiler in the active conda environment or set CC." >&2
  exit 2
}

mkdir -p "$BUILD_DIR" "$OUTPUT_ROOT"

if [[ ! -d "$TABLES_PATH" ]]; then
  echo "Could not find CMIP7 tables under $TABLES_PATH. Clone cmip7-cmor-tables or set CMOR_TABLES_PATH." >&2
  exit 2
fi

if [[ ! -f "$INPUT_PATH" ]]; then
  echo "Could not find CMIP7 user input JSON at $INPUT_PATH. Set CMOR_INPUT_PATH to override it." >&2
  exit 2
fi

CC="$(detect_c_compiler)"
CMOR_PREFIX="${CMOR_PREFIX:-$CONDA_PREFIX}"
CMOR_INCLUDE_DIR="${CMOR_INCLUDE_DIR:-$CMOR_PREFIX/include}"
CMOR_CDTIME_INCLUDE_DIR="${CMOR_CDTIME_INCLUDE_DIR:-$CMOR_INCLUDE_DIR/cdTime}"

if [[ -n "${CMOR_LIB:-}" ]]; then
  CMOR_LINK_FLAGS=("$CMOR_LIB")
elif [[ -f "$CMOR_PREFIX/lib/libcmor.a" ]]; then
  CMOR_LINK_FLAGS=("$CMOR_PREFIX/lib/libcmor.a")
elif [[ -f "$CMOR_PREFIX/lib/libcmor.dylib" || -f "$CMOR_PREFIX/lib/libcmor.so" ]]; then
  CMOR_LINK_FLAGS=("-L$CMOR_PREFIX/lib" "-lcmor")
else
  echo "Could not find CMOR in $CMOR_PREFIX. Install cmor in the active conda environment or set CMOR_PREFIX/CMOR_LIB." >&2
  exit 2
fi

if [[ ! -f "$CMOR_INCLUDE_DIR/cmor.h" ]]; then
  echo "Could not find cmor.h in $CMOR_INCLUDE_DIR. Install cmor in the active conda environment or set CMOR_INCLUDE_DIR." >&2
  exit 2
fi
if [[ ! -f "$CMOR_INCLUDE_DIR/cdmsint.h" && ! -f "$CMOR_CDTIME_INCLUDE_DIR/cdmsint.h" ]]; then
  echo "Could not find cdmsint.h in $CMOR_INCLUDE_DIR or $CMOR_CDTIME_INCLUDE_DIR. Install cmor in the active conda environment or set CMOR_CDTIME_INCLUDE_DIR." >&2
  exit 2
fi

CFLAGS_DEFAULT="-g -O2 -Wall -Wextra"
CFLAGS="${CFLAGS:-$CFLAGS_DEFAULT}"
EXTRA_LDFLAGS="${EXTRA_LDFLAGS:-}"
LINK_DIRS=("$CMOR_PREFIX/lib")
if [[ "$CONDA_PREFIX/lib" != "$CMOR_PREFIX/lib" ]]; then
  LINK_DIRS+=("$CONDA_PREFIX/lib")
fi

LINK_FLAGS=("${CMOR_LINK_FLAGS[@]}")
for link_dir in "${LINK_DIRS[@]}"; do
  LINK_FLAGS+=("-L$link_dir")
done
LINK_FLAGS+=("-lnetcdf" "-ludunits2" "-ljson-c" "-luuid" "-lm")
for link_dir in "${LINK_DIRS[@]}"; do
  LINK_FLAGS+=("-Wl,-rpath,$link_dir")
done

INCLUDES=("-I$SCRIPT_DIR" "-I$CMOR_INCLUDE_DIR" "-I$CMOR_CDTIME_INCLUDE_DIR" "-I$CONDA_PREFIX/include")
COMMON_SRC="$SCRIPT_DIR/cmip7_c_common.c"

examples=(
  example_01_regular_grid_tos
  example_02_pressure_levels
  example_03_scalar_height_tas
  example_04_basin_axis
  example_05_hybrid_sigma_levels
  example_06_curvilinear_grid
  example_07_fixed_field_rootd
)

for example in "${examples[@]}"; do
  src="$SCRIPT_DIR/$example.c"
  exe="$BUILD_DIR/$example"

  echo "Compiling $example"
  "$CC" $CFLAGS "${INCLUDES[@]}" "$COMMON_SRC" "$src" "${LINK_FLAGS[@]}" $EXTRA_LDFLAGS -o "$exe"

  echo "Running $example"
  "$exe" "$TABLES_PATH" "$INPUT_PATH" "$OUTPUT_ROOT"
done

echo "Wrote CMIP7 example output under $OUTPUT_ROOT"