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 ExtrudedMeshHierarchy(base_hierarchy,
layers,
kernel=None,
layer_height=None,
extrusion_type='uniform',
gdim=None):
"""Build a hierarchy of extruded meshes by extruded a hierarchy of meshes.
:arg base_hierarchy: the unextruded base mesh hierarchy to extrude.
See :func:`~.ExtrudedMesh` for the meaning of the remaining parameters.
"""
if not isinstance(base_hierarchy, HierarchyBase):
raise ValueError("Expecting a HierarchyBase, not a %r" %
type(base_hierarchy))
if any(m.cell_set._extruded for m in base_hierarchy):
raise ValueError("Meshes in base hierarchy must not be extruded")
meshes = [
firedrake.ExtrudedMesh(m,
layers,
kernel=kernel,
layer_height=layer_height,
extrusion_type=extrusion_type,
gdim=gdim) for m in base_hierarchy._meshes
]
return HierarchyBase(
meshes,
base_hierarchy.coarse_to_fine_cells,
base_hierarchy.fine_to_coarse_cells,
refinements_per_level=base_hierarchy.refinements_per_level,
nested=base_hierarchy.nested)
def test_hybrid_prognostic_solve():
Lx, Ly = 20e3, 20e3
h0, dh = 500.0, 100.0
T = 254.15
u_in = 100.0
model = icepack.models.HybridModel()
opts = {'dirichlet_ids': [1], 'side_wall_ids': [3, 4], 'tol': 1e-12}
Nx, Ny = 32, 32
mesh2d = firedrake.RectangleMesh(Nx, Ny, Lx, Ly)
mesh = firedrake.ExtrudedMesh(mesh2d, layers=1)
V = firedrake.VectorFunctionSpace(mesh,
dim=2,
family='CG',
degree=2,
vfamily='GL',
vdegree=1)
Q = firedrake.FunctionSpace(mesh,
family='CG',
degree=2,
vfamily='DG',
vdegree=0)
x, y, ζ = firedrake.SpatialCoordinate(mesh)
height_above_flotation = 10.0
d = -ρ_I / ρ_W * (h0 - dh) + height_above_flotation
ρ = ρ_I - ρ_W * d**2 / (h0 - dh)**2
Z = icepack.rate_factor(T) * (ρ * g * h0 / 4)**n
q = 1 - (1 - (dh / h0) * (x / Lx))**(n + 1)
ux = u_in + Z * q * Lx * (h0 / dh) / (n + 1)
u0 = interpolate(firedrake.as_vector((ux, 0)), V)
thickness = h0 - dh * x / Lx
β = 1 / 2
α = β * ρ / ρ_I * dh / Lx
h = interpolate(h0 - dh * x / Lx, Q)
h_inflow = h.copy(deepcopy=True)
ds = (1 + β) * ρ / ρ_I * dh
s = interpolate(d + h0 - dh + ds * (1 - x / Lx), Q)
b = interpolate(s - h, Q)
C = interpolate(α * (ρ_I * g * thickness) * ux**(-1 / m), Q)
A = firedrake.Constant(icepack.rate_factor(T))
final_time, dt = 1.0, 1.0 / 12
num_timesteps = int(final_time / dt)
u = model.diagnostic_solve(u0=u0, h=h, s=s, C=C, A=A, **opts)
a0 = firedrake.Constant(0)
a = interpolate((model.prognostic_solve(dt, h0=h, a=a0, u=u) - h) / dt, Q)
for k in range(num_timesteps):
h = model.prognostic_solve(dt, h0=h, a=a, u=u, h_inflow=h_inflow)
s = icepack.compute_surface(h=h, b=b)
u = model.diagnostic_solve(u0=u, h=h, s=s, C=C, A=A, **opts)
assert icepack.norm(h, norm_type='Linfty') < np.inf
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_diagnostic_solver():
Nx, Ny = 32, 32
mesh2d = firedrake.RectangleMesh(Nx, Ny, Lx, Ly)
mesh = firedrake.ExtrudedMesh(mesh2d, layers=1)
Q = firedrake.FunctionSpace(mesh,
family='CG',
degree=2,
vfamily='DG',
vdegree=0)
x, y, ζ = firedrake.SpatialCoordinate(mesh)
h = firedrake.interpolate(h0 - dh * x / Lx, Q)
s = firedrake.interpolate(d + h0 - dh + ds * (1 - x / Lx), Q)
u_expr = firedrake.as_vector(((0.95 + 0.05 * ζ) * exact_u(x), 0))
A = firedrake.Constant(icepack.rate_factor(254.15))
C = firedrake.Constant(0.001)
model = icepack.models.HybridModel()
opts = {'dirichlet_ids': [1, 3, 4], 'tol': 1e-12}
max_degree = 5
Nz = 32
xs = np.array([(Lx / 2, Ly / 2, k / Nz) for k in range(Nz + 1)])
us = np.zeros((max_degree + 1, Nz + 1))
for vdegree in range(max_degree, 0, -1):
solver = icepack.solvers.FlowSolver(model, **opts)
V = firedrake.VectorFunctionSpace(mesh,
dim=2,
family='CG',
degree=2,
vfamily='GL',
vdegree=vdegree)
u0 = firedrake.interpolate(u_expr, V)
u = solver.diagnostic_solve(velocity=u0,
thickness=h,
surface=s,
fluidity=A,
friction=C)
V0 = firedrake.VectorFunctionSpace(mesh,
dim=2,
family='CG',
degree=2,
vfamily='DG',
vdegree=0)
depth_avg_u = firedrake.project(u, V0)
shear_u = firedrake.project(u - depth_avg_u, V)
assert icepack.norm(shear_u, norm_type='Linfty') > 1e-2
us_center = np.array(u.at(xs, tolerance=1e-6))
us[vdegree, :] = np.sqrt(np.sum(us_center**2, 1))
norm = np.linalg.norm(us[max_degree, :])
error = np.linalg.norm(us[vdegree, :] - us[max_degree, :]) / norm
print(error, flush=True)
assert error < 1e-2
def test_order_0():
def h_expr(x):
return h0 - dh * x / Lx
def s_expr(x):
return d + h0 - dh + ds * (1 - x / Lx)
A = firedrake.Constant(icepack.rate_factor(254.15))
C = firedrake.Constant(0.001)
opts = {'dirichlet_ids': [1], 'side_wall_ids': [3, 4], 'tolerance': 1e-14}
Nx, Ny = 64, 64
mesh2d = firedrake.RectangleMesh(Nx, Ny, Lx, Ly)
x, y = firedrake.SpatialCoordinate(mesh2d)
Q2d = firedrake.FunctionSpace(mesh2d, family='CG', degree=2)
V2d = firedrake.VectorFunctionSpace(mesh2d, family='CG', degree=2)
h = firedrake.interpolate(h_expr(x), Q2d)
s = firedrake.interpolate(s_expr(x), Q2d)
u_expr = firedrake.as_vector((exact_u(x), 0))
u0 = firedrake.interpolate(u_expr, V2d)
model2d = icepack.models.IceStream()
solver2d = icepack.solvers.FlowSolver(model2d, **opts)
u2d = solver2d.diagnostic_solve(velocity=u0,
thickness=h,
surface=s,
fluidity=A,
friction=C)
mesh = firedrake.ExtrudedMesh(mesh2d, layers=1)
x, y, ζ = firedrake.SpatialCoordinate(mesh)
Q3d = firedrake.FunctionSpace(mesh,
family='CG',
degree=2,
vfamily='DG',
vdegree=0)
V3d = firedrake.VectorFunctionSpace(mesh,
dim=2,
family='CG',
degree=2,
vfamily='GL',
vdegree=0)
h = firedrake.interpolate(h_expr(x), Q3d)
s = firedrake.interpolate(s_expr(x), Q3d)
u_expr = firedrake.as_vector((exact_u(x), 0))
u0 = firedrake.interpolate(u_expr, V3d)
model3d = icepack.models.HybridModel()
solver3d = icepack.solvers.FlowSolver(model3d, **opts)
u3d = solver3d.diagnostic_solve(velocity=u0,
thickness=h,
surface=s,
fluidity=A,
friction=C)
U2D, U3D = u2d.dat.data_ro, u3d.dat.data_ro
assert np.linalg.norm(U3D - U2D) / np.linalg.norm(U2D) < 1e-2
def test_vertical_velocity():
Lx, Ly = 20e3, 20e3
nx, ny = 48, 48
mesh2d = firedrake.RectangleMesh(nx, ny, Lx, Ly)
mesh = firedrake.ExtrudedMesh(mesh2d, layers=1)
Q = firedrake.FunctionSpace(mesh,
family="CG",
degree=2,
vfamily="DG",
vdegree=0)
Q3D = firedrake.FunctionSpace(mesh,
family="DG",
degree=2,
vfamily="GL",
vdegree=6)
V = firedrake.VectorFunctionSpace(mesh,
dim=2,
family="CG",
degree=2,
vfamily="GL",
vdegree=5)
# note we should call the families in the vertical velocity solver.
x, y, ζ = firedrake.SpatialCoordinate(mesh)
u_inflow = 1.0
v_inflow = 2.0
mu = 0.003
mv = 0.001
b = firedrake.interpolate(firedrake.Constant(0.0), Q)
s = firedrake.interpolate(firedrake.Constant(1000.0), Q)
h = firedrake.interpolate(s - b, Q)
u = firedrake.interpolate(
firedrake.as_vector((mu * x + u_inflow, mv * y + v_inflow)), V)
m = -0.01
def analytic_vertical_velocity(h, ζ, mu, mv, m, Q3D):
return firedrake.interpolate(
firedrake.Constant(m) - (firedrake.Constant(mu + mv) * h * ζ), Q3D)
w = firedrake.interpolate(
icepack.utilities.vertical_velocity(u, h, m=m) * h, Q3D)
w_analytic = analytic_vertical_velocity(h, ζ, mu, mv, m, Q3D)
assert np.mean(np.abs(w.dat.data - w_analytic.dat.data)) < 10e-9
def extrudedmesh(base_mesh, mz, refine=-1, temporary_height=1.0):
'''Generate extruded mesh on draft reference domain. Optional refinement
hierarchy (if refine>0). Result has placeholder height of one.'''
if base_mesh.cell_dimension() not in {1, 2}:
raise ValueError('only 2D and 3D extruded meshes are generated')
if refine > 0:
hierarchy = fd.SemiCoarsenedExtrudedHierarchy(base_mesh,
temporary_height,
base_layer=mz,
nref=refine)
mesh = hierarchy[-1]
return mesh, hierarchy
else:
mesh = fd.ExtrudedMesh(base_mesh,
layers=mz,
layer_height=temporary_height / mz)
return mesh
def test_plot_extruded_field():
nx, ny = 32, 32
mesh2d = firedrake.UnitSquareMesh(nx, ny)
mesh3d = firedrake.ExtrudedMesh(mesh2d, layers=1)
x, y, z = firedrake.SpatialCoordinate(mesh3d)
Q = firedrake.FunctionSpace(mesh3d, "CG", 2, vfamily="GL", vdegree=4)
q = interpolate((x**2 - y**2) * (1 - z**4), Q)
q_contours = icepack.plot.tricontourf(q)
assert q_contours is not None
V = firedrake.VectorFunctionSpace(mesh3d,
"CG",
2,
vfamily="GL",
vdegree=4,
dim=2)
u = interpolate(as_vector((1 - z**4, 0)), V)
u_contours = icepack.plot.tricontourf(u)
assert u_contours is not None
def form_assembler(form, n, family, degree, dimension, operation):
m = f.UnitSquareMesh(n, n, quadrilateral=True)
if dimension == 3:
m = f.ExtrudedMesh(m, n)
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)
actualform = form(u, v)
if operation == "matrix":
return lambda: f.assemble(actualform).M
else:
return lambda: f.assemble(actualform)
def test_plot_extruded_field():
Nx, Ny = 32, 32
mesh2d = firedrake.UnitSquareMesh(Nx, Ny)
mesh3d = firedrake.ExtrudedMesh(mesh2d, layers=1)
x, y, z = firedrake.SpatialCoordinate(mesh3d)
Q = firedrake.FunctionSpace(mesh3d,
family='CG',
degree=2,
vfamily='GL',
vdegree=4)
q = firedrake.interpolate((x**2 - y**2) * (1 - z**4), Q)
q_contours = icepack.plot.tricontourf(q)
assert q_contours is not None
V = firedrake.VectorFunctionSpace(mesh3d,
dim=2,
family='CG',
degree=2,
vfamily='GL',
vdegree=4)
u = firedrake.interpolate(firedrake.as_vector((1 - z**4, 0)), V)
u_contours = icepack.plot.tricontourf(u)
assert u_contours is not None
#
# The full text of the license can be found in the file LICENSE in the
# icepack source directory or at <http://www.gnu.org/licenses/>.
import numpy as np
import firedrake
from firedrake import assemble, inner, as_vector, Constant, dx, ds_t, ds_b
import icepack.models
from icepack.constants import (year, thermal_diffusivity as α,
melting_temperature as Tm)
# Using the same mesh and data for every test case.
Nx, Ny = 32, 32
Lx, Ly = 20e3, 20e3
mesh2d = firedrake.RectangleMesh(Nx, Ny, Lx, Ly)
mesh = firedrake.ExtrudedMesh(mesh2d, layers=1)
Q = firedrake.FunctionSpace(mesh,
family='CG',
degree=2,
vfamily='GL',
vdegree=4)
V = firedrake.VectorFunctionSpace(mesh,
dim=2,
family='CG',
degree=2,
vfamily='GL',
vdegree=4)
W = firedrake.FunctionSpace(mesh,
family='DG',
degree=1,
def test_diagnostic_solver(dim):
Nx, Ny, Nz = 32, 32, 32
if dim == "xz":
opts = {"dirichlet_ids": [1], "tol": 1e-12}
mesh_x = firedrake.IntervalMesh(Nx, Lx)
mesh = firedrake.ExtrudedMesh(mesh_x, layers=1)
x, ζ = firedrake.SpatialCoordinate(mesh)
u_expr = (0.95 + 0.05 * ζ) * exact_u(x)
xs = np.array([(Lx / 2, k / Nz) for k in range(Nz + 1)])
elif dim == "xyz":
opts = {"dirichlet_ids": [1, 3, 4], "tol": 1e-12}
mesh_x = firedrake.RectangleMesh(Nx, Ny, Lx, Ly)
mesh = firedrake.ExtrudedMesh(mesh_x, layers=1)
x, y, ζ = firedrake.SpatialCoordinate(mesh)
u_expr = firedrake.as_vector(((0.95 + 0.05 * ζ) * exact_u(x), 0))
xs = np.array([(Lx / 2, Ly / 2, k / Nz) for k in range(Nz + 1)])
Q = firedrake.FunctionSpace(mesh, "CG", 2, vfamily="DG", vdegree=0)
h = firedrake.interpolate(h0 - dh * x / Lx, Q)
s = firedrake.interpolate(d + h0 - dh + ds * (1 - x / Lx), Q)
A = Constant(icepack.rate_factor(254.15))
C = Constant(0.001)
model = icepack.models.HybridModel()
max_degree = 5
us = np.zeros((max_degree + 1, Nz + 1))
for vdegree in range(max_degree, 0, -1):
solver = icepack.solvers.FlowSolver(model, **opts)
if dim == "xz":
V = firedrake.FunctionSpace(mesh,
"CG",
2,
vfamily="DG",
vdegree=vdegree)
V0 = firedrake.FunctionSpace(mesh,
"CG",
2,
vfamily="DG",
vdegree=0)
elif dim == "xyz":
V = firedrake.VectorFunctionSpace(mesh,
"CG",
2,
vfamily="DG",
vdegree=vdegree,
dim=2)
V0 = firedrake.VectorFunctionSpace(mesh,
"CG",
2,
vfamily="DG",
vdegree=0,
dim=2)
u0 = firedrake.interpolate(u_expr, V)
u = solver.diagnostic_solve(velocity=u0,
thickness=h,
surface=s,
fluidity=A,
friction=C)
depth_avg_u = firedrake.project(u, V0)
shear_u = firedrake.project(u - depth_avg_u, V)
assert icepack.norm(shear_u, norm_type="Linfty") > 1e-2
us_center = np.array(u.at(xs, tolerance=1e-6))
if dim == "xz":
us[vdegree, :] = us_center
elif dim == "xyz":
us[vdegree, :] = np.sqrt(np.sum(us_center**2, 1))
norm = np.linalg.norm(us[max_degree, :])
error = np.linalg.norm(us[vdegree, :] - us[max_degree, :]) / norm
print(error, flush=True)
assert error < 1e-2
def test_hybrid_prognostic_solve(solver_type):
Lx, Ly = 20e3, 20e3
h0, dh = 500.0, 100.0
T = 254.15
u_in = 100.0
model = icepack.models.HybridModel()
opts = {
'dirichlet_ids': [1],
'side_wall_ids': [3, 4],
'prognostic_solver_type': solver_type
}
Nx, Ny = 32, 32
mesh2d = firedrake.RectangleMesh(Nx, Ny, Lx, Ly)
mesh = firedrake.ExtrudedMesh(mesh2d, layers=1)
V = firedrake.VectorFunctionSpace(
mesh, 'CG', 2, vfamily='GL', vdegree=1, dim=2
)
Q = firedrake.FunctionSpace(mesh, 'CG', 2, vfamily='DG', vdegree=0)
x, y, ζ = firedrake.SpatialCoordinate(mesh)
height_above_flotation = 10.0
d = -ρ_I / ρ_W * (h0 - dh) + height_above_flotation
ρ = ρ_I - ρ_W * d**2 / (h0 - dh)**2
Z = icepack.rate_factor(T) * (ρ * g * h0 / 4)**n
q = 1 - (1 - (dh/h0) * (x/Lx))**(n + 1)
ux = u_in + Z * q * Lx * (h0/dh) / (n + 1)
u0 = interpolate(firedrake.as_vector((ux, 0)), V)
thickness = h0 - dh * x / Lx
β = 1/2
α = β * ρ / ρ_I * dh / Lx
h = interpolate(h0 - dh * x / Lx, Q)
h_inflow = h.copy(deepcopy=True)
ds = (1 + β) * ρ / ρ_I * dh
s = interpolate(d + h0 - dh + ds * (1 - x / Lx), Q)
b = interpolate(s - h, Q)
C = interpolate(α * (ρ_I * g * thickness) * ux**(-1/m), Q)
A = firedrake.Constant(icepack.rate_factor(T))
final_time, dt = 1.0, 1.0/12
num_timesteps = int(final_time / dt)
solver = icepack.solvers.FlowSolver(model, **opts)
u = solver.diagnostic_solve(
velocity=u0, thickness=h, surface=s, fluidity=A, friction=C
)
a = firedrake.Function(Q)
h_n = solver.prognostic_solve(
dt, thickness=h, velocity=u, accumulation=a, thickness_inflow=h_inflow
)
a.interpolate((h_n - h) / dt)
for k in range(num_timesteps):
h = solver.prognostic_solve(
dt,
thickness=h,
velocity=u,
accumulation=a,
thickness_inflow=h_inflow
)
s = icepack.compute_surface(thickness=h, bed=b)
u = solver.diagnostic_solve(
velocity=u,
thickness=h,
surface=s,
fluidity=A,
friction=C
)
assert icepack.norm(h, norm_type='Linfty') < np.inf
def test_order_0(dim):
def h_expr(x):
return h0 - dh * x / Lx
def s_expr(x):
return d + h0 - dh + ds * (1 - x / Lx)
A = Constant(icepack.rate_factor(254.15))
C = Constant(0.001)
Nx, Ny = 64, 64
if dim == "xz":
opts = {"dirichlet_ids": [1], "tolerance": 1e-14}
mesh_x = firedrake.IntervalMesh(Nx, Lx)
x = firedrake.SpatialCoordinate(mesh_x)[0]
elif dim == "xyz":
opts = {
"dirichlet_ids": [1],
"side_wall_ids": [3, 4],
"tolerance": 1e-14
}
mesh_x = firedrake.RectangleMesh(Nx, Ny, Lx, Ly)
x, y = firedrake.SpatialCoordinate(mesh_x)
Q_x = firedrake.FunctionSpace(mesh_x, "CG", 2)
h = firedrake.interpolate(h_expr(x), Q_x)
s = firedrake.interpolate(s_expr(x), Q_x)
if dim == "xz":
u0 = firedrake.interpolate(exact_u(x), Q_x)
elif dim == "xyz":
V_x = firedrake.VectorFunctionSpace(mesh_x, "CG", 2)
u_expr = firedrake.as_vector((exact_u(x), 0))
u0 = firedrake.interpolate(u_expr, V_x)
model_x = icepack.models.IceStream()
solver_x = icepack.solvers.FlowSolver(model_x, **opts)
u_x = solver_x.diagnostic_solve(
velocity=u0,
thickness=h,
surface=s,
fluidity=A,
friction=C,
strain_rate_min=Constant(0.0),
)
mesh = firedrake.ExtrudedMesh(mesh_x, layers=1)
if dim == "xz":
x, ζ = firedrake.SpatialCoordinate(mesh)
V_xz = firedrake.FunctionSpace(mesh, "CG", 2, vfamily="GL", vdegree=0)
u0 = firedrake.interpolate(exact_u(x), V_xz)
elif dim == "xyz":
x, y, ζ = firedrake.SpatialCoordinate(mesh)
V_xz = firedrake.VectorFunctionSpace(mesh,
"CG",
2,
vfamily="GL",
vdegree=0,
dim=2)
u_expr = firedrake.as_vector((exact_u(x), 0))
u0 = firedrake.interpolate(u_expr, V_xz)
Q_xz = firedrake.FunctionSpace(mesh, "CG", 2, vfamily="DG", vdegree=0)
h = firedrake.interpolate(h_expr(x), Q_xz)
s = firedrake.interpolate(s_expr(x), Q_xz)
model_xz = icepack.models.HybridModel()
solver_xz = icepack.solvers.FlowSolver(model_xz, **opts)
u_xz = solver_xz.diagnostic_solve(
velocity=u0,
thickness=h,
surface=s,
fluidity=A,
friction=C,
strain_rate_min=Constant(0.0),
)
U_x, U_xz = u_x.dat.data_ro, u_xz.dat.data_ro
assert np.linalg.norm(U_xz - U_x) / np.linalg.norm(U_x) < 1e-2
except PETSc.Error:
λ = np.nan
stability_constants.append(λ)
fig, axes = plt.subplots()
axes.plot(abs(np.array(stability_constants)))
fig.savefig(args.output)
elif args.dimension == 3:
kmin, kmax = args.zdegree_min, args.zdegree_max + 1
fig, axes = plt.subplots()
for k in tqdm.trange(kmin, kmax):
stability_constants = []
for N in tqdm.trange(2**args.log_dx_min, 2**args.log_dx_max + 1):
mesh2d = firedrake.UnitSquareMesh(N, N, diagonal='crossed')
mesh = firedrake.ExtrudedMesh(mesh2d, args.num_layers)
d = mesh.topological_dimension()
volume = assemble(firedrake.Constant(1) * dx(mesh))
l = firedrake.Constant(volume**(1 / d))
V = firedrake.VectorFunctionSpace(mesh,
'CG',
2,
vfamily='GLL',
vdegree=k + 1)
Q = firedrake.FunctionSpace(mesh, 'CG', 1, vfamily='GL', vdegree=k)
try:
b = lambda v, q: -q * div(v) * dx
m = lambda u, v: (inner(u, v) + l**2 * inner(grad(u), grad(v))
) * dx
n = lambda p, q: p * q * dx
Nx = int(60)
Ny = int(220)
layers = range(10)
Nz = len(layers)
Lx = Nx * Delta_x
Ly = Ny * Delta_y
Lz = Nz * Delta_z
mesh = fd.utility_meshes.RectangleMesh(nx=Nx,
ny=Ny,
Lx=Lx,
Ly=Ly,
quadrilateral=True)
mesh = fd.ExtrudedMesh(mesh, layers=Nz, layer_height=Delta_z)
# We need to decide on the function space in which we'd like to solve the
# problem. Let's use piecewise linear functions continuous between
# elements::
# Create extruded mesh element
horiz_elt = fd.FiniteElement("DG", fd.quadrilateral, 0)
vert_elt = fd.FiniteElement("DG", fd.interval, 0)
elt = fd.TensorProductElement(horiz_elt, vert_elt)
# Create function space
V = fd.FunctionSpace(mesh, elt)
Vvec = fd.VectorFunctionSpace(mesh, "DG", 0)
# We'll also need the test and trial functions corresponding to this
from firedrake import inner, sqrt
import icepack.plot
parser = argparse.ArgumentParser()
parser.add_argument('--input')
parser.add_argument('--level', type=int)
parser.add_argument('--output')
args = parser.parse_args()
Lx, Ly = 640e3, 80e3
ny = 20
nx = int(Lx / Ly) * ny
coarse_mesh = firedrake.RectangleMesh(nx, ny, Lx, Ly)
mesh_hierarchy = firedrake.MeshHierarchy(coarse_mesh, args.level)
mesh2d = mesh_hierarchy[args.level]
mesh = firedrake.ExtrudedMesh(mesh2d, 1)
Q = firedrake.FunctionSpace(mesh, 'CG', 1, vfamily='R', vdegree=0)
V = firedrake.VectorFunctionSpace(mesh,
'CG',
1,
vfamily='GL',
vdegree=2,
dim=2)
h = firedrake.Function(Q)
u = firedrake.Function(V)
input_name = os.path.splitext(args.input)[0]
with firedrake.DumbCheckpoint(input_name, mode=firedrake.FILE_READ) as chk:
timesteps, indices = chk.get_timesteps()
