def test_nodal_basis_1d():
for num_nodes in range(2, 10):
nodes = np.linspace(-1, 1, num=num_nodes)
nodal_basis = basis.NodalBasis1D(nodes)
utils.check_to_from_dict(nodal_basis, basis_factory)
assert nodal_basis.num_basis_cpts == num_nodes
check_matrices(nodal_basis)
check_derivative_matrix(nodal_basis)
def test_identity():
flux_function = flux_functions.Identity()
utils.check_to_from_dict(flux_function, flux_functions)
# should always give q back out
for q in range(-10, 10):
assert flux_function(q) == q
for x in range(-10, 10):
assert flux_function(q, x) == q
for t in range(-10, 10):
assert flux_function(q, x, t) == q
def test_zero():
flux_function = flux_functions.Zero()
utils.check_to_from_dict(flux_function, flux_functions)
# should always give zero
for q in range(-10, 10):
assert flux_function(q) == 0.0
for x in range(-10, 10):
assert flux_function(q, x) == 0.0
for t in range(-10, 10):
assert flux_function(q, x, t) == 0.0
def test_variable_advection():
wavespeed_function = functions.Sine(offset=2.0)
flux_function = flux_functions.VariableAdvection(wavespeed_function)
utils.check_to_from_dict(flux_function, flux_functions)
q = 1.0
x = 1.0
# shouldn't depend on t
assert flux_function(q, x, 0) == flux_function(q, x, 1.0)
# t_derivative should be zero
assert flux_function.t_derivative(q, x, 0.0) == 0.0
# q_derivative should be wavespeed_function
assert flux_function.q_derivative(q, x, 0.0) == wavespeed_function(x)
# higher q_derivatives should be zero
assert flux_function.q_derivative(q, x, 0.0, order=2) == 0.0
def test_linearized_about_q():
original_flux_function = flux_functions.Polynomial(degree=3)
q = xt_functions.AdvectingSine()
xt_function = xt_functions.LinearizedAboutQ(original_flux_function, q)
utils.check_to_from_dict(xt_function, xt_functions)
x = 0.5
t = 0.1
assert xt_function(q(x, t), x, t) is not None
assert xt_function(x, t) is not None
assert xt_function(x, t) == xt_function(q(x, t), x, t)
for x in range(10):
for t in range(10):
assert xt_function(x, t) == original_flux_function(q(x, t), x, t)
def test_exponential_function():
g = x_functions.Sine()
r = 1.0
xt_function = xt_functions.ExponentialFunction(g, r)
utils.check_to_from_dict(xt_function, xt_functions)
# should be able to call with (x, t) and (q, x, t)
q = 0.0
x = 0.5
t = 0.1
assert xt_function(x, t) is not None
assert xt_function(q, x, t) is not None
assert xt_function(q, x, t) == xt_function(x, t)
assert xt_function.q_derivative(q, x, t) is not None
assert xt_function.x_derivative(q, x, t) is not None
assert xt_function.x_derivative(x, t) is not None
assert xt_function.x_derivative(x, t) == xt_function.x_derivative(q, x, t)
assert xt_function.t_derivative(q, x, t) is not None
assert xt_function.t_derivative(x, t) is not None
assert xt_function.t_derivative(x, t) == xt_function.t_derivative(q, x, t)
def test_scalar_autonomous():
f = functions.Exponential()
flux_function = flux_functions.ScalarAutonomous(f)
utils.check_to_from_dict(flux_function, flux_functions)
q = 1.0
x = 1.5
t = 2.0
# should be able to call with just q
assert flux_function(q) is not None
# should be able to call with two inputs
assert flux_function(q, x) is not None
# should be able to call with three inputs
assert flux_function(q, x, t) is not None
# shouldn't depend on x or t
assert flux_function(q, x, t) == flux_function(q, x + 1.0, t)
assert flux_function(q, x, t) == flux_function(q, x, t + 1.0)
assert flux_function(q, x, t) == flux_function(q, x + 1.0, t + 1.0)
# x and t derivatives should be zero
assert flux_function.x_derivative(q, x, t) == 0.0
assert flux_function.t_derivative(q, x, t) == 0.0
def test_advecting_function():
xt_function = xt_functions.AdvectingSine()
utils.check_to_from_dict(xt_function, xt_functions)
# should be able to call with just x and t
x = 0.0
t = 0.0
q = 1.0
assert xt_function(x, t) is not None
# should also be able to call with (q, x, t)
assert xt_function(q, x, t) is not None
assert xt_function(q, x, t) == xt_function(x, t)
assert xt_function.q_derivative(q, x, t) is not None
assert xt_function.x_derivative(q, x, t) is not None
assert xt_function.x_derivative(x, t) is not None
assert xt_function.x_derivative(x, t) == xt_function.x_derivative(q, x, t)
assert xt_function.t_derivative(q, x, t) is not None
assert xt_function.t_derivative(x, t) is not None
assert xt_function.t_derivative(x, t) == xt_function.t_derivative(q, x, t)
# should be traveling to the right at speed 1
for x in range(-10, 10):
for t in range(-10, 10):
assert xt_function(x, t) == xt_function(x - 1, t - 1)
def check_x_function(x_function):
q = 1.0
x = 0.5
t = 0.1
# should be able to call as (q, x, t), (x, t) or (x)
assert x_function(q, x, t) is not None
assert x_function(x, t) is not None
assert x_function(x) is not None
# should give same value as long as x is same
assert x_function(q, x, t) == x_function(x)
assert x_function(x, t) == x_function(x)
# should give 0.0 q_derivative and t_derivative
assert x_function.q_derivative(q, x, t) == 0.0
assert x_function.q_derivative(x, t) == 0.0
assert x_function.q_derivative(x) == 0.0
assert x_function.t_derivative(q, x, t) == 0.0
assert x_function.t_derivative(x, t) == 0.0
assert x_function.t_derivative(x) == 0.0
# should be able to convert to dict and back again
utils.check_to_from_dict(x_function, x_functions)
def test_gauss_lobatto_nodal_basis_1d():
gl_nodal_basis = basis.GaussLobattoNodalBasis1D(1)
utils.check_to_from_dict(gl_nodal_basis, basis_factory)
assert gl_nodal_basis.num_basis_cpts == 1
assert gl_nodal_basis.nodes[0] == 0.0
check_matrices(gl_nodal_basis)
check_derivative_matrix(gl_nodal_basis)
gl_nodal_basis = basis.GaussLobattoNodalBasis1D(2)
utils.check_to_from_dict(gl_nodal_basis, basis_factory)
assert gl_nodal_basis.num_basis_cpts == 2
assert gl_nodal_basis.nodes[0] == -1.0
assert gl_nodal_basis.nodes[1] == 1.0
check_matrices(gl_nodal_basis)
check_derivative_matrix(gl_nodal_basis)
for num_basis_cpts in range(3, 10):
gl_nodal_basis = basis.GaussLobattoNodalBasis1D(num_basis_cpts)
utils.check_to_from_dict(gl_nodal_basis, basis_factory)
check_matrices(gl_nodal_basis)
check_derivative_matrix(gl_nodal_basis)
def test_modal_basis_2d_triangle():
for space_order in range(1, 6):
modal_basis_2d_triangle = basis.ModalBasis2DTriangle(space_order)
utils.check_to_from_dict(modal_basis_2d_triangle, basis_factory)
check_matrices(modal_basis_2d_triangle)
def test_legendre_basis_2d_cartesian():
for space_order in range(1, 10):
legendre_basis_2d_cartesian = basis.LegendreBasis2DCartesian(
space_order)
utils.check_to_from_dict(legendre_basis_2d_cartesian, basis_factory)
check_matrices(legendre_basis_2d_cartesian)
def test_fv_basis_1d():
fv_basis = basis.FiniteVolumeBasis1D()
utils.check_to_from_dict(fv_basis, basis_factory)
check_matrices(fv_basis)
def test_legendre_basis_1d():
for num_basis_cpts in range(1, 10):
legendre_basis = basis.LegendreBasis1D(num_basis_cpts)
utils.check_to_from_dict(legendre_basis, basis_factory)
check_matrices(legendre_basis)
def test_gauss_legendre_nodal_basis_1d():
for num_nodes in range(1, 10):
gl_nodal_basis = basis.GaussLegendreNodalBasis1D(num_nodes)
utils.check_to_from_dict(gl_nodal_basis, basis_factory)
check_matrices(gl_nodal_basis)
check_derivative_matrix(gl_nodal_basis)