def test_sharp_cutoff():
"""Tests that the sharp cutoff function does what it should."""
k = 10.0
mesh = fd.UnitSquareMesh(10,10)
V = fd.FunctionSpace(mesh,"CG",1)
prob = hh.HelmholtzProblem(k,V,n=2.0)
prob.sharp_cutoff(np.array([0.5,0.5]),0.5)
V_DG = fd.FunctionSpace(mesh,"DG",0)
n_fn = fd.Function(V_DG)
n_fn.interpolate(prob._n)
# This is a rudimentary test that it's 1 on the boundary and 2 elsewhere
# Yes, I kind of made this pass by changing the value to check until it did.
# But I've confirmed that it's doing (roughly) the right thing visually, so I'm content
assert n_fn.dat.data_ro[97] == 1.0
assert n_fn.dat.data_ro[95] == 2.0
def __init__(self, *args, meshcell_size, **kwargs):
n = int(round(1 / meshcell_size))
kwargs["mesh"] = fe.UnitSquareMesh(n, n)
super().__init__(*args, **kwargs)
def test__verify__second_order_temporal_convergence__via_mms(
sim_constructor_kwargs={
"quadrature_degree": 4,
"element_degree": 1,
"time_stencil_size": 3
},
parameters={
"grashof_number": 2.,
"prandtl_number": 5.,
"stefan_number": 0.2,
"heat_capacity_solid_to_liquid_ratio": 0.500,
"thermal_conductivity_solid_to_liquid_ratio": 2.14 / 0.561,
"smoothing": 1. / 16.
},
meshsize=24,
timestep_sizes=(1. / 3., 1. / 9., 1. / 27.),
tolerance=0.3):
rx = sim_constructor_kwargs["element_degree"] + 1
mesh = fe.UnitSquareMesh(meshsize, meshsize)
h = mesh.cell_sizes((0., ) * mesh.geometric_dimension())
sapphire.mms.verify_temporal_order_of_accuracy(
sim_module=sim_module,
manufactured_solution=manufactured_solution,
sim_constructor_kwargs=sim_constructor_kwargs,
mesh=mesh,
parameters=parameters,
expected_order=2,
tolerance=tolerance,
timestep_sizes=timestep_sizes,
endtime=0.5)
def test_kl_like_coeff_reorder():
"""Tests the KL-like coefficient reordering works correctly."""
mesh = fd.UnitSquareMesh(10,10)
J = 2
delta = 2.0
lambda_mult = 0.1
j_scaling = 1.0
n_0 = 1.0
stochastic_points_2 = np.array([[1.0,1.0],[2.0,2.0]])
kl_like = UniformKLLikeCoeff(mesh,J,delta,lambda_mult,j_scaling,n_0,
stochastic_points_2)
kl_like.reorder([1,0],include_current_point=True)
assert (kl_like.current_and_unsampled_points() == np.array([[2.0,2.0],[1.0,1.0]])).all()
stochastic_points_3 = np.array([[1.0,1.0],[2.0,2.0],[3.0,3.0]])
kl_like = UniformKLLikeCoeff(mesh,J,delta,lambda_mult,j_scaling,n_0,
stochastic_points_3)
kl_like.reorder([1,0],include_current_point=False)
assert (kl_like.unsampled_points() == np.array([[3.0,3.0],[2.0,2.0]])).all()
def test_coeff_size():
"""Tests that the p/w/ const coeffs are the correct size."""
mesh = fd.UnitSquareMesh(100,100)
V = fd.FunctionSpace(mesh, "CG", 1)
num_pieces = 1
noise_level = 0.1
num_repeats = 100
A_pre = fd.as_matrix(np.array([[1.0,0.0],[0.0,1.0]]))
A_stoch = PiecewiseConstantCoeffGenerator(mesh,num_pieces,
noise_level,A_pre,[2,2])
n_pre = 1.0
n_stoch = PiecewiseConstantCoeffGenerator(mesh,num_pieces,
noise_level,n_pre,[1])
for ii in range(num_repeats):
A_stoch.sample()
n_stoch.sample()
fl = A_stoch._constant_array.flat
for jj in fl:
coords = hh_utils.flatiter_hack(A_stoch._constant_array,fl.coords)
assert A_stoch._constant_array[coords].evaluate(None,None,(),None).shape\
== (2,2)
assert n_stoch._constant_array[coords].evaluate(None,None,(),None).shape\
== ()
def test_kl_like_coeff_change_all_points():
"""Tests the KL-like coefficient changes points correctly (and
accesses points correctly too)."""
mesh = fd.UnitSquareMesh(10,10)
J = 10
delta = 2.0
lambda_mult = 0.1
j_scaling = 1.0
n_0 = 1.0
stochastic_points = np.random.rand(3,J) - 0.5
kl_like = UniformKLLikeCoeff(mesh,J,delta,lambda_mult,j_scaling,n_0,
stochastic_points)
new_points = np.random.rand(7,J) - 0.5
kl_like.change_all_points(new_points)
assert (kl_like.current_and_unsampled_points() == new_points).all()
def test_noise_level():
"""Tests p/w const coeffs have correct noise_level.
Only works for the case coeff_pre = 1.0."""
mesh = fd.UnitSquareMesh(100,100)
num_pieces = 12
noise_level = 0.1
num_repeats = 100
n_pre = 1.0
n_stoch = PiecewiseConstantCoeffGenerator(mesh,num_pieces,
noise_level,n_pre,[1])
V = fd.FunctionSpace(mesh, "CG", 1)
n_func = fd.Function(V)
for ii in range(num_repeats):
n_stoch.sample()
fl = n_stoch._constant_array.flat
for jj in fl:
coords = hh_utils.flatiter_hack(n_stoch._constant_array,fl.coords)
assert abs(n_stoch._constant_array[coords]\
.evaluate(None,None,(),None)) <= noise_level
n_func.interpolate(n_stoch.coeff)
assert (np.abs(n_func.dat.data_ro-n_pre) <= noise_level).all()
def test_coeff_being_updated():
"""Test that the p/w/ const random coefficients are updated."""
k = 20.0
mesh = fd.UnitSquareMesh(100,100)
V = fd.FunctionSpace(mesh, "CG", 1)
num_pieces = 12
noise_level = 0.1
num_repeats = 10
A_pre = fd.as_matrix(np.array([[1.0,0.0],[0.0,1.0]]))
A_stoch = PiecewiseConstantCoeffGenerator(mesh,num_pieces,
noise_level,A_pre,[2,2])
n_pre = 1.0
n_stoch = PiecewiseConstantCoeffGenerator(mesh,num_pieces,
noise_level,n_pre,[1])
A_copy = copy.deepcopy(A_stoch._constant_array[0,0].values())
n_copy = copy.deepcopy(n_stoch._constant_array[0,0].values())
A_stoch.sample()
n_stoch.sample()
A_diff = A_copy - A_stoch._constant_array[0,0].values()
assert all(A_copy != 0.0)
assert n_copy != n_stoch._constant_array[0,0].values()
def test__verify__third_order_spatial_convergence__via_mms(
sim_constructor_kwargs={
"quadrature_degree": 2,
"element_degree": 2,
"time_stencil_size": 4
},
parameters={
"grashof_number": 2.,
"prandtl_number": 5.,
"stefan_number": 0.2,
"heat_capacity_solid_to_liquid_ratio": 0.500,
"thermal_conductivity_solid_to_liquid_ratio": 2.14 / 0.561,
"smoothing": 1. / 16.
},
mesh_sizes=(3, 6, 12, 24),
timestep_size=1. / 64.,
tolerance=0.32):
rt = sim_constructor_kwargs["time_stencil_size"] - 1
sapphire.mms.verify_spatial_order_of_accuracy(
sim_module=sim_module,
manufactured_solution=manufactured_solution,
sim_constructor_kwargs=sim_constructor_kwargs,
meshes=[fe.UnitSquareMesh(n, n) for n in mesh_sizes],
parameters=parameters,
expected_order=3,
tolerance=tolerance,
timestep_size=timestep_size,
endtime=0.32)
def test_sharp_cutoff_ufl():
"""Tests that the sharp cutoff function does what it should when the
coefficient is given by a ufl expression."""
k = 10.0
mesh = fd.UnitSquareMesh(10,10)
V = fd.FunctionSpace(mesh,"CG",1)
x = fd.SpatialCoordinate(mesh)
n = 1.0 + fd.sin(30*x[0])
prob = hh.HelmholtzProblem(k,V,n=n)
prob.sharp_cutoff(np.array([0.5,0.5]),0.5)
V_DG = fd.FunctionSpace(mesh,"DG",0)
n_fn = fd.Function(V_DG)
n_fn.interpolate(prob._n)
# This is a rudimentary test that it's 1 on the boundary
# Yes, I kind of made this pass by changing the value to check until it did.
# But I've confirmed that it's doing (roughly) the right thing visually, so I'm content
assert n_fn.dat.data_ro[97] == 1.0
def test__steady_state_lid_driven_cavity_benchmark():
""" Verify against steady state lid-driven cavity benchmark.
Comparing to data published in
@article{ghia1982high-re,
author = {Ghia, Urmila and Ghia, K.N and Shin, C.T},
year = {1982},
month = {12},
pages = {387-411},
title = {High-Re solutions for incompressible flow using the Navier-Stokes equations and a multigrid method1},
volume = {48},
journal = {Journal of Computational Physics},
doi = {10.1016/0021-9991(82)90058-4}
}
"""
endtime = 1.e12
sim = LidDrivenCavitySimulation(reynolds_number=100.,
mesh=fe.UnitSquareMesh(50, 50),
element_degrees=(2, 1),
timestep_size=endtime)
sim.states = sim.run(endtime=endtime)
tests.validation.helpers.check_scalar_solution_component(
solution=sim.solution,
component=0,
subcomponent=0,
coordinates=[(0.5, y) for y in (0.9766, 0.1016, 0.0547, 0.0000)],
expected_values=(0.8412, -0.0643, -0.0372, 0.0000),
absolute_tolerances=(0.0025, 0.0015, 0.001, 1.e-16))
def run_L2tracking_optimization(write_output=False):
""" Test template for fsz.LevelsetFunctional."""
# tool for developing new tests, allows storing shape iterates
if write_output:
out = fd.File("domain.pvd")
def cb(*args):
out.write(Q.mesh_m.coordinates)
cb()
else:
cb = None
# setup problem
mesh = fd.UnitSquareMesh(30, 30)
Q = fs.FeControlSpace(mesh)
inner = fs.ElasticityInnerProduct(Q)
q = fs.ControlVector(Q, inner)
# setup PDE constraint
mesh_m = Q.mesh_m
e = PoissonSolver(mesh_m)
# create PDEconstrained objective functional
J_ = L2trackingObjective(e, Q, cb=cb)
J = fs.ReducedObjective(J_, e)
# ROL parameters
params_dict = {
'General': {
'Secant': {
'Type': 'Limited-Memory BFGS',
'Maximum Storage': 10
}
},
'Step': {
'Type': 'Line Search',
'Line Search': {
'Descent Method': {
'Type': 'Quasi-Newton Step'
}
},
},
'Status Test': {
'Gradient Tolerance': 1e-4,
'Step Tolerance': 1e-5,
'Iteration Limit': 15
}
}
# assemble and solve ROL optimization problem
params = ROL.ParameterList(params_dict, "Parameters")
problem = ROL.OptimizationProblem(J, q)
solver = ROL.OptimizationSolver(problem, params)
solver.solve()
# verify that the norm of the gradient at optimum is small enough
state = solver.getAlgorithmState()
assert (state.gnorm < 1e-4)
def test_coeff_definition_no_error():
"""Test that a coeff with just too few many pieces is not caught."""
k = 20.0
mesh = fd.UnitSquareMesh(100, 100)
V = fd.FunctionSpace(mesh, "CG", 1)
num_pieces = 12
noise_level = 0.1
num_repeats = 10
A_pre = fd.as_matrix(np.array([[1.0, 0.0], [0.0, 1.0]]))
A_stoch = PiecewiseConstantCoeffGenerator(mesh, num_pieces, noise_level,
A_pre, [2, 2])
n_pre = 1.0
n_stoch = PiecewiseConstantCoeffGenerator(mesh, num_pieces, noise_level,
n_pre, [1])
f = 1.0
g = 1.0
GMRES_its = nbex.nearby_preconditioning_experiment(V, k, A_pre, A_stoch,
n_pre, n_stoch, f, g,
num_repeats)
# The code should not error.
assert GMRES_its.shape != (0, )
def test_plot_field():
mesh = firedrake.UnitSquareMesh(32, 32)
Q = firedrake.FunctionSpace(mesh, "CG", 1)
x, y = firedrake.SpatialCoordinate(mesh)
u = interpolate(x * y, Q)
fig, axes = icepack.plot.subplots(nrows=2,
ncols=2,
sharex=True,
sharey=True)
filled_contours = icepack.plot.tricontourf(u, axes=axes[0, 0])
assert filled_contours is not None
colorbar = plt.colorbar(filled_contours, ax=axes[0, 0])
assert colorbar is not None
contours = icepack.plot.tricontour(u, axes=axes[0, 1])
assert contours is not None
colors_flat = icepack.plot.tripcolor(u, shading="flat", axes=axes[1, 0])
assert colors_flat is not None
colors_gouraud = icepack.plot.tripcolor(u,
shading="gouraud",
axes=axes[1, 1])
assert colors_flat.get_array().shape != colors_gouraud.get_array().shape
def __init__(self, *args,
mesh_dimensions = (20, 20),
hotwall_temperature = 0.5,
coldwall_temperature = -0.5,
reynolds_number = 1.,
rayleigh_number = 1.e6,
prandtl_number = 0.71,
**kwargs):
if "solution" not in kwargs:
kwargs["mesh"] = fe.UnitSquareMesh(*mesh_dimensions)
self.hotwall_id = 1
self.coldwall_id = 2
self.hotwall_temperature = fe.Constant(hotwall_temperature)
self.coldwall_temperature = fe.Constant(coldwall_temperature)
super().__init__(
*args,
reynolds_number = reynolds_number,
rayleigh_number = rayleigh_number,
prandtl_number = prandtl_number,
**kwargs)
def test_coeff_definition_error():
"""Test that a coeff with too many pieces is caught."""
k = 20.0
mesh = fd.UnitSquareMesh(100, 100)
V = fd.FunctionSpace(mesh, "CG", 1)
num_pieces = 13
noise_level = 0.1
num_repeats = 10
A_pre = fd.as_matrix(np.array([[1.0, 0.0], [0.0, 1.0]]))
A_stoch = PiecewiseConstantCoeffGenerator(mesh, num_pieces, noise_level,
A_pre, [2, 2])
n_pre = 1.0
n_stoch = PiecewiseConstantCoeffGenerator(mesh, num_pieces, noise_level,
n_pre, [1])
f = 1.0
g = 1.0
GMRES_its = nbex.nearby_preconditioning_experiment(V, k, A_pre, A_stoch,
n_pre, n_stoch, f, g,
num_repeats)
# The code should catch the error and print a warning message, and
# exit, not recording any GMRES iterations.
assert GMRES_its.shape == (0, )
def __init__(self,
*args,
mesh_dimensions=(24, 24),
hotwall_temperature=1.,
initial_temperature=-0.01,
reynolds_number=1.,
rayleigh_number=3.27e5,
prandtl_number=56.2,
stefan_number=0.045,
liquidus_temperature=0.,
**kwargs):
if "solution" not in kwargs:
kwargs["mesh"] = fe.UnitSquareMesh(*mesh_dimensions)
self.hotwall_temperature = fe.Constant(hotwall_temperature)
self.initial_temperature = fe.Constant(initial_temperature)
super().__init__(*args,
liquidus_temperature=liquidus_temperature,
reynolds_number=reynolds_number,
rayleigh_number=rayleigh_number,
prandtl_number=prandtl_number,
stefan_number=stefan_number,
**kwargs)
def test_scalar_field():
Nx, Ny = 16, 16
mesh2d = firedrake.UnitSquareMesh(Nx, Ny)
mesh3d = firedrake.ExtrudedMesh(mesh2d, layers=1)
x, y, z = firedrake.SpatialCoordinate(mesh3d)
Q3D = firedrake.FunctionSpace(mesh3d,
family='CG',
degree=2,
vfamily='GL',
vdegree=5)
q3d = firedrake.interpolate((x**2 + y**2) * (1 - z**4), Q3D)
q_avg = depth_average(q3d)
p3d = firedrake.interpolate(x**2 + y**2, Q3D)
p_avg = depth_average(p3d, weight=1 - z**4)
Q2D = firedrake.FunctionSpace(mesh2d, family='CG', degree=2)
x, y = firedrake.SpatialCoordinate(mesh2d)
q2d = firedrake.interpolate(4 * (x**2 + y**2) / 5, Q2D)
assert q_avg.ufl_domain() is mesh2d
assert norm(q_avg - q2d) / norm(q2d) < 1 / (Nx * Ny)**2
assert norm(p_avg - q2d) / norm(q2d) < 1 / (Nx * Ny)**2
Q0 = firedrake.FunctionSpace(mesh3d,
family='CG',
degree=2,
vfamily='GL',
vdegree=0)
q_lift = lift3d(q_avg, Q0)
assert norm(depth_average(q_lift) - q2d) / norm(q2d) < 1 / (Nx * Ny)**2
def test_n_min_ufl():
"""Tests that the sharp cutoff function does what it should when n is given by a ufl expression."""
k = 10.0
mesh = fd.UnitSquareMesh(10,10)
V = fd.FunctionSpace(mesh,"CG",1)
x = fd.SpatialCoordinate(mesh)
n = 1.0 + fd.sin(30*x[0])
prob = hh.HelmholtzProblem(k,V,n=n)
n_min_val = 2.0
prob.n_min(n_min_val)
V_DG = fd.FunctionSpace(mesh,"DG",0)
n_fn = fd.Function(V_DG)
n_fn.interpolate(prob._n)
assert (n_fn.dat.data_ro >= n_min_val).all()
def test_n_min_pre_ufl():
"""Tests that the sharp cutoff function does what it should when n_pre is given by a UFL expression."""
k = 10.0
mesh = fd.UnitSquareMesh(10,10)
V = fd.FunctionSpace(mesh,"CG",1)
x = fd.SpatialCoordinate(mesh)
n_pre = 1.0 + fd.sin(30*x[0])
prob = hh.HelmholtzProblem(k,V,n_pre=n_pre,A_pre = fd.as_matrix([[1.0,0.0],[0.0,1.0]]))
n_min_val = 2.0
prob.n_min(n_min_val,True)
V_DG = fd.FunctionSpace(mesh,"DG",0)
n_fn = fd.Function(V_DG)
n_fn.interpolate(prob._n_pre)
assert (n_fn.dat.data_ro >= n_min_val).all()
def __init__(self, *args, meshsize, **kwargs):
self.hot_wall_temperature = fe.Constant(1.)
self.cold_wall_temperature = fe.Constant(-0.01)
self.topwall_heatflux = fe.Constant(0.)
super().__init__(
*args,
mesh=fe.UnitSquareMesh(meshsize, meshsize),
initial_values=initial_values,
dirichlet_boundary_conditions=dirichlet_boundary_conditions,
**kwargs)
q = self.topwall_heatflux
_, _, psi_T = fe.TestFunctions(self.function_space)
ds = fe.ds(domain=self.mesh, subdomain_id=4)
self.variational_form_residual += psi_T * q * ds
Ra = 3.27e5
Pr = 56.2
self.grashof_number = self.grashof_number.assign(Ra / Pr)
self.prandtl_number = self.prandtl_number.assign(Pr)
self.stefan_number = self.stefan_number.assign(0.045)
self.liquidus_temperature = self.liquidus_temperature.assign(0.)
def test_sharp_cutoff_pre_ufl():
"""Tests that the sharp cutoff function does what it should when the
preconditioning coefficient is given by ufl."""
k = 10.0
mesh = fd.UnitSquareMesh(10,10)
V = fd.FunctionSpace(mesh,"CG",1)
x = fd.SpatialCoordinate(mesh)
n_pre = 1.0 + fd.sin(30*x[0])
prob = hh.HelmholtzProblem(k,V,n_pre=n_pre,A_pre = fd.as_matrix([[1.0,0.0],[0.0,1.0]]))
prob.sharp_cutoff(np.array([0.5,0.5]),0.5,True)
V_DG = fd.FunctionSpace(mesh,"DG",0)
n_fn = fd.Function(V_DG)
n_fn.interpolate(prob._n_pre)
# As above
assert n_fn.dat.data_ro[97] == 1.0
def test_interpolating_function():
nx, ny = 32, 32
mesh = firedrake.UnitSquareMesh(nx, ny)
x = firedrake.SpatialCoordinate(mesh)
Q = firedrake.FunctionSpace(mesh, "CG", 2)
q = icepack.interpolate(x[0] ** 2 - x[1] ** 2, Q)
assert abs(firedrake.assemble(q * dx)) < 1e-6
def test_vector_field():
Nx, Ny = 16, 16
mesh2d = firedrake.UnitSquareMesh(Nx, Ny)
mesh3d = firedrake.ExtrudedMesh(mesh2d, layers=1)
x, y, z = firedrake.SpatialCoordinate(mesh3d)
V3D = firedrake.VectorFunctionSpace(mesh3d,
"CG",
2,
vfamily="GL",
vdegree=5,
dim=2)
u3d = firedrake.interpolate(firedrake.as_vector((1 - z**4, 0)), V3D)
u_avg = depth_average(u3d)
V2D = firedrake.VectorFunctionSpace(mesh2d, "CG", 2)
x, y = firedrake.SpatialCoordinate(mesh2d)
u2d = firedrake.interpolate(firedrake.as_vector((4 / 5, 0)), V2D)
assert norm(u_avg - u2d) / norm(u2d) < 1 / (Nx * Ny)**2
V0 = firedrake.VectorFunctionSpace(mesh3d,
"CG",
2,
vfamily="GL",
vdegree=0,
dim=2)
u_lift = lift3d(u_avg, V0)
assert norm(depth_average(u_lift) - u2d) / norm(u2d) < 1 / (Nx * Ny)**2
def create_form(form_string, family, degree, dimension, operation):
from firedrake import dx, inner, grad
import firedrake as f
f.parameters['coffee']['optlevel'] = 'O3'
f.parameters['pyop2_options']['opt_level'] = 'O3'
f.parameters['pyop2_options']['simd_isa'] = 'avx'
f.parameters["pyop2_options"]["lazy_evaluation"] = False
m = f.UnitSquareMesh(2, 2, quadrilateral=True)
if dimension == 3:
m = f.ExtrudedMesh(m, 2)
fs = f.FunctionSpace(m, family, degree)
v = f.TestFunction(fs)
if operation == "matrix":
u = f.TrialFunction(fs)
elif operation == "action":
u = f.Function(fs)
else:
raise ValueError("Unknown operation: %s" % operation)
if form_string == "u * v * dx":
return u * v * dx
elif form_string == "inner(grad(u), grad(v)) * dx":
return inner(grad(u), grad(v)) * dx
def test_checkpointing(controlspace_t):
mesh = fd.UnitSquareMesh(5, 5)
if controlspace_t == fs.BsplineControlSpace:
bbox = [(-1, 2), (-1, 2)]
orders = [2, 2]
levels = [4, 4]
Q = fs.BsplineControlSpace(mesh, bbox, orders, levels)
elif controlspace_t == fs.FeMultiGridControlSpace:
Q = fs.FeMultiGridControlSpace(mesh, refinements=1, order=2)
else:
Q = controlspace_t(mesh)
inner = fs.H1InnerProduct(Q)
q = fs.ControlVector(Q, inner)
p = fs.ControlVector(Q, inner)
from firedrake.petsc import PETSc
rand = PETSc.Random().create(mesh.comm)
rand.setInterval((1, 2))
q.vec_wo().setRandom(rand)
Q.store(q)
Q.load(p)
assert q.norm() > 0
assert abs(q.norm()-p.norm()) < 1e-14
p.axpy(-1, q)
assert p.norm() < 1e-14
def test_ilu():
"""Tests that ILU functionality gives correct solution."""
k = 10.0
num_cells = utils.h_to_num_cells(k**-1.5,2)
mesh = fd.UnitSquareMesh(num_cells,num_cells)
V = fd.FunctionSpace(mesh,"CG",1)
prob = hh.HelmholtzProblem(k,V)
angle = 2.0 * np.pi/7.0
d = [np.cos(angle),np.sin(angle)]
prob.f_g_plane_wave(d)
for fill_in in range(40):
prob.use_ilu_gmres(fill_in)
prob.solve()
x = fd.SpatialCoordinate(mesh)
# This error was found out by eye
assert np.abs(fd.norms.errornorm(fd.exp(1j * k * fd.dot(fd.as_vector(d),x)),uh=prob.u_h,norm_type='H1')) < 0.5
def make_domain(nx, ny, xmin, ymin, width, height):
mesh = firedrake.UnitSquareMesh(nx, ny, diagonal="crossed")
x, y = firedrake.SpatialCoordinate(mesh)
Vc = mesh.coordinates.function_space()
expr = firedrake.as_vector((width * x + xmin, height * y + ymin))
f = firedrake.interpolate(expr, Vc)
mesh.coordinates.assign(f)
return mesh
def test_plot_field():
mesh = firedrake.UnitSquareMesh(32, 32)
Q = firedrake.FunctionSpace(mesh, 'CG', 1)
x, y = firedrake.SpatialCoordinate(mesh)
u = firedrake.interpolate(x * y, Q)
contours = icepack.plot.tricontourf(u)
assert contours is not None
colorbar = plt.colorbar(contours)
assert colorbar is not None
def test_StochasticHelmholtzProblem_sample():
"""Test that sample routine works correctly."""
class DeterministicCoeff(object):
"""Generates 'random' coefficients in a known way.
Coefficients are of the type required in
StochasticHelmholtzProblem, but matrix-valued coefficients take
the values [[1.0,0.0],[0.0,1.0/n]] and scalar-valued
coefficients take the value 1.0 = 1.0/n, where n >= 1 is the
number of times the coefficient has been sampled.
"""
def __init__(self,type):
"""Initialises testing class."""
self._counter = 1
self._changes = fd.Constant(1.0)
self._type = type
if type == "matrix":
self.coeff = fd.as_matrix([[1.0,0.0],[0.0,1.0/self._changes]])
if type == "scalar":
self.coeff = 1 + 1.0/self._changes
def sample(self):
"""Update coefficient."""
self._counter += 1
self._changes.assign(float(self._counter))
A_test = DeterministicCoeff("matrix")
n_test = DeterministicCoeff("scalar")
k = 20.0
mesh = fd.UnitSquareMesh(100,100)
V = fd.FunctionSpace(mesh, "CG", 1)
prob = hh.StochasticHelmholtzProblem(k,V,A_test,n_test)
num_samples = 999
for ii in range(num_samples):
prob.sample()
# The following test isn't perfect, but it shows that the `sample'
# method for StochasticHelmholtzProblem is calling the `sample'
# method of the coefficients correctly. (It doesn't show if the
# embedding in the form is correct.)
assert n_test._changes.values() == float(num_samples + 1)
assert A_test._changes.values() == float(num_samples + 1)
