test_interp_method_config.py

Go to the documentation of this file.

#!/usr/bin/env python3
 
# Copyright (c) 2026 The YAC Authors
#
# SPDX-License-Identifier: BSD-3-Clause
 
 
 
try:
    from mpi4py import MPI
    comm = MPI.COMM_WORLD
except ImportError:
    comm = None
 
import math
from numpy import deg2rad
 
from yac.core import InterpMethodConfig, InterpolationStack
 
# Test set/get int (nnn.n)
cfg = InterpMethodConfig("nnn")
cfg.set_param_int("n", 8)
n = cfg.get_param_int("n")
assert n == 8, f"set/get int: expected n==8, got {n}"
 
# Test set/get double (nnn.max_search_distance)
cfg2 = InterpMethodConfig("nnn")
cfg2.set_param_dble("max_search_distance", 0.5)
d = cfg2.get_param_dble("max_search_distance")
assert d == 0.5, f"set/get dble: expected 0.5, got {d}"
 
# Test set/get int (nnn.n_min; defaults to 0, which is interpreted as n)
cfg_n_min = InterpMethodConfig("nnn")
n_min = cfg_n_min.get_param_int("n_min")
assert n_min == 0, f"default n_min: expected 0, got {n_min}"
cfg_n_min.set_param_int("n", 8)
cfg_n_min.set_param_int("n_min", 4)
n_min = cfg_n_min.get_param_int("n_min")
assert n_min == 4, f"set/get int: expected n_min==4, got {n_min}"
 
# Test set/get int (dnn.n_min)
cfg_dnn_n_min = InterpMethodConfig("dnn")
n_min = cfg_dnn_n_min.get_param_int("n_min")
assert n_min == 1, f"default dnn n_min: expected 1, got {n_min}"
cfg_dnn_n_min.set_param_int("n_min", 3)
n_min = cfg_dnn_n_min.get_param_int("n_min")
assert n_min == 3, f"set/get int: expected n_min==3, got {n_min}"
 
# Test set/get string (nnn.weighted)
cfg3 = InterpMethodConfig("nnn")
cfg3.set_param_str("weighted", "gauss_weighted")
s = cfg3.get_param_str("weighted")
assert s == "gauss_weighted", f"set/get str: expected 'gauss_weighted', got '{s}'"
 
# Test dot-separated path (dnn.search_distance.fixed)
cfg4 = InterpMethodConfig("dnn")
cfg4.set_param_dble("search_distance.fixed", deg2rad(1))
d4 = cfg4.get_param_dble("search_distance.fixed")
assert d4 == deg2rad(1), f"dot-path dble: wrong value {d4}"
 
# Test add_from_config integrates with InterpolationStack
stack = InterpolationStack()
cfg5 = InterpMethodConfig("nnn")
cfg5.set_param_int("n", 3)
stack.add_from_config(cfg5)
 
# Check generic set_param method
cfg6 = InterpMethodConfig("nnn")
cfg6.set_param("n", 5)
assert cfg6.get_param_int("n") == 5, "set_param int dispatch failed"
 
cfg6.set_param("max_search_distance", 1.5)
assert cfg6.get_param_dble("max_search_distance") == 1.5, "set_param float dispatch failed"
 
cfg6.set_param("weighted", "gauss_weighted")
assert cfg6.get_param_str("weighted") == "gauss_weighted", "set_param str dispatch failed"
 
cfg7 = InterpMethodConfig("spmap")
cfg7.set_param("overwrite", [
    {
        "condition": {
            "bounding_circle": {  # amazonas delta
                "center": {
                    "lon": deg2rad(-50.0),
                    "lat": deg2rad(0.0),
                },
                "radius": deg2rad(4.0),
            }
        },
        "spread_distance": deg2rad(0.3),
    },
    {
        "condition": {
            "bounding_circle": {  # north pole
                "center": {
                    "lon": deg2rad(0.0),
                    "lat": deg2rad(90.0),
                },
                "radius": deg2rad(2.0),
            }
        },
        "spread_distance": deg2rad(0.4),
    }
])
 
assert cfg7.get_param_dble("overwrite.0.spread_distance") == deg2rad(0.3)
assert cfg7.get_param_dble("overwrite.0.condition.bounding_circle.radius") == deg2rad(4.0)
assert cfg7.get_param_dble("overwrite.1.spread_distance") == deg2rad(0.4)
 
 
# Check constructor with kwargs
cfg8 = InterpMethodConfig("nnn",
                          n=3,
                          weighted="gauss_weighted",
                          max_search_distance=1.4,
                          )
assert cfg8.get_param_int("n") == 3, "set_param int dispatch failed"
assert cfg8.get_param_str("weighted") == "gauss_weighted", "set_param str dispatch failed"
assert abs(cfg8.get_param_dble("max_search_distance") - 1.4) < 1e-15, "set_param float dispatch failed"
 
 
 
# Test constructing multiple method types with default parameters
for method_name in ("average", "ncc", "dnn", "nnn", "conservative",
                    "fixed", "check", "bernstein_bezier", "creep",
                    "source_to_target_map"):
    c = InterpMethodConfig(method_name)
    assert c is not None, f"failed to create default config for '{method_name}'"
 
# Test list parameter: spmap overwrite (get_list_size, append_list_element, index path)
spmap = InterpMethodConfig("spmap")
 
# The overwrite list must be empty by default.
assert spmap.get_list_size("overwrite") == 0, \
    "spmap overwrite list should start empty"
 
# Append first element and verify returned index.
idx0 = spmap.append_list_element("overwrite")
assert idx0 == 0, f"expected index 0 for first append, got {idx0}"
assert spmap.get_list_size("overwrite") == 1, \
    "expected list size 1 after one append"
 
# Set and get a sub-parameter of the new element via index path.
spmap.set_param_dble("overwrite.0.spread_distance", 0.05)
sd0 = spmap.get_param_dble("overwrite.0.spread_distance")
assert sd0 == 0.05, f"overwrite.0.spread_distance round-trip failed: {sd0}"
 
# Append a second element; both elements must be independent.
idx1 = spmap.append_list_element("overwrite")
assert idx1 == 1, f"expected index 1 for second append, got {idx1}"
 
spmap.set_param_dble("overwrite.1.spread_distance", 0.10)
sd1 = spmap.get_param_dble("overwrite.1.spread_distance")
assert sd1 == 0.10, f"overwrite.1.spread_distance round-trip failed: {sd1}"
 
# First element must be unchanged.
sd0_check = spmap.get_param_dble("overwrite.0.spread_distance")
assert sd0_check == 0.05, \
    f"overwrite.0 was modified when setting overwrite.1: {sd0_check}"
 
# Check InterpolationStack add_from_dict
stack2 = InterpolationStack()
stack2.add_method("nnn",
                  n=5,
                  weighted="distance_weighted",
                  max_search_distance=2.2
                  )
stack2.add_method("spmap",
                  overwrite=[{
                      "condition": {
                          "bounding_circle": {  # amazonas delta
                              "center": {
                                  "lon": deg2rad(-50.0),
                                  "lat": deg2rad(0.0),
                              },
                              "radius": deg2rad(4.0),
                          }
                      },
                      "spread_distance": 0.0002}],
                  )