def test_adaptive_rk_codegen_error():
"""Test whether Fortran code generation for the Runge-Kutta
timestepper works.
"""
component_id = 'y'
rhs_function = '<func>y'
stepper = ODE45MethodBuilder(component_id, use_high_order=False, atol=1e-6)
from dagrt.function_registry import (
base_function_registry, register_ode_rhs)
freg = register_ode_rhs(base_function_registry, component_id,
identifier=rhs_function)
freg = freg.register_codegen(rhs_function, "fortran",
f.CallCode("""
${result} = -2*${y}
"""))
code = stepper.generate()
codegen = f.CodeGenerator(
"RKMethod",
user_type_map={
component_id: f.ArrayType(
(2,),
f.BuiltinType('real (kind=8)'),
)
},
function_registry=freg)
run_fortran([
("rkmethod.f90", codegen(code)),
("test_rk_adaptive_error.f90", read_file("test_rk_adaptive_error.f90")),
])
def test_adaptive_rk_codegen():
"""Test whether Fortran code generation for the Runge-Kutta
timestepper works.
"""
component_id = "y"
rhs_function = "<func>y"
stepper = ODE45MethodBuilder(component_id, use_high_order=False, rtol=1e-6)
from dagrt.function_registry import (base_function_registry,
register_ode_rhs)
freg = register_ode_rhs(base_function_registry,
component_id,
identifier=rhs_function)
freg = freg.register_codegen(
rhs_function, "fortran",
f.CallCode("""
${result}(1) = ${y}(2)
${result}(2) = -30*((${y}(1))**2 - 1)*${y}(2) - ${y}(1)
"""))
code = stepper.generate()
codegen = f.CodeGenerator("RKMethod",
user_type_map={
"y":
f.ArrayType(
(2, ),
f.BuiltinType("real (kind=8)"),
),
},
function_registry=freg)
run_fortran([
("rkmethod.f90", codegen(code)),
("test_rk_adaptive.f90", read_file("test_rk_adaptive.f90")),
])
#skip = pytest.mark.skipif(True, reason="not fully implemented")
def read_file(rel_path):
from os.path import join, abspath, dirname
path = join(abspath(dirname(__file__)), rel_path)
with open(path, "r") as inf:
return inf.read()
# {{{ test rk methods
@pytest.mark.parametrize(("min_order", "stepper"), [
(2, ODE23MethodBuilder("y", use_high_order=False)),
(3, ODE23MethodBuilder("y", use_high_order=True)),
(4, ODE45MethodBuilder("y", use_high_order=False)),
(5, ODE45MethodBuilder("y", use_high_order=True)),
(4, RK4MethodBuilder("y")),
(4, LSRK4MethodBuilder("y")),
])
def test_rk_codegen(min_order, stepper, print_code=False):
"""Test whether Fortran code generation for the Runge-Kutta
timestepper works.
"""
component_id = 'y'
rhs_function = '<func>y'
from dagrt.function_registry import (
base_function_registry, register_ode_rhs)
freg = register_ode_rhs(base_function_registry, component_id,
MidpointMethodBuilder,
HeunsMethodBuilder,
RK3MethodBuilder,
RK4MethodBuilder,
RK5MethodBuilder,
LSRK4MethodBuilder,
SSPRK22MethodBuilder,
SSPRK33MethodBuilder,
)
from leap.rk.imex import KennedyCarpenterIMEXARK4MethodBuilder
from mirgecom.steppers import advance_state
@pytest.mark.parametrize(("method", "method_order"), [
(ODE23MethodBuilder("y", use_high_order=False), 2),
(ODE23MethodBuilder("y", use_high_order=True), 3),
(ODE45MethodBuilder("y", use_high_order=False), 4),
(ODE45MethodBuilder("y", use_high_order=True), 5),
(ForwardEulerMethodBuilder("y"), 1),
(MidpointMethodBuilder("y"), 2),
(HeunsMethodBuilder("y"), 2),
(RK3MethodBuilder("y"), 3),
(RK4MethodBuilder("y"), 4),
(RK5MethodBuilder("y"), 5),
(LSRK4MethodBuilder("y"), 4),
(KennedyCarpenterIMEXARK4MethodBuilder(
"y", use_implicit=False, explicit_rhs_name="y"), 4),
(SSPRK22MethodBuilder("y"), 2),
(SSPRK33MethodBuilder("y"), 3),
])
def test_leapgen_integration_order(method, method_order):
"""Test that time integrators have correct order."""