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()