def assemble_vector(form: ufl.form.Form,
constraint: MultiPointConstraint,
b: _PETSc.Vec = None) -> _PETSc.Vec:
"""
Assemble a linear form into vector b with corresponding multi point constraint
Parameters
----------
form
The linear form
constraint
The multi point constraint
b
PETSc vector to assemble into (optional)
Returns
-------
PETSc.Vec
The assembled linear form
"""
if b is None:
b = _cpp.la.petsc.create_vector(
constraint.function_space.dofmap.index_map,
constraint.function_space.dofmap.index_map_bs)
t = Timer("~MPC: Assemble vector (C++)")
with b.localForm() as b_local:
b_local.set(0.0)
dolfinx_mpc.cpp.mpc.assemble_vector(b_local, form,
constraint._cpp_object)
t.stop()
return b
def apply_lifting(b: _PETSc.Vec,
form: List[_fem.FormMetaClass],
bcs: List[List[_fem.DirichletBCMetaClass]],
constraint: MultiPointConstraint,
x0: List[_PETSc.Vec] = [],
scale: float = 1.0):
"""
Apply lifting to vector b, i.e.
.. math::
b <- b - scale * K^T (A_j (g_j - x0_j))
Parameters
----------
b
PETSc vector to assemble into
form
The linear form
bcs
List of Dirichlet boundary conditions
constraint
The multi point constraint
x0
List of vectors
scale
Scaling for lifting
Returns
-------
PETSc.Vec
The assembled linear form
"""
t = Timer("~MPC: Apply lifting (C++)")
with contextlib.ExitStack() as stack:
x0 = [stack.enter_context(x.localForm()) for x in x0]
x0_r = [x.array_r for x in x0]
b_local = stack.enter_context(b.localForm())
dolfinx_mpc.cpp.mpc.apply_lifting(b_local.array_w, form, bcs, x0_r,
scale, constraint._cpp_object)
t.stop()
def test_slave_on_same_cell(master_point, degree, celltype,
get_assemblers): # noqa: F811
assemble_matrix, _ = get_assemblers
# Create mesh and function space
mesh = create_unit_square(MPI.COMM_WORLD, 1, 8, celltype)
V = fem.FunctionSpace(mesh, ("Lagrange", degree))
# Build master slave map
s_m_c = {
np.array([1, 0], dtype=np.float64).tobytes(): {
np.array([0, 1], dtype=np.float64).tobytes(): 0.43,
np.array([1, 1], dtype=np.float64).tobytes(): 0.11
},
np.array([0, 0], dtype=np.float64).tobytes(): {
np.array(master_point, dtype=np.float64).tobytes(): 0.69
}
}
with Timer("~TEST: MPC INIT"):
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c)
mpc.finalize()
# Test against generated code and general assembler
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
a = ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx
bilinear_form = fem.form(a)
with Timer("~TEST: Assemble matrix"):
A_mpc = assemble_matrix(bilinear_form, mpc)
with Timer("~TEST: Compare with numpy"):
# Create globally reduced system
A_org = fem.petsc.assemble_matrix(bilinear_form)
A_org.assemble()
dolfinx_mpc.utils.compare_mpc_lhs(A_org, A_mpc, mpc)
list_timings(mesh.comm, [TimingType.wall])
def test_mpc_assembly(master_point, degree, celltype,
get_assemblers): # noqa: F811
assemble_matrix, _ = get_assemblers
# Create mesh and function space
mesh = create_unit_square(MPI.COMM_WORLD, 5, 3, celltype)
V = fem.FunctionSpace(mesh, ("Lagrange", degree))
# Test against generated code and general assembler
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
a = ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx
bilinear_form = fem.form(a)
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {
l2b([1, 0]): {
l2b([0, 1]): 0.43,
l2b([1, 1]): 0.11
},
l2b([0, 0]): {
l2b(master_point): 0.69
}
}
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c)
mpc.finalize()
with Timer("~TEST: Assemble matrix"):
A_mpc = assemble_matrix(bilinear_form, mpc)
with Timer("~TEST: Compare with numpy"):
# Create globally reduced system
A_org = fem.petsc.assemble_matrix(bilinear_form)
A_org.assemble()
dolfinx_mpc.utils.compare_mpc_lhs(A_org, A_mpc, mpc)
def test_mpc_assembly(master_point, degree, celltype,
get_assemblers): # noqa: F811
_, assemble_vector = get_assemblers
# Create mesh and function space
mesh = create_unit_square(MPI.COMM_WORLD, 3, 5, celltype)
V = fem.FunctionSpace(mesh, ("Lagrange", degree))
# Generate reference vector
v = ufl.TestFunction(V)
x = ufl.SpatialCoordinate(mesh)
f = ufl.sin(2 * ufl.pi * x[0]) * ufl.sin(ufl.pi * x[1])
rhs = ufl.inner(f, v) * ufl.dx
linear_form = fem.form(rhs)
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {
l2b([1, 0]): {
l2b([0, 1]): 0.43,
l2b([1, 1]): 0.11
},
l2b([0, 0]): {
l2b(master_point): 0.69
}
}
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c)
mpc.finalize()
b = assemble_vector(linear_form, mpc)
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
# Reduce system with global matrix K after assembly
L_org = fem.petsc.assemble_vector(linear_form)
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
root = 0
comm = mesh.comm
with Timer("~TEST: Compare"):
dolfinx_mpc.utils.compare_mpc_rhs(L_org, b, mpc, root=root)
list_timings(comm, [TimingType.wall])
def test_lifting(get_assemblers): # noqa: F811
"""
Test MPC lifting operation on a single cell
"""
assemble_matrix, assemble_vector = get_assemblers
# Create mesh and function space
mesh = create_unit_square(MPI.COMM_WORLD, 1, 1, CellType.quadrilateral)
V = fem.FunctionSpace(mesh, ("Lagrange", 1))
# Solve Problem without MPC for reference
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
x = ufl.SpatialCoordinate(mesh)
f = x[1] * ufl.sin(2 * ufl.pi * x[0])
a = ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx
rhs = ufl.inner(f, v) * ufl.dx
bilinear_form = fem.form(a)
linear_form = fem.form(rhs)
# Create Dirichlet boundary condition
u_bc = fem.Function(V)
with u_bc.vector.localForm() as u_local:
u_local.set(2.3)
def dirichletboundary(x):
return np.isclose(x[0], 1)
mesh.topology.create_connectivity(2, 1)
geometrical_dofs = fem.locate_dofs_geometrical(V, dirichletboundary)
bc = fem.dirichletbc(u_bc, geometrical_dofs)
bcs = [bc]
# Generate reference matrices
A_org = fem.petsc.assemble_matrix(bilinear_form, bcs=bcs)
A_org.assemble()
L_org = fem.petsc.assemble_vector(linear_form)
fem.petsc.apply_lifting(L_org, [bilinear_form], [bcs])
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
fem.petsc.set_bc(L_org, bcs)
# Create multipoint constraint
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {l2b([0, 0]): {l2b([0, 1]): 1}}
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c)
mpc.finalize()
A = assemble_matrix(bilinear_form, mpc, bcs=bcs)
b = assemble_vector(linear_form, mpc)
dolfinx_mpc.apply_lifting(b, [bilinear_form], [bcs], mpc)
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
fem.petsc.set_bc(b, bcs)
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setType(PETSc.KSP.Type.PREONLY)
solver.getPC().setType(PETSc.PC.Type.LU)
solver.setOperators(A)
# Solve
uh = b.copy()
uh.set(0)
solver.solve(b, uh)
uh.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
mpc.backsubstitution(uh)
V_mpc = mpc.function_space
u_out = fem.Function(V_mpc)
u_out.vector.array[:] = uh.array
root = 0
comm = mesh.comm
with Timer("~TEST: Compare"):
dolfinx_mpc.utils.compare_mpc_lhs(A_org, A, mpc, root=root)
dolfinx_mpc.utils.compare_mpc_rhs(L_org, b, mpc, root=root)
# Gather LHS, RHS and solution on one process
A_csr = dolfinx_mpc.utils.gather_PETScMatrix(A_org, root=root)
K = dolfinx_mpc.utils.gather_transformation_matrix(mpc, root=root)
L_np = dolfinx_mpc.utils.gather_PETScVector(L_org, root=root)
u_mpc = dolfinx_mpc.utils.gather_PETScVector(uh, root=root)
# constants = dolfinx_mpc.utils.gather_contants(mpc, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ (L_np) # - constants)
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vecto
uh_numpy = K @ (d) # + constants)
assert np.allclose(uh_numpy, u_mpc)
list_timings(comm, [TimingType.wall])
# ----------------------Defining boundary conditions----------------------
# Inlet velocity Dirichlet BC
inlet_velocity = fem.Function(V)
inlet_velocity.interpolate(inlet_velocity_expression)
inlet_velocity.x.scatter_forward()
W0 = W.sub(0)
dofs = fem.locate_dofs_topological((W0, V), 1, mt.find(3))
bc1 = fem.dirichletbc(inlet_velocity, dofs, W0)
# Collect Dirichlet boundary conditions
bcs = [bc1]
# Slip conditions for walls
n = dolfinx_mpc.utils.create_normal_approximation(V, mt, 1)
with Timer("~Stokes: Create slip constraint"):
mpc = MultiPointConstraint(W)
mpc.create_slip_constraint(W.sub(0), (mt, 1), n, bcs=bcs)
mpc.finalize()
def tangential_proj(u: Expr, n: Expr):
"""
See for instance:
https://link.springer.com/content/pdf/10.1023/A:1022235512626.pdf
"""
return (Identity(u.ufl_shape[0]) - outer(n, n)) * u
def sym_grad(u: Expr):
return sym(grad(u))
def bench_elasticity_edge(tetra: bool = True, r_lvl: int = 0, out_hdf5=None, xdmf: bool = False,
boomeramg: bool = False, kspview: bool = False, degree: int = 1, info: bool = False):
N = 3
for i in range(r_lvl):
N *= 2
ct = CellType.tetrahedron if tetra else CellType.hexahedron
mesh = create_unit_cube(MPI.COMM_WORLD, N, N, N, ct)
# Get number of unknowns on each edge
V = VectorFunctionSpace(mesh, ("Lagrange", int(degree)))
# Generate Dirichlet BC (Fixed)
u_bc = Function(V)
with u_bc.vector.localForm() as u_local:
u_local.set(0.0)
def boundaries(x):
return np.isclose(x[0], np.finfo(float).eps)
fdim = mesh.topology.dim - 1
facets = locate_entities_boundary(mesh, fdim, boundaries)
topological_dofs = locate_dofs_topological(V, fdim, facets)
bc = dirichletbc(u_bc, topological_dofs)
bcs = [bc]
def PeriodicBoundary(x):
return np.logical_and(np.isclose(x[0], 1), np.isclose(x[2], 0))
def periodic_relation(x):
out_x = np.zeros(x.shape)
out_x[0] = x[0]
out_x[1] = x[1]
out_x[2] = x[2] + 1
return out_x
with Timer("~Elasticity: Initialize MPC"):
edim = mesh.topology.dim - 2
edges = locate_entities_boundary(mesh, edim, PeriodicBoundary)
arg_sort = np.argsort(edges)
periodic_mt = meshtags(mesh, edim, edges[arg_sort], np.full(len(edges), 2, dtype=np.int32))
mpc = MultiPointConstraint(V)
mpc.create_periodic_constraint_topological(V, periodic_mt, 2, periodic_relation, bcs, scale=0.5)
mpc.finalize()
# Create traction meshtag
def traction_boundary(x):
return np.isclose(x[0], 1)
t_facets = locate_entities_boundary(mesh, fdim, traction_boundary)
facet_values = np.ones(len(t_facets), dtype=np.int32)
arg_sort = np.argsort(t_facets)
mt = meshtags(mesh, fdim, t_facets[arg_sort], facet_values)
# Elasticity parameters
E = PETSc.ScalarType(1.0e4)
nu = 0.1
mu = Constant(mesh, E / (2.0 * (1.0 + nu)))
lmbda = Constant(mesh, E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu)))
g = Constant(mesh, PETSc.ScalarType((0, 0, -1e2)))
x = SpatialCoordinate(mesh)
f = Constant(mesh, PETSc.ScalarType(1e3)) * as_vector((0, -(x[2] - 0.5)**2, (x[1] - 0.5)**2))
# Stress computation
def epsilon(v):
return sym(grad(v))
def sigma(v):
return (2.0 * mu * epsilon(v) + lmbda * tr(epsilon(v)) * Identity(len(v)))
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
a = inner(sigma(u), grad(v)) * dx
rhs = inner(g, v) * ds(domain=mesh, subdomain_data=mt, subdomain_id=1) + inner(f, v) * dx
# Setup MPC system
if info:
log_info(f"Run {r_lvl}: Assembling matrix and vector")
bilinear_form = form(a)
linear_form = form(rhs)
with Timer("~Elasticity: Assemble LHS and RHS"):
A = assemble_matrix(bilinear_form, mpc, bcs=bcs)
b = assemble_vector(linear_form, mpc)
# Create nullspace for elasticity problem and assign to matrix
null_space = rigid_motions_nullspace(mpc.function_space)
A.setNearNullSpace(null_space)
# Apply boundary conditions
apply_lifting(b, [bilinear_form], [bcs], mpc)
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES, mode=PETSc.ScatterMode.REVERSE)
set_bc(b, bcs)
opts = PETSc.Options()
if boomeramg:
opts["ksp_type"] = "cg"
opts["ksp_rtol"] = 1.0e-5
opts["pc_type"] = "hypre"
opts['pc_hypre_type'] = 'boomeramg'
opts["pc_hypre_boomeramg_max_iter"] = 1
opts["pc_hypre_boomeramg_cycle_type"] = "v"
# opts["pc_hypre_boomeramg_print_statistics"] = 1
else:
opts["ksp_rtol"] = 1.0e-8
opts["pc_type"] = "gamg"
opts["pc_gamg_type"] = "agg"
opts["pc_gamg_coarse_eq_limit"] = 1000
opts["pc_gamg_sym_graph"] = True
opts["mg_levels_ksp_type"] = "chebyshev"
opts["mg_levels_pc_type"] = "jacobi"
opts["mg_levels_esteig_ksp_type"] = "cg"
opts["matptap_via"] = "scalable"
opts["pc_gamg_square_graph"] = 2
opts["pc_gamg_threshold"] = 0.02
# opts["help"] = None # List all available options
# opts["ksp_view"] = None # List progress of solver
# Setup PETSc solver
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setFromOptions()
if info:
log_info(f"Run {r_lvl}: Solving")
with Timer("~Elasticity: Solve problem") as timer:
solver.setOperators(A)
uh = b.copy()
uh.set(0)
solver.solve(b, uh)
uh.ghostUpdate(addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD)
mpc.backsubstitution(uh)
solver_time = timer.elapsed()
if kspview:
solver.view()
mem = sum(MPI.COMM_WORLD.allgather(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss))
it = solver.getIterationNumber()
num_dofs = V.dofmap.index_map.size_global * V.dofmap.index_map_bs
if out_hdf5 is not None:
d_set = out_hdf5.get("its")
d_set[r_lvl] = it
d_set = out_hdf5.get("num_dofs")
d_set[r_lvl] = num_dofs
d_set = out_hdf5.get("num_slaves")
d_set[r_lvl, MPI.COMM_WORLD.rank] = mpc.num_local_slaves
d_set = out_hdf5.get("solve_time")
d_set[r_lvl, MPI.COMM_WORLD.rank] = solver_time[0]
if info:
log_info(f"Lvl: {r_lvl}, Its: {it}, max Mem: {mem}, dim(V): {num_dofs}")
if xdmf:
# Write solution to file
u_h = Function(mpc.function_space)
u_h.vector.setArray(uh.array)
u_h.name = "u_mpc"
fname = f"results/bench_elasticity_edge_{r_lvl}.xdmf"
with XDMFFile(MPI.COMM_WORLD, fname, "w") as outfile:
outfile.write_mesh(mesh)
outfile.write_function(u_h)
def demo_stacked_cubes(outfile: XDMFFile,
theta: float,
gmsh: bool = True,
quad: bool = False,
compare: bool = False,
res: float = 0.1):
log_info(
f"Run theta:{theta:.2f}, Quad: {quad}, Gmsh {gmsh}, Res {res:.2e}")
celltype = "quadrilateral" if quad else "triangle"
if gmsh:
mesh, mt = gmsh_2D_stacked(celltype, theta)
mesh.name = f"mesh_{celltype}_{theta:.2f}_gmsh"
else:
mesh_name = "mesh"
filename = f"meshes/mesh_{celltype}_{theta:.2f}.xdmf"
mesh_2D_dolfin(celltype, theta)
with XDMFFile(MPI.COMM_WORLD, filename, "r") as xdmf:
mesh = xdmf.read_mesh(name=mesh_name)
mesh.name = f"mesh_{celltype}_{theta:.2f}"
tdim = mesh.topology.dim
fdim = tdim - 1
mesh.topology.create_connectivity(tdim, tdim)
mesh.topology.create_connectivity(fdim, tdim)
mt = xdmf.read_meshtags(mesh, name="facet_tags")
# Helper until meshtags can be read in from xdmf
V = VectorFunctionSpace(mesh, ("Lagrange", 1))
r_matrix = rotation_matrix([0, 0, 1], theta)
g_vec = np.dot(r_matrix, [0, -1.25e2, 0])
g = Constant(mesh, PETSc.ScalarType(g_vec[:2]))
def bottom_corner(x):
return np.isclose(x, [[0], [0], [0]]).all(axis=0)
# Fix bottom corner
bc_value = np.array((0, ) * mesh.geometry.dim, dtype=PETSc.ScalarType)
bottom_dofs = locate_dofs_geometrical(V, bottom_corner)
bc_bottom = dirichletbc(bc_value, bottom_dofs, V)
bcs = [bc_bottom]
# Elasticity parameters
E = PETSc.ScalarType(1.0e3)
nu = 0
mu = Constant(mesh, E / (2.0 * (1.0 + nu)))
lmbda = Constant(mesh, E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu)))
# Stress computation
def sigma(v):
return (2.0 * mu * sym(grad(v)) +
lmbda * tr(sym(grad(v))) * Identity(len(v)))
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
a = inner(sigma(u), grad(v)) * dx
ds = Measure("ds", domain=mesh, subdomain_data=mt, subdomain_id=3)
rhs = inner(Constant(mesh, PETSc.ScalarType(
(0, 0))), v) * dx + inner(g, v) * ds
def left_corner(x):
return np.isclose(x.T, np.dot(r_matrix, [0, 2, 0])).all(axis=1)
# Create multi point constraint
mpc = MultiPointConstraint(V)
with Timer("~Contact: Create contact constraint"):
nh = create_normal_approximation(V, mt, 4)
mpc.create_contact_slip_condition(mt, 4, 9, nh)
with Timer("~Contact: Add non-slip condition at bottom interface"):
bottom_normal = facet_normal_approximation(V, mt, 5)
mpc.create_slip_constraint(V, (mt, 5), bottom_normal, bcs=bcs)
with Timer("~Contact: Add tangential constraint at one point"):
vertex = locate_entities_boundary(mesh, 0, left_corner)
tangent = facet_normal_approximation(V, mt, 3, tangent=True)
mtv = meshtags(mesh, 0, vertex, np.full(len(vertex), 6,
dtype=np.int32))
mpc.create_slip_constraint(V, (mtv, 6), tangent, bcs=bcs)
mpc.finalize()
rtol = 1e-9
petsc_options = {
"ksp_rtol": 1e-9,
"pc_type": "gamg",
"pc_gamg_type": "agg",
"pc_gamg_square_graph": 2,
"pc_gamg_threshold": 0.02,
"pc_gamg_coarse_eq_limit": 1000,
"pc_gamg_sym_graph": True,
"mg_levels_ksp_type": "chebyshev",
"mg_levels_pc_type": "jacobi",
"mg_levels_esteig_ksp_type": "cg"
# , "help": None, "ksp_view": None
}
# Solve Linear problem
problem = LinearProblem(a, rhs, mpc, bcs=bcs, petsc_options=petsc_options)
# Build near nullspace
null_space = rigid_motions_nullspace(mpc.function_space)
problem.A.setNearNullSpace(null_space)
u_h = problem.solve()
it = problem.solver.getIterationNumber()
if MPI.COMM_WORLD.rank == 0:
print("Number of iterations: {0:d}".format(it))
unorm = u_h.vector.norm()
if MPI.COMM_WORLD.rank == 0:
print(f"Norm of u: {unorm}")
# Write solution to file
ext = "_gmsh" if gmsh else ""
u_h.name = "u_mpc_{0:s}_{1:.2f}{2:s}".format(celltype, theta, ext)
outfile.write_mesh(mesh)
outfile.write_function(u_h, 0.0,
f"Xdmf/Domain/Grid[@Name='{mesh.name}'][1]")
# Solve the MPC problem using a global transformation matrix
# and numpy solvers to get reference values
if not compare:
return
log_info("Solving reference problem with global matrix (using numpy)")
with Timer("~MPC: Reference problem"):
# Generate reference matrices and unconstrained solution
A_org = assemble_matrix(form(a), bcs)
A_org.assemble()
L_org = assemble_vector(form(rhs))
apply_lifting(L_org, [form(a)], [bcs])
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
set_bc(L_org, bcs)
root = 0
with Timer("~MPC: Verification"):
compare_mpc_lhs(A_org, problem.A, mpc, root=root)
compare_mpc_rhs(L_org, problem.b, mpc, root=root)
# Gather LHS, RHS and solution on one process
A_csr = gather_PETScMatrix(A_org, root=root)
K = gather_transformation_matrix(mpc, root=root)
L_np = gather_PETScVector(L_org, root=root)
u_mpc = gather_PETScVector(u_h.vector, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc, rtol=rtol)
def demo_stacked_cubes(theta, ct, noslip, num_refinements, N0, timings=False):
celltype = "hexahedron" if ct == CellType.hexahedron else "tetrahedron"
type_ext = "no_slip" if noslip else "slip"
log_info(f"Run theta: {theta:.2f}, Cell: {celltype:s}, Noslip: {noslip:b}")
# Read in mesh
mesh_3D_dolfin(theta=theta,
ct=ct,
ext=celltype,
num_refinements=num_refinements,
N0=N0)
comm.barrier()
with XDMFFile(comm, f"meshes/mesh_{celltype}_{theta:.2f}.xdmf",
"r") as xdmf:
mesh = xdmf.read_mesh(name="mesh")
tdim = mesh.topology.dim
fdim = tdim - 1
mesh.topology.create_connectivity(tdim, tdim)
mesh.topology.create_connectivity(fdim, tdim)
mt = xdmf.read_meshtags(mesh, "facet_tags")
mesh.name = f"mesh_{celltype}_{theta:.2f}{type_ext:s}"
# Create functionspaces
V = VectorFunctionSpace(mesh, ("Lagrange", 1))
# Define boundary conditions
# Bottom boundary is fixed in all directions
u_bc = Function(V)
with u_bc.vector.localForm() as u_local:
u_local.set(0.0)
bottom_dofs = locate_dofs_topological(V, fdim, mt.find(5))
bc_bottom = dirichletbc(u_bc, bottom_dofs)
g_vec = [0, 0, -4.25e-1]
if not noslip:
# Helper for orienting traction
r_matrix = rotation_matrix([1 / np.sqrt(2), 1 / np.sqrt(2), 0], -theta)
# Top boundary has a given deformation normal to the interface
g_vec = np.dot(r_matrix, [0, 0, -4.25e-1])
def top_v(x):
values = np.empty((3, x.shape[1]))
values[0] = g_vec[0]
values[1] = g_vec[1]
values[2] = g_vec[2]
return values
u_top = Function(V)
u_top.interpolate(top_v)
u_top.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT_VALUES,
mode=PETSc.ScatterMode.FORWARD)
top_dofs = locate_dofs_topological(V, fdim, mt.find(3))
bc_top = dirichletbc(u_top, top_dofs)
bcs = [bc_bottom, bc_top]
# Elasticity parameters
E = PETSc.ScalarType(1.0e3)
nu = 0
mu = Constant(mesh, E / (2.0 * (1.0 + nu)))
lmbda = Constant(mesh, E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu)))
# Stress computation
def sigma(v):
return (2.0 * mu * sym(grad(v)) +
lmbda * tr(sym(grad(v))) * Identity(len(v)))
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
a = inner(sigma(u), grad(v)) * dx
rhs = inner(Constant(mesh, PETSc.ScalarType((0, 0, 0))), v) * dx
log_info("Create constraints")
mpc = MultiPointConstraint(V)
num_dofs = V.dofmap.index_map.size_global * V.dofmap.index_map_bs
if noslip:
with Timer(f"{num_dofs}: Contact-constraint"):
mpc.create_contact_inelastic_condition(mt, 4, 9)
else:
with Timer(f"{num_dofs}: FacetNormal"):
nh = create_normal_approximation(V, mt, 4)
with Timer(f"{num_dofs}: Contact-constraint"):
mpc.create_contact_slip_condition(mt, 4, 9, nh)
with Timer(f"{num_dofs}: MPC-init"):
mpc.finalize()
null_space = rigid_motions_nullspace(mpc.function_space)
log_info(f"Num dofs: {num_dofs}")
log_info("Assemble matrix")
bilinear_form = form(a)
linear_form = form(rhs)
with Timer(f"{num_dofs}: Assemble-matrix (C++)"):
A = assemble_matrix(bilinear_form, mpc, bcs=bcs)
with Timer(f"{num_dofs}: Assemble-vector (C++)"):
b = assemble_vector(linear_form, mpc)
apply_lifting(b, [bilinear_form], [bcs], mpc)
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
set_bc(b, bcs)
list_timings(MPI.COMM_WORLD, [TimingType.wall])
# Solve Linear problem
opts = PETSc.Options()
# opts["ksp_rtol"] = 1.0e-8
opts["pc_type"] = "gamg"
# opts["pc_gamg_type"] = "agg"
# opts["pc_gamg_coarse_eq_limit"] = 1000
# opts["pc_gamg_sym_graph"] = True
# opts["mg_levels_ksp_type"] = "chebyshev"
# opts["mg_levels_pc_type"] = "jacobi"
# opts["mg_levels_esteig_ksp_type"] = "cg"
# opts["matptap_via"] = "scalable"
# opts["pc_gamg_square_graph"] = 2
# opts["pc_gamg_threshold"] = 1e-2
# opts["help"] = None # List all available options
if timings:
opts["ksp_view"] = None # List progress of solver
# Create functionspace and build near nullspace
A.setNearNullSpace(null_space)
solver = PETSc.KSP().create(comm)
solver.setOperators(A)
solver.setFromOptions()
uh = b.copy()
uh.set(0)
log_info("Solve")
with Timer(f"{num_dofs}: Solve"):
solver.solve(b, uh)
uh.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
log_info("Backsub")
with Timer(f"{num_dofs}: Backsubstitution"):
mpc.backsubstitution(uh)
it = solver.getIterationNumber()
# Write solution to file
u_h = Function(mpc.function_space)
u_h.vector.setArray(uh.array)
u_h.name = "u"
with XDMFFile(comm, f"results/bench_contact_{num_dofs}.xdmf",
"w") as outfile:
outfile.write_mesh(mesh)
outfile.write_function(u_h, 0.0,
f"Xdmf/Domain/Grid[@Name='{mesh.name}'][1]")
# Write performance data to file
if timings:
log_info("Timings")
num_slaves = MPI.COMM_WORLD.allreduce(mpc.num_local_slaves, op=MPI.SUM)
results_file = None
num_procs = comm.size
if comm.rank == 0:
results_file = open(f"results_bench_{num_dofs}.txt", "w")
print(f"#Procs: {num_procs}", file=results_file)
print(f"#Dofs: {num_dofs}", file=results_file)
print(f"#Slaves: {num_slaves}", file=results_file)
print(f"#Iterations: {it}", file=results_file)
operations = [
"Solve", "Assemble-matrix (C++)", "MPC-init", "Contact-constraint",
"FacetNormal", "Assemble-vector (C++)", "Backsubstitution"
]
if comm.rank == 0:
print("Operation #Calls Avg Min Max", file=results_file)
for op in operations:
op_timing = timing(f"{num_dofs}: {op}")
num_calls = op_timing[0]
wall_time = op_timing[1]
avg_time = comm.allreduce(wall_time, op=MPI.SUM) / comm.size
min_time = comm.allreduce(wall_time, op=MPI.MIN)
max_time = comm.allreduce(wall_time, op=MPI.MAX)
if comm.rank == 0:
print(op,
num_calls,
avg_time,
min_time,
max_time,
file=results_file)
list_timings(MPI.COMM_WORLD, [TimingType.wall])
def demo_elasticity():
mesh = create_unit_square(MPI.COMM_WORLD, 10, 10)
V = fem.VectorFunctionSpace(mesh, ("Lagrange", 1))
# Generate Dirichlet BC on lower boundary (Fixed)
def boundaries(x):
return np.isclose(x[0], np.finfo(float).eps)
facets = locate_entities_boundary(mesh, 1, boundaries)
topological_dofs = fem.locate_dofs_topological(V, 1, facets)
bc = fem.dirichletbc(np.array([0, 0], dtype=PETSc.ScalarType),
topological_dofs, V)
bcs = [bc]
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
# Elasticity parameters
E = PETSc.ScalarType(1.0e4)
nu = 0.0
mu = fem.Constant(mesh, E / (2.0 * (1.0 + nu)))
lmbda = fem.Constant(mesh, E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu)))
# Stress computation
def sigma(v):
return (2.0 * mu * sym(grad(v)) +
lmbda * tr(sym(grad(v))) * Identity(len(v)))
x = SpatialCoordinate(mesh)
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
a = inner(sigma(u), grad(v)) * dx
rhs = inner(as_vector((0, (x[0] - 0.5) * 10**4 * x[1])), v) * dx
# Create MPC
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {l2b([1, 0]): {l2b([1, 1]): 0.9}}
mpc = MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c, 1, 1)
mpc.finalize()
# Solve Linear problem
petsc_options = {"ksp_type": "preonly", "pc_type": "lu"}
problem = LinearProblem(a, rhs, mpc, bcs=bcs, petsc_options=petsc_options)
u_h = problem.solve()
u_h.name = "u_mpc"
with XDMFFile(MPI.COMM_WORLD, "results/demo_elasticity.xdmf",
"w") as outfile:
outfile.write_mesh(mesh)
outfile.write_function(u_h)
# Solve the MPC problem using a global transformation matrix
# and numpy solvers to get reference values
bilinear_form = fem.form(a)
A_org = fem.petsc.assemble_matrix(bilinear_form, bcs)
A_org.assemble()
linear_form = fem.form(rhs)
L_org = fem.petsc.assemble_vector(linear_form)
fem.petsc.apply_lifting(L_org, [bilinear_form], [bcs])
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
fem.petsc.set_bc(L_org, bcs)
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setType(PETSc.KSP.Type.PREONLY)
solver.getPC().setType(PETSc.PC.Type.LU)
solver.setOperators(A_org)
u_ = fem.Function(V)
solver.solve(L_org, u_.vector)
u_.x.scatter_forward()
u_.name = "u_unconstrained"
with XDMFFile(MPI.COMM_WORLD, "results/demo_elasticity.xdmf",
"a") as outfile:
outfile.write_function(u_)
outfile.close()
root = 0
with Timer("~Demo: Verification"):
dolfinx_mpc.utils.compare_mpc_lhs(A_org, problem.A, mpc, root=root)
dolfinx_mpc.utils.compare_mpc_rhs(L_org, problem.b, mpc, root=root)
# Gather LHS, RHS and solution on one process
A_csr = dolfinx_mpc.utils.gather_PETScMatrix(A_org, root=root)
K = dolfinx_mpc.utils.gather_transformation_matrix(mpc, root=root)
L_np = dolfinx_mpc.utils.gather_PETScVector(L_org, root=root)
u_mpc = dolfinx_mpc.utils.gather_PETScVector(u_h.vector, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc)
# Print out master-slave connectivity for the first slave
master_owner = None
master_data = None
slave_owner = None
if mpc.num_local_slaves > 0:
slave_owner = MPI.COMM_WORLD.rank
bs = mpc.function_space.dofmap.index_map_bs
slave = mpc.slaves[0]
print("Constrained: {0:.5e}\n Unconstrained: {1:.5e}".format(
u_h.x.array[slave], u_.vector.array[slave]))
master_owner = mpc._cpp_object.owners.links(slave)[0]
_masters = mpc.masters
master = _masters.links(slave)[0]
glob_master = mpc.function_space.dofmap.index_map.local_to_global(
[master // bs])[0]
coeffs, offs = mpc.coefficients()
master_data = [
glob_master * bs + master % bs,
coeffs[offs[slave]:offs[slave + 1]][0]
]
# If master not on proc send info to this processor
if MPI.COMM_WORLD.rank != master_owner:
MPI.COMM_WORLD.send(master_data, dest=master_owner, tag=1)
else:
print("Master*Coeff: {0:.5e}".format(
coeffs[offs[slave]:offs[slave + 1]][0] *
u_h.x.array[_masters.links(slave)[0]]))
# As a processor with a master is not aware that it has a master,
# Determine this so that it can receive the global dof and coefficient
master_recv = MPI.COMM_WORLD.allgather(master_owner)
for master in master_recv:
if master is not None:
master_owner = master
break
if slave_owner != master_owner and MPI.COMM_WORLD.rank == master_owner:
dofmap = mpc.function_space.dofmap
bs = dofmap.index_map_bs
in_data = MPI.COMM_WORLD.recv(source=MPI.ANY_SOURCE, tag=1)
num_local = dofmap.index_map.size_local + dofmap.index_map.num_ghosts
l2g = dofmap.index_map.local_to_global(
np.arange(num_local, dtype=np.int32))
l_index = np.flatnonzero(l2g == in_data[0] // bs)[0]
print("Master*Coeff (on other proc): {0:.5e}".format(
u_h.x.array[l_index * bs + in_data[0] % bs] * in_data[1]))
def assemble_matrix(form: _forms, constraint: MultiPointConstraint,
bcs: List[_bcs] = None, diagval: _PETSc.ScalarType = 1.,
A: _PETSc.Mat = None):
"""
Assembles a compiled DOLFINx form with given a multi point constraint and possible
Dirichlet boundary conditions.
NOTE: Strong Dirichlet conditions cannot be on master dofs.
Parameters
----------
form
The compiled bilinear form
constraint
The multi point constraint
bcs
List of Dirichlet boundary conditions
diagval
Value to set on the diagonal of the matrix(Default 1)
A
PETSc matrix to assemble into (optional)
"""
timer_matrix = Timer("~MPC: Assemble matrix (numba)")
V = constraint.function_space
dofmap = V.dofmap
dofs = dofmap.list.array
# Pack MPC data for numba kernels
coefficients = constraint.coefficients()[0]
masters_adj = constraint.masters
c_to_s_adj = constraint.cell_to_slaves
cell_to_slave = c_to_s_adj.array
c_to_s_off = c_to_s_adj.offsets
is_slave = constraint.is_slave
mpc_data = (masters_adj.array, coefficients, masters_adj.offsets, cell_to_slave, c_to_s_off, is_slave)
slave_cells = extract_slave_cells(c_to_s_off)
# Create 1D bc indicator for matrix assembly
num_dofs_local = (dofmap.index_map.size_local + dofmap.index_map.num_ghosts) * dofmap.index_map_bs
is_bc = numpy.zeros(num_dofs_local, dtype=bool)
bcs = [] if bcs is None else bcs
if len(bcs) > 0:
for bc in bcs:
is_bc[bc.dof_indices()[0]] = True
# Get data from mesh
pos = V.mesh.geometry.dofmap.offsets
x_dofs = V.mesh.geometry.dofmap.array
x = V.mesh.geometry.x
# Pack constants and coefficients
form_coeffs = _cpp.fem.pack_coefficients(form)
form_consts = _cpp.fem.pack_constants(form)
# Create sparsity pattern and matrix if not supplied
if A is None:
pattern = create_sparsity_pattern(form, constraint)
pattern.assemble()
A = _cpp.la.petsc.create_matrix(V.mesh.comm, pattern)
A.zeroEntries()
# Assemble the matrix with all entries
_cpp.fem.petsc.assemble_matrix(A, form, form_consts, form_coeffs, bcs, False)
# General assembly data
block_size = dofmap.dof_layout.block_size
num_dofs_per_element = dofmap.dof_layout.num_dofs
tdim = V.mesh.topology.dim
# Assemble over cells
subdomain_ids = form.integral_ids(_fem.IntegralType.cell)
num_cell_integrals = len(subdomain_ids)
e0 = form.function_spaces[0].element
e1 = form.function_spaces[1].element
# Get dof transformations
needs_transformation_data = e0.needs_dof_transformations or e1.needs_dof_transformations or \
form.needs_facet_permutations
cell_perms = numpy.array([], dtype=numpy.uint32)
if needs_transformation_data:
V.mesh.topology.create_entity_permutations()
cell_perms = V.mesh.topology.get_cell_permutation_info()
# NOTE: Here we need to add the apply_dof_transformation and apply_dof_transformation transpose functions
# to support more exotic elements
if e0.needs_dof_transformations or e1.needs_dof_transformations:
raise NotImplementedError("Dof transformations not implemented")
is_complex = numpy.issubdtype(_PETSc.ScalarType, numpy.complexfloating)
nptype = "complex128" if is_complex else "float64"
ufcx_form = form.ufcx_form
if num_cell_integrals > 0:
V.mesh.topology.create_entity_permutations()
for i, id in enumerate(subdomain_ids):
coeffs_i = form_coeffs[(_fem.IntegralType.cell, id)]
cell_kernel = getattr(ufcx_form.integrals(_fem.IntegralType.cell)[i], f"tabulate_tensor_{nptype}")
active_cells = form.domains(_fem.IntegralType.cell, id)
assemble_slave_cells(A.handle, cell_kernel, active_cells[numpy.isin(active_cells, slave_cells)],
(pos, x_dofs, x), coeffs_i, form_consts, cell_perms, dofs,
block_size, num_dofs_per_element, mpc_data, is_bc)
# Assemble over exterior facets
subdomain_ids = form.integral_ids(_fem.IntegralType.exterior_facet)
num_exterior_integrals = len(subdomain_ids)
if num_exterior_integrals > 0:
V.mesh.topology.create_entities(tdim - 1)
V.mesh.topology.create_connectivity(tdim - 1, tdim)
# Get facet permutations if required
facet_perms = numpy.array([], dtype=numpy.uint8)
if form.needs_facet_permutations:
facet_perms = V.mesh.topology.get_facet_permutations()
perm = (cell_perms, form.needs_facet_permutations, facet_perms)
for i, id in enumerate(subdomain_ids):
facet_kernel = getattr(ufcx_form.integrals(_fem.IntegralType.exterior_facet)
[i], f"tabulate_tensor_{nptype}")
facets = form.domains(_fem.IntegralType.exterior_facet, id)
coeffs_i = form_coeffs[(_fem.IntegralType.exterior_facet, id)]
facet_info = pack_slave_facet_info(facets, slave_cells)
num_facets_per_cell = len(V.mesh.topology.connectivity(tdim, tdim - 1).links(0))
assemble_exterior_slave_facets(A.handle, facet_kernel, (pos, x_dofs, x), coeffs_i, form_consts,
perm, dofs, block_size, num_dofs_per_element, facet_info, mpc_data, is_bc,
num_facets_per_cell)
# Add mpc entries on diagonal
slaves = constraint.slaves
num_local_slaves = constraint.num_local_slaves
add_diagonal(A.handle, slaves[:num_local_slaves], diagval)
# Add one on diagonal for diriclet bc and slave dofs
# NOTE: In the future one could use a constant in the dirichletbc
if form.function_spaces[0] is form.function_spaces[1]:
A.assemblyBegin(_PETSc.Mat.AssemblyType.FLUSH)
A.assemblyEnd(_PETSc.Mat.AssemblyType.FLUSH)
_cpp.fem.petsc.insert_diagonal(A, form.function_spaces[0], bcs, diagval)
A.assemble()
timer_matrix.stop()
return A
def test_surface_integrals(get_assemblers): # noqa: F811
assemble_matrix, assemble_vector = get_assemblers
N = 4
mesh = create_unit_square(MPI.COMM_WORLD, N, N)
V = fem.VectorFunctionSpace(mesh, ("Lagrange", 1))
# Fixed Dirichlet BC on the left wall
def left_wall(x):
return np.isclose(x[0], np.finfo(float).eps)
fdim = mesh.topology.dim - 1
left_facets = locate_entities_boundary(mesh, fdim, left_wall)
bc_dofs = fem.locate_dofs_topological(V, 1, left_facets)
u_bc = fem.Function(V)
with u_bc.vector.localForm() as u_local:
u_local.set(0.0)
bc = fem.dirichletbc(u_bc, bc_dofs)
bcs = [bc]
# Traction on top of domain
def top(x):
return np.isclose(x[1], 1)
top_facets = locate_entities_boundary(mesh, 1, top)
arg_sort = np.argsort(top_facets)
mt = meshtags(mesh, fdim, top_facets[arg_sort], np.full(len(top_facets), 3, dtype=np.int32))
ds = ufl.Measure("ds", domain=mesh, subdomain_data=mt, subdomain_id=3)
g = fem.Constant(mesh, PETSc.ScalarType((0, -9.81e2)))
# Elasticity parameters
E = PETSc.ScalarType(1.0e4)
nu = 0.0
mu = fem.Constant(mesh, E / (2.0 * (1.0 + nu)))
lmbda = fem.Constant(mesh, E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu)))
# Stress computation
def sigma(v):
return (2.0 * mu * ufl.sym(ufl.grad(v))
+ lmbda * ufl.tr(ufl.sym(ufl.grad(v))) * ufl.Identity(len(v)))
# Define variational problem
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
a = ufl.inner(sigma(u), ufl.grad(v)) * ufl.dx
rhs = ufl.inner(fem.Constant(mesh, PETSc.ScalarType((0, 0))), v) * ufl.dx\
+ ufl.inner(g, v) * ds
bilinear_form = fem.form(a)
linear_form = fem.form(rhs)
# Setup LU solver
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setType(PETSc.KSP.Type.PREONLY)
solver.getPC().setType(PETSc.PC.Type.LU)
# Setup multipointconstraint
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {}
for i in range(1, N):
s_m_c[l2b([1, i / N])] = {l2b([1, 1]): 0.8}
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c, 1, 1)
mpc.finalize()
with Timer("~TEST: Assemble matrix old"):
A = assemble_matrix(bilinear_form, mpc, bcs=bcs)
with Timer("~TEST: Assemble vector"):
b = assemble_vector(linear_form, mpc)
dolfinx_mpc.apply_lifting(b, [bilinear_form], [bcs], mpc)
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES, mode=PETSc.ScatterMode.REVERSE)
fem.petsc.set_bc(b, bcs)
solver.setOperators(A)
uh = b.copy()
uh.set(0)
solver.solve(b, uh)
uh.ghostUpdate(addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD)
mpc.backsubstitution(uh)
# Write solution to file
# u_h = dolfinx.Function(mpc.function_space)
# u_h.vector.setArray(uh.array)
# u_h.name = "u_mpc"
# outfile = dolfinx.io.XDMFFile(MPI.COMM_WORLD, "output/uh.xdmf", "w")
# outfile.write_mesh(mesh)
# outfile.write_function(u_h)
# outfile.close()
# Solve the MPC problem using a global transformation matrix
# and numpy solvers to get reference values
# Generate reference matrices and unconstrained solution
A_org = fem.petsc.assemble_matrix(bilinear_form, bcs)
A_org.assemble()
L_org = fem.petsc.assemble_vector(linear_form)
fem.petsc.apply_lifting(L_org, [bilinear_form], [bcs])
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES, mode=PETSc.ScatterMode.REVERSE)
fem.petsc.set_bc(L_org, bcs)
root = 0
comm = mesh.comm
with Timer("~TEST: Compare"):
dolfinx_mpc.utils.compare_mpc_lhs(A_org, A, mpc, root=root)
dolfinx_mpc.utils.compare_mpc_rhs(L_org, b, mpc, root=root)
# Gather LHS, RHS and solution on one process
A_csr = dolfinx_mpc.utils.gather_PETScMatrix(A_org, root=root)
K = dolfinx_mpc.utils.gather_transformation_matrix(mpc, root=root)
L_np = dolfinx_mpc.utils.gather_PETScVector(L_org, root=root)
u_mpc = dolfinx_mpc.utils.gather_PETScVector(uh, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc)
list_timings(comm, [TimingType.wall])
def test_pipeline(master_point, get_assemblers): # noqa: F811
assemble_matrix, assemble_vector = get_assemblers
# Create mesh and function space
mesh = create_unit_square(MPI.COMM_WORLD, 3, 5)
V = fem.FunctionSpace(mesh, ("Lagrange", 1))
# Solve Problem without MPC for reference
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
d = fem.Constant(mesh, PETSc.ScalarType(1.5))
c = fem.Constant(mesh, PETSc.ScalarType(2))
x = ufl.SpatialCoordinate(mesh)
f = c * ufl.sin(2 * ufl.pi * x[0]) * ufl.sin(ufl.pi * x[1])
g = fem.Function(V)
g.interpolate(lambda x: np.sin(x[0]) * x[1])
h = fem.Function(V)
h.interpolate(lambda x: 2 + x[1] * x[0])
a = d * g * ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx
rhs = h * ufl.inner(f, v) * ufl.dx
bilinear_form = fem.form(a)
linear_form = fem.form(rhs)
# Generate reference matrices
A_org = fem.petsc.assemble_matrix(bilinear_form)
A_org.assemble()
L_org = fem.petsc.assemble_vector(linear_form)
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
# Create multipoint constraint
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {
l2b([1, 0]): {
l2b([0, 1]): 0.43,
l2b([1, 1]): 0.11
},
l2b([0, 0]): {
l2b(master_point): 0.69
}
}
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c)
mpc.finalize()
A = assemble_matrix(bilinear_form, mpc)
b = assemble_vector(linear_form, mpc)
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setType(PETSc.KSP.Type.PREONLY)
solver.getPC().setType(PETSc.PC.Type.LU)
solver.setOperators(A)
# Solve
uh = b.copy()
uh.set(0)
solver.solve(b, uh)
uh.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
mpc.backsubstitution(uh)
root = 0
comm = mesh.comm
with Timer("~TEST: Compare"):
dolfinx_mpc.utils.compare_mpc_lhs(A_org, A, mpc, root=root)
dolfinx_mpc.utils.compare_mpc_rhs(L_org, b, mpc, root=root)
# Gather LHS, RHS and solution on one process
A_csr = dolfinx_mpc.utils.gather_PETScMatrix(A_org, root=root)
K = dolfinx_mpc.utils.gather_transformation_matrix(mpc, root=root)
L_np = dolfinx_mpc.utils.gather_PETScVector(L_org, root=root)
u_mpc = dolfinx_mpc.utils.gather_PETScVector(uh, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc)
list_timings(comm, [TimingType.wall])
def mesh_3D_dolfin(theta=0,
ct=CellType.tetrahedron,
ext="tetrahedron",
num_refinements=0,
N0=5):
timer = Timer("Create mesh")
def find_plane_function(p0, p1, p2):
"""
Find plane function given three points:
http://www.nabla.hr/CG-LinesPlanesIn3DA3.htm
"""
v1 = np.array(p1) - np.array(p0)
v2 = np.array(p2) - np.array(p0)
n = np.cross(v1, v2)
D = -(n[0] * p0[0] + n[1] * p0[1] + n[2] * p0[2])
return lambda x: np.isclose(0, np.dot(n, x) + D)
def over_plane(p0, p1, p2):
"""
Returns function that checks if a point is over a plane defined
by the points p0, p1 and p2.
"""
v1 = np.array(p1) - np.array(p0)
v2 = np.array(p2) - np.array(p0)
n = np.cross(v1, v2)
D = -(n[0] * p0[0] + n[1] * p0[1] + n[2] * p0[2])
return lambda x: n[0] * x[0] + n[1] * x[1] + D > -n[2] * x[2]
tmp_mesh_name = "tmp_mesh.xdmf"
r_matrix = rotation_matrix([1 / np.sqrt(2), 1 / np.sqrt(2), 0], -theta)
if MPI.COMM_WORLD.rank == 0:
# Create two coarse meshes and merge them
mesh0 = create_unit_cube(MPI.COMM_SELF, N0, N0, N0, ct)
mesh0.geometry.x[:, 2] += 1
mesh1 = create_unit_cube(MPI.COMM_SELF, 2 * N0, 2 * N0, 2 * N0, ct)
tdim0 = mesh0.topology.dim
num_cells0 = mesh0.topology.index_map(tdim0).size_local
cells0 = entities_to_geometry(
mesh0, tdim0,
np.arange(num_cells0, dtype=np.int32).reshape((-1, 1)), False)
tdim1 = mesh1.topology.dim
num_cells1 = mesh1.topology.index_map(tdim1).size_local
cells1 = entities_to_geometry(
mesh1, tdim1,
np.arange(num_cells1, dtype=np.int32).reshape((-1, 1)), False)
cells1 += mesh0.geometry.x.shape[0]
# Concatenate points and cells
points = np.vstack([mesh0.geometry.x, mesh1.geometry.x])
cells = np.vstack([cells0, cells1])
cell = Cell(ext, geometric_dimension=points.shape[1])
domain = Mesh(VectorElement("Lagrange", cell, 1))
# Rotate mesh
points = np.dot(r_matrix, points.T).T
mesh = create_mesh(MPI.COMM_SELF, cells, points, domain)
with XDMFFile(MPI.COMM_SELF, tmp_mesh_name, "w") as xdmf:
xdmf.write_mesh(mesh)
MPI.COMM_WORLD.barrier()
with XDMFFile(MPI.COMM_WORLD, tmp_mesh_name, "r") as xdmf:
mesh = xdmf.read_mesh()
# Refine coarse mesh
for i in range(num_refinements):
mesh.topology.create_entities(mesh.topology.dim - 2)
mesh = refine(mesh, redistribute=True)
tdim = mesh.topology.dim
fdim = tdim - 1
# Find information about facets to be used in meshtags
bottom_points = np.dot(
r_matrix,
np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0]]).T)
bottom = find_plane_function(bottom_points[:, 0], bottom_points[:, 1],
bottom_points[:, 2])
bottom_facets = locate_entities_boundary(mesh, fdim, bottom)
top_points = np.dot(
r_matrix,
np.array([[0, 0, 2], [1, 0, 2], [0, 1, 2], [1, 1, 2]]).T)
top = find_plane_function(top_points[:, 0], top_points[:, 1],
top_points[:, 2])
top_facets = locate_entities_boundary(mesh, fdim, top)
# Determine interface facets
if_points = np.dot(
r_matrix,
np.array([[0, 0, 1], [1, 0, 1], [0, 1, 1], [1, 1, 1]]).T)
interface = find_plane_function(if_points[:, 0], if_points[:, 1],
if_points[:, 2])
i_facets = locate_entities_boundary(mesh, fdim, interface)
mesh.topology.create_connectivity(fdim, tdim)
top_interface = []
bottom_interface = []
facet_to_cell = mesh.topology.connectivity(fdim, tdim)
num_cells = mesh.topology.index_map(tdim).size_local
# Find top and bottom interface facets
cell_midpoints = compute_midpoints(mesh, tdim, range(num_cells))
top_cube = over_plane(if_points[:, 0], if_points[:, 1], if_points[:, 2])
for facet in i_facets:
i_cells = facet_to_cell.links(facet)
assert (len(i_cells == 1))
i_cell = i_cells[0]
if top_cube(cell_midpoints[i_cell]):
top_interface.append(facet)
else:
bottom_interface.append(facet)
# Create cell tags
num_cells = mesh.topology.index_map(tdim).size_local
cell_midpoints = compute_midpoints(mesh, tdim, range(num_cells))
top_cube_marker = 2
indices = []
values = []
for cell_index in range(num_cells):
if top_cube(cell_midpoints[cell_index]):
indices.append(cell_index)
values.append(top_cube_marker)
ct = meshtags(mesh, tdim, np.array(indices, dtype=np.intc),
np.array(values, dtype=np.intc))
# Create meshtags for facet data
markers = {
3: top_facets,
4: bottom_interface,
9: top_interface,
5: bottom_facets
} # , 6: left_facets, 7: right_facets}
indices = np.array([], dtype=np.intc)
values = np.array([], dtype=np.intc)
for key in markers.keys():
indices = np.append(indices, markers[key])
values = np.append(values,
np.full(len(markers[key]), key, dtype=np.intc))
sorted_indices = np.argsort(indices)
mt = meshtags(mesh, fdim, indices[sorted_indices], values[sorted_indices])
mt.name = "facet_tags"
fname = f"meshes/mesh_{ext}_{theta:.2f}.xdmf"
with XDMFFile(MPI.COMM_WORLD, fname, "w") as o_f:
o_f.write_mesh(mesh)
o_f.write_meshtags(ct)
o_f.write_meshtags(mt)
timer.stop()
def demo_stacked_cubes(outfile: XDMFFile, theta: float, gmsh: bool = False, ct: CellType = CellType.tetrahedron,
compare: bool = True, res: float = 0.1, noslip: bool = False):
celltype = "hexahedron" if ct == CellType.hexahedron else "tetrahedron"
type_ext = "no_slip" if noslip else "slip"
mesh_ext = "_gmsh_" if gmsh else "_"
log_info(f"Run theta:{theta:.2f}, Cell: {celltype}, GMSH {gmsh}, Noslip: {noslip}")
# Read in mesh
if gmsh:
mesh, mt = gmsh_3D_stacked(celltype, theta, res)
tdim = mesh.topology.dim
fdim = tdim - 1
mesh.topology.create_connectivity(tdim, tdim)
mesh.topology.create_connectivity(fdim, tdim)
else:
mesh_3D_dolfin(theta, ct, celltype, res)
MPI.COMM_WORLD.barrier()
with XDMFFile(MPI.COMM_WORLD, f"meshes/mesh_{celltype}_{theta:.2f}.xdmf", "r") as xdmf:
mesh = xdmf.read_mesh(name="mesh")
tdim = mesh.topology.dim
fdim = tdim - 1
mesh.topology.create_connectivity(tdim, tdim)
mesh.topology.create_connectivity(fdim, tdim)
mt = xdmf.read_meshtags(mesh, "facet_tags")
mesh.name = f"mesh_{celltype}_{theta:.2f}{type_ext}{mesh_ext}"
# Create functionspaces
V = fem.VectorFunctionSpace(mesh, ("Lagrange", 1))
# Define boundary conditions
# Bottom boundary is fixed in all directions
bottom_dofs = fem.locate_dofs_topological(V, fdim, mt.find(5)) # type: ignore
u_bc = np.array((0, ) * mesh.geometry.dim, dtype=PETSc.ScalarType)
bc_bottom = fem.dirichletbc(u_bc, bottom_dofs, V)
g_vec = np.array([0, 0, -4.25e-1], dtype=PETSc.ScalarType)
if not noslip:
# Helper for orienting traction
r_matrix = rotation_matrix([1 / np.sqrt(2), 1 / np.sqrt(2), 0], -theta)
# Top boundary has a given deformation normal to the interface
g_vec = np.dot(r_matrix, g_vec)
top_dofs = fem.locate_dofs_topological(V, fdim, mt.find(3)) # type: ignore
bc_top = fem.dirichletbc(g_vec, top_dofs, V)
bcs = [bc_bottom, bc_top]
# Elasticity parameters
E = PETSc.ScalarType(1.0e3)
nu = 0
mu = fem.Constant(mesh, E / (2.0 * (1.0 + nu)))
lmbda = fem.Constant(mesh, E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu)))
# Stress computation
def sigma(v):
return (2.0 * mu * sym(grad(v)) + lmbda * tr(sym(grad(v))) * Identity(len(v)))
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
a = inner(sigma(u), grad(v)) * dx
# NOTE: Traction deactivated until we have a way of fixing nullspace
# g = fem.Constant(mesh, PETSc.ScalarType(g_vec))
# ds = Measure("ds", domain=mesh, subdomain_data=mt, subdomain_id=3)
rhs = inner(fem.Constant(mesh, PETSc.ScalarType((0, 0, 0))), v) * dx
# + inner(g, v) * ds
bilinear_form = fem.form(a)
linear_form = fem.form(rhs)
mpc = MultiPointConstraint(V)
if noslip:
with Timer("~~Contact: Create non-elastic constraint"):
mpc.create_contact_inelastic_condition(mt, 4, 9)
else:
with Timer("~Contact: Create contact constraint"):
nh = create_normal_approximation(V, mt, 4)
mpc.create_contact_slip_condition(mt, 4, 9, nh)
with Timer("~~Contact: Add data and finialize MPC"):
mpc.finalize()
# Create null-space
null_space = rigid_motions_nullspace(mpc.function_space)
num_dofs = V.dofmap.index_map.size_global * V.dofmap.index_map_bs
with Timer(f"~~Contact: Assemble matrix ({num_dofs})"):
A = assemble_matrix(bilinear_form, mpc, bcs=bcs)
with Timer(f"~~Contact: Assemble vector ({num_dofs})"):
b = assemble_vector(linear_form, mpc)
apply_lifting(b, [bilinear_form], [bcs], mpc)
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES, mode=PETSc.ScatterMode.REVERSE)
fem.petsc.set_bc(b, bcs)
# Solve Linear problem
opts = PETSc.Options()
opts["ksp_rtol"] = 1.0e-8
opts["pc_type"] = "gamg"
opts["pc_gamg_type"] = "agg"
opts["pc_gamg_coarse_eq_limit"] = 1000
opts["pc_gamg_sym_graph"] = True
opts["mg_levels_ksp_type"] = "chebyshev"
opts["mg_levels_pc_type"] = "jacobi"
opts["mg_levels_esteig_ksp_type"] = "cg"
opts["matptap_via"] = "scalable"
# opts["pc_gamg_square_graph"] = 2
# opts["pc_gamg_threshold"] = 1e-2
# opts["help"] = None # List all available options
# opts["ksp_view"] = None # List progress of solver
# Create functionspace and build near nullspace
A.setNearNullSpace(null_space)
solver = PETSc.KSP().create(mesh.comm)
solver.setOperators(A)
solver.setFromOptions()
u_h = fem.Function(mpc.function_space)
with Timer("~~Contact: Solve"):
solver.solve(b, u_h.vector)
u_h.x.scatter_forward()
with Timer("~~Contact: Backsubstitution"):
mpc.backsubstitution(u_h.vector)
it = solver.getIterationNumber()
unorm = u_h.vector.norm()
num_slaves = MPI.COMM_WORLD.allreduce(mpc.num_local_slaves, op=MPI.SUM)
if mesh.comm.rank == 0:
num_dofs = V.dofmap.index_map.size_global * V.dofmap.index_map_bs
print(f"Number of dofs: {num_dofs}")
print(f"Number of slaves: {num_slaves}")
print(f"Number of iterations: {it}")
print(f"Norm of u {unorm:.5e}")
# Write solution to file
u_h.name = f"u_{celltype}_{theta:.2f}{mesh_ext}{type_ext}".format(celltype, theta, type_ext, mesh_ext)
outfile.write_mesh(mesh)
outfile.write_function(u_h, 0.0, f"Xdmf/Domain/Grid[@Name='{mesh.name}'][1]")
# Solve the MPC problem using a global transformation matrix
# and numpy solvers to get reference values
if not compare:
return
log_info("Solving reference problem with global matrix (using scipy)")
with Timer("~~Contact: Reference problem"):
A_org = fem.petsc.assemble_matrix(bilinear_form, bcs)
A_org.assemble()
L_org = fem.petsc.assemble_vector(linear_form)
fem.petsc.apply_lifting(L_org, [bilinear_form], [bcs])
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES, mode=PETSc.ScatterMode.REVERSE)
fem.petsc.set_bc(L_org, bcs)
root = 0
with Timer("~~Contact: Compare LHS, RHS and solution"):
compare_mpc_lhs(A_org, A, mpc, root=root)
compare_mpc_rhs(L_org, b, mpc, root=root)
# Gather LHS, RHS and solution on one process
A_csr = gather_PETScMatrix(A_org, root=root)
K = gather_transformation_matrix(mpc, root=root)
L_np = gather_PETScVector(L_org, root=root)
u_mpc = gather_PETScVector(u_h.vector, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc)
list_timings(mesh.comm, [TimingType.wall])
def test_cell_domains(get_assemblers): # noqa: F811
"""
Periodic MPC conditions over integral with different cell subdomains
"""
assemble_matrix, assemble_vector = get_assemblers
N = 5
# Create mesh and function space
mesh = create_unit_square(MPI.COMM_WORLD, 15, N)
V = fem.FunctionSpace(mesh, ("Lagrange", 1))
def left_side(x):
return x[0] < 0.5
tdim = mesh.topology.dim
num_cells = mesh.topology.index_map(tdim).size_local
cell_midpoints = compute_midpoints(mesh, tdim, range(num_cells))
values = np.ones(num_cells, dtype=np.intc)
# All cells on right side marked one, all other with 1
values += left_side(cell_midpoints.T)
ct = meshtags(mesh, mesh.topology.dim, np.arange(num_cells,
dtype=np.int32), values)
# Solve Problem without MPC for reference
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
x = ufl.SpatialCoordinate(mesh)
c1 = fem.Constant(mesh, PETSc.ScalarType(2))
c2 = fem.Constant(mesh, PETSc.ScalarType(10))
dx = ufl.Measure("dx", domain=mesh, subdomain_data=ct)
a = c1 * ufl.inner(ufl.grad(u), ufl.grad(v)) * dx(1) +\
c2 * ufl.inner(ufl.grad(u), ufl.grad(v)) * dx(2)\
+ 0.01 * ufl.inner(u, v) * dx(1)
rhs = ufl.inner(x[1], v) * dx(1) + \
ufl.inner(fem.Constant(mesh, PETSc.ScalarType(1)), v) * dx(2)
bilinear_form = fem.form(a)
linear_form = fem.form(rhs)
# Generate reference matrices
A_org = fem.petsc.assemble_matrix(bilinear_form)
A_org.assemble()
L_org = fem.petsc.assemble_vector(linear_form)
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {}
for i in range(0, N + 1):
s_m_c[l2b([1, i / N])] = {l2b([0, i / N]): 1}
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c)
mpc.finalize()
# Setup MPC system
with Timer("~TEST: Assemble matrix old"):
A = assemble_matrix(bilinear_form, mpc)
with Timer("~TEST: Assemble vector"):
b = assemble_vector(linear_form, mpc)
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setType(PETSc.KSP.Type.PREONLY)
solver.getPC().setType(PETSc.PC.Type.LU)
solver.setOperators(A)
# Solve
uh = b.copy()
uh.set(0)
solver.solve(b, uh)
uh.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
mpc.backsubstitution(uh)
root = 0
comm = mesh.comm
with Timer("~TEST: Compare"):
dolfinx_mpc.utils.compare_mpc_lhs(A_org, A, mpc, root=root)
dolfinx_mpc.utils.compare_mpc_rhs(L_org, b, mpc, root=root)
# Gather LHS, RHS and solution on one process
A_csr = dolfinx_mpc.utils.gather_PETScMatrix(A_org, root=root)
K = dolfinx_mpc.utils.gather_transformation_matrix(mpc, root=root)
L_np = dolfinx_mpc.utils.gather_PETScVector(L_org, root=root)
u_mpc = dolfinx_mpc.utils.gather_PETScVector(uh, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc)
list_timings(comm, [TimingType.wall])
bcs = [bc]
def periodic_boundary(x):
return np.isclose(x[0], 1)
def periodic_relation(x):
out_x = np.zeros(x.shape)
out_x[0] = 1 - x[0]
out_x[1] = x[1]
out_x[2] = x[2]
return out_x
with Timer("~PERIODIC: Initialize MPC"):
mpc = MultiPointConstraint(V)
mpc.create_periodic_constraint_geometrical(V, periodic_boundary,
periodic_relation, bcs)
mpc.finalize()
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
a = inner(grad(u), grad(v)) * dx
x = SpatialCoordinate(mesh)
dx_ = x[0] - 0.9
dy_ = x[1] - 0.5
f = as_vector(
(x[0] * sin(5.0 * pi * x[1]) + 1.0 * exp(-(dx_ * dx_ + dy_ * dy_) / 0.02),
def ref_elasticity(tetra: bool = True, r_lvl: int = 0, out_hdf5: h5py.File = None,
xdmf: bool = False, boomeramg: bool = False, kspview: bool = False, degree: int = 1):
if tetra:
N = 3 if degree == 1 else 2
mesh = create_unit_cube(MPI.COMM_WORLD, N, N, N)
else:
N = 3
mesh = create_unit_cube(MPI.COMM_WORLD, N, N, N, CellType.hexahedron)
for i in range(r_lvl):
# set_log_level(LogLevel.INFO)
N *= 2
if tetra:
mesh = refine(mesh, redistribute=True)
else:
mesh = create_unit_cube(MPI.COMM_WORLD, N, N, N, CellType.hexahedron)
# set_log_level(LogLevel.ERROR)
N = degree * N
fdim = mesh.topology.dim - 1
V = VectorFunctionSpace(mesh, ("Lagrange", int(degree)))
# Generate Dirichlet BC on lower boundary (Fixed)
u_bc = Function(V)
with u_bc.vector.localForm() as u_local:
u_local.set(0.0)
def boundaries(x):
return np.isclose(x[0], np.finfo(float).eps)
facets = locate_entities_boundary(mesh, fdim, boundaries)
topological_dofs = locate_dofs_topological(V, fdim, facets)
bc = dirichletbc(u_bc, topological_dofs)
bcs = [bc]
# Create traction meshtag
def traction_boundary(x):
return np.isclose(x[0], 1)
t_facets = locate_entities_boundary(mesh, fdim, traction_boundary)
facet_values = np.ones(len(t_facets), dtype=np.int32)
arg_sort = np.argsort(t_facets)
mt = meshtags(mesh, fdim, t_facets[arg_sort], facet_values[arg_sort])
# Elasticity parameters
E = PETSc.ScalarType(1.0e4)
nu = 0.1
mu = Constant(mesh, E / (2.0 * (1.0 + nu)))
lmbda = Constant(mesh, E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu)))
g = Constant(mesh, PETSc.ScalarType((0, 0, -1e2)))
x = SpatialCoordinate(mesh)
f = Constant(mesh, PETSc.ScalarType(1e4)) * \
as_vector((0, -(x[2] - 0.5)**2, (x[1] - 0.5)**2))
# Stress computation
def sigma(v):
return (2.0 * mu * sym(grad(v)) + lmbda * tr(sym(grad(v))) * Identity(len(v)))
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
a = inner(sigma(u), grad(v)) * dx
rhs = inner(g, v) * ds(domain=mesh, subdomain_data=mt, subdomain_id=1) + inner(f, v) * dx
num_dofs = V.dofmap.index_map.size_global * V.dofmap.index_map_bs
if MPI.COMM_WORLD.rank == 0:
print("Problem size {0:d} ".format(num_dofs))
# Generate reference matrices and unconstrained solution
bilinear_form = form(a)
A_org = assemble_matrix(bilinear_form, bcs)
A_org.assemble()
null_space_org = rigid_motions_nullspace(V)
A_org.setNearNullSpace(null_space_org)
linear_form = form(rhs)
L_org = assemble_vector(linear_form)
apply_lifting(L_org, [bilinear_form], [bcs])
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES, mode=PETSc.ScatterMode.REVERSE)
set_bc(L_org, bcs)
opts = PETSc.Options()
if boomeramg:
opts["ksp_type"] = "cg"
opts["ksp_rtol"] = 1.0e-5
opts["pc_type"] = "hypre"
opts['pc_hypre_type'] = 'boomeramg'
opts["pc_hypre_boomeramg_max_iter"] = 1
opts["pc_hypre_boomeramg_cycle_type"] = "v"
# opts["pc_hypre_boomeramg_print_statistics"] = 1
else:
opts["ksp_rtol"] = 1.0e-8
opts["pc_type"] = "gamg"
opts["pc_gamg_type"] = "agg"
opts["pc_gamg_coarse_eq_limit"] = 1000
opts["pc_gamg_sym_graph"] = True
opts["mg_levels_ksp_type"] = "chebyshev"
opts["mg_levels_pc_type"] = "jacobi"
opts["mg_levels_esteig_ksp_type"] = "cg"
opts["matptap_via"] = "scalable"
opts["pc_gamg_square_graph"] = 2
opts["pc_gamg_threshold"] = 0.02
# opts["help"] = None # List all available options
# opts["ksp_view"] = None # List progress of solver
# Create solver, set operator and options
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setFromOptions()
solver.setOperators(A_org)
# Solve linear problem
u_ = Function(V)
start = perf_counter()
with Timer("Ref solve"):
solver.solve(L_org, u_.vector)
end = perf_counter()
u_.x.scatter_forward()
if kspview:
solver.view()
it = solver.getIterationNumber()
if out_hdf5 is not None:
d_set = out_hdf5.get("its")
d_set[r_lvl] = it
d_set = out_hdf5.get("num_dofs")
d_set[r_lvl] = num_dofs
d_set = out_hdf5.get("solve_time")
d_set[r_lvl, MPI.COMM_WORLD.rank] = end - start
if MPI.COMM_WORLD.rank == 0:
print("Refinement level {0:d}, Iterations {1:d}".format(r_lvl, it))
# List memory usage
mem = sum(MPI.COMM_WORLD.allgather(
resource.getrusage(resource.RUSAGE_SELF).ru_maxrss))
if MPI.COMM_WORLD.rank == 0:
print("{1:d}: Max usage after trad. solve {0:d} (kb)"
.format(mem, r_lvl))
if xdmf:
# Name formatting of functions
u_.name = "u_unconstrained"
fname = "results/ref_elasticity_{0:d}.xdmf".format(r_lvl)
with XDMFFile(MPI.COMM_WORLD, fname, "w") as out_xdmf:
out_xdmf.write_mesh(mesh)
out_xdmf.write_function(u_, 0.0, "Xdmf/Domain/Grid[@Name='{0:s}'][1]".format(mesh.name))
def test_surface_integral_dependency(get_assemblers): # noqa: F811
assemble_matrix, assemble_vector = get_assemblers
N = 10
mesh = create_unit_square(MPI.COMM_WORLD, N, N)
V = fem.VectorFunctionSpace(mesh, ("Lagrange", 1))
def top(x):
return np.isclose(x[1], 1)
fdim = mesh.topology.dim - 1
top_facets = locate_entities_boundary(mesh, fdim, top)
indices = np.array([], dtype=np.intc)
values = np.array([], dtype=np.intc)
markers = {3: top_facets}
for key in markers.keys():
indices = np.append(indices, markers[key])
values = np.append(values, np.full(len(markers[key]), key, dtype=np.intc))
sort = np.argsort(indices)
mt = meshtags(mesh, mesh.topology.dim - 1, np.array(indices[sort], dtype=np.intc),
np.array(values[sort], dtype=np.intc))
ds = ufl.Measure("ds", domain=mesh, subdomain_data=mt)
g = fem.Constant(mesh, PETSc.ScalarType((2, 1)))
h = fem.Constant(mesh, PETSc.ScalarType((3, 2)))
# Define variational problem
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
a = ufl.inner(u, v) * ds(3) + ufl.inner(ufl.grad(u), ufl.grad(v)) * ds
rhs = ufl.inner(g, v) * ds + ufl.inner(h, v) * ds(3)
bilinear_form = fem.form(a)
linear_form = fem.form(rhs)
# Create multipoint constraint and assemble system
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {}
for i in range(1, N):
s_m_c[l2b([1, i / N])] = {l2b([1, 1]): 0.3}
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c, 1, 1)
mpc.finalize()
with Timer("~TEST: Assemble matrix"):
A = assemble_matrix(bilinear_form, mpc)
with Timer("~TEST: Assemble vector"):
b = assemble_vector(linear_form, mpc)
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES, mode=PETSc.ScatterMode.REVERSE)
# Solve the MPC problem using a global transformation matrix
# and numpy solvers to get reference values
# Generate reference matrices and unconstrained solution
A_org = fem.petsc.assemble_matrix(bilinear_form)
A_org.assemble()
L_org = fem.petsc.assemble_vector(linear_form)
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES, mode=PETSc.ScatterMode.REVERSE)
root = 0
comm = mesh.comm
with Timer("~TEST: Compare"):
dolfinx_mpc.utils.compare_mpc_lhs(A_org, A, mpc, root=root)
dolfinx_mpc.utils.compare_mpc_rhs(L_org, b, mpc, root=root)
list_timings(comm, [TimingType.wall])
def assemble_vector(form: _forms, constraint: MultiPointConstraint, b: _PETSc.Vec = None) -> _PETSc.Vec:
"""
Assemble a compiled DOLFINx form into vector b.
Parameters
----------
form
The complied linear form
constraint
The multi point constraint
b
PETSc vector to assemble into (optional)
"""
_log.log(_log.LogLevel.INFO, "Assemble MPC vector")
timer_vector = Timer("~MPC: Assemble vector (numba)")
# Unpack Function space data
V = form.function_spaces[0]
pos = V.mesh.geometry.dofmap.offsets
x_dofs = V.mesh.geometry.dofmap.array
x = V.mesh.geometry.x
dofs = V.dofmap.list().array
block_size = V.dofmap.index_map_bs
# Data from multipointconstraint
coefficients = constraint.coefficients()[0]
masters_adj = constraint.masters
c_to_s_adj = constraint.cell_to_slaves
cell_to_slave = c_to_s_adj.array
c_to_s_off = c_to_s_adj.offsets
is_slave = constraint.is_slave
mpc_data = (masters_adj.array, coefficients, masters_adj.offsets, cell_to_slave, c_to_s_off, is_slave)
slave_cells = extract_slave_cells(c_to_s_off)
# Get index map and ghost info
if b is None:
index_map = constraint.function_space.dofmap.index_map
vector = _cpp.la.petsc.create_vector(index_map, block_size)
else:
vector = b
# Pack constants and coefficients
form_coeffs = _cpp.fem.pack_coefficients(form)
form_consts = _cpp.fem.pack_constants(form)
tdim = V.mesh.topology.dim
num_dofs_per_element = V.dofmap.dof_layout.num_dofs
# Assemble vector with all entries
with vector.localForm() as b_local:
_cpp.fem.assemble_vector(b_local.array_w, form, form_consts, form_coeffs)
# Check if we need facet permutations
# FIXME: access apply_dof_transformations here
e0 = form.function_spaces[0].element
needs_transformation_data = e0.needs_dof_transformations or form.needs_facet_permutations
cell_perms = numpy.array([], dtype=numpy.uint32)
if needs_transformation_data:
V.mesh.topology.create_entity_permutations()
cell_perms = V.mesh.topology.get_cell_permutation_info()
if e0.needs_dof_transformations:
raise NotImplementedError("Dof transformations not implemented")
# Assemble over cells
subdomain_ids = form.integral_ids(_fem.IntegralType.cell)
num_cell_integrals = len(subdomain_ids)
is_complex = numpy.issubdtype(_PETSc.ScalarType, numpy.complexfloating)
nptype = "complex128" if is_complex else "float64"
ufcx_form = form.ufcx_form
if num_cell_integrals > 0:
V.mesh.topology.create_entity_permutations()
for i, id in enumerate(subdomain_ids):
cell_kernel = getattr(ufcx_form.integrals(_fem.IntegralType.cell)[i], f"tabulate_tensor_{nptype}")
active_cells = form.domains(_fem.IntegralType.cell, id)
coeffs_i = form_coeffs[(_fem.IntegralType.cell, id)]
with vector.localForm() as b:
assemble_cells(numpy.asarray(b), cell_kernel, active_cells[numpy.isin(active_cells, slave_cells)],
(pos, x_dofs, x), coeffs_i, form_consts,
cell_perms, dofs, block_size, num_dofs_per_element, mpc_data)
# Assemble exterior facet integrals
subdomain_ids = form.integral_ids(_fem.IntegralType.exterior_facet)
num_exterior_integrals = len(subdomain_ids)
if num_exterior_integrals > 0:
V.mesh.topology.create_entities(tdim - 1)
V.mesh.topology.create_connectivity(tdim - 1, tdim)
# Get facet permutations if required
facet_perms = numpy.array([], dtype=numpy.uint8)
if form.needs_facet_permutations:
facet_perms = V.mesh.topology.get_facet_permutations()
perm = (cell_perms, form.needs_facet_permutations, facet_perms)
for i, id in enumerate(subdomain_ids):
facet_kernel = getattr(ufcx_form.integrals(_fem.IntegralType.exterior_facet)[i],
f"tabulate_tensor_{nptype}")
coeffs_i = form_coeffs[(_fem.IntegralType.exterior_facet, id)]
facets = form.domains(_fem.IntegralType.exterior_facet, id)
facet_info = pack_slave_facet_info(facets, slave_cells)
num_facets_per_cell = len(V.mesh.topology.connectivity(tdim, tdim - 1).links(0))
with vector.localForm() as b:
assemble_exterior_slave_facets(numpy.asarray(b), facet_kernel, facet_info, (pos, x_dofs, x),
coeffs_i, form_consts, perm,
dofs, block_size, num_dofs_per_element, mpc_data, num_facets_per_cell)
timer_vector.stop()
return vector
def test_linearproblem(master_point):
# Create mesh and function space
mesh = create_unit_square(MPI.COMM_WORLD, 3, 5)
V = fem.FunctionSpace(mesh, ("Lagrange", 1))
# Solve Problem without MPC for reference
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
d = fem.Constant(mesh, PETSc.ScalarType(1.5))
c = fem.Constant(mesh, PETSc.ScalarType(2))
x = ufl.SpatialCoordinate(mesh)
f = c * ufl.sin(2 * ufl.pi * x[0]) * ufl.sin(ufl.pi * x[1])
g = fem.Function(V)
g.interpolate(lambda x: np.sin(x[0]) * x[1])
h = fem.Function(V)
h.interpolate(lambda x: 2 + x[1] * x[0])
a = d * g * ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx
rhs = h * ufl.inner(f, v) * ufl.dx
# Generate reference matrices
A_org = fem.petsc.assemble_matrix(fem.form(a))
A_org.assemble()
L_org = fem.petsc.assemble_vector(fem.form(rhs))
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
# Create multipoint constraint
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {
l2b([1, 0]): {
l2b([0, 1]): 0.43,
l2b([1, 1]): 0.11
},
l2b([0, 0]): {
l2b(master_point): 0.69
}
}
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c)
mpc.finalize()
problem = dolfinx_mpc.LinearProblem(a,
rhs,
mpc,
bcs=[],
petsc_options={
"ksp_type": "preonly",
"pc_type": "lu"
})
uh = problem.solve()
root = 0
comm = mesh.comm
with Timer("~TEST: Compare"):
dolfinx_mpc.utils.compare_mpc_lhs(A_org, problem._A, mpc, root=root)
dolfinx_mpc.utils.compare_mpc_rhs(L_org, problem._b, mpc, root=root)
# Gather LHS, RHS and solution on one process
A_csr = dolfinx_mpc.utils.gather_PETScMatrix(A_org, root=root)
K = dolfinx_mpc.utils.gather_transformation_matrix(mpc, root=root)
L_np = dolfinx_mpc.utils.gather_PETScVector(L_org, root=root)
u_mpc = dolfinx_mpc.utils.gather_PETScVector(uh.vector, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc)
list_timings(comm, [TimingType.wall])
def test_cube_contact(generate_hex_boxes, nonslip,
get_assemblers): # noqa: F811
assemble_matrix, assemble_vector = get_assemblers
comm = MPI.COMM_WORLD
root = 0
# Generate mesh
mesh_data = generate_hex_boxes
mesh, mt = mesh_data
fdim = mesh.topology.dim - 1
# Create functionspaces
V = fem.VectorFunctionSpace(mesh, ("Lagrange", 1))
# Helper for orienting traction
# Bottom boundary is fixed in all directions
u_bc = fem.Function(V)
with u_bc.vector.localForm() as u_local:
u_local.set(0.0)
bottom_dofs = fem.locate_dofs_topological(V, fdim, mt.find(5))
bc_bottom = fem.dirichletbc(u_bc, bottom_dofs)
g_vec = [0, 0, -4.25e-1]
if not nonslip:
# Helper for orienting traction
r_matrix = dolfinx_mpc.utils.rotation_matrix(
[1 / np.sqrt(2), 1 / np.sqrt(2), 0], -theta)
# Top boundary has a given deformation normal to the interface
g_vec = np.dot(r_matrix, [0, 0, -4.25e-1])
# Top boundary has a given deformation normal to the interface
def top_v(x):
values = np.empty((3, x.shape[1]))
values[0] = g_vec[0]
values[1] = g_vec[1]
values[2] = g_vec[2]
return values
u_top = fem.Function(V)
u_top.interpolate(top_v)
top_dofs = fem.locate_dofs_topological(V, fdim, mt.find(3))
bc_top = fem.dirichletbc(u_top, top_dofs)
bcs = [bc_bottom, bc_top]
# Elasticity parameters
E = PETSc.ScalarType(1.0e3)
nu = 0
mu = fem.Constant(mesh, E / (2.0 * (1.0 + nu)))
lmbda = fem.Constant(mesh, E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu)))
# Stress computation
def sigma(v):
return (2.0 * mu * ufl.sym(ufl.grad(v)) +
lmbda * ufl.tr(ufl.sym(ufl.grad(v))) * ufl.Identity(len(v)))
# Define variational problem
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
a = ufl.inner(sigma(u), ufl.grad(v)) * ufl.dx
rhs = ufl.inner(fem.Constant(mesh, PETSc.ScalarType(
(0, 0, 0))), v) * ufl.dx
bilinear_form = fem.form(a)
linear_form = fem.form(rhs)
# Create LU solver
solver = PETSc.KSP().create(comm)
solver.setType("preonly")
solver.setTolerances(rtol=1.0e-14)
solver.getPC().setType("lu")
# Create MPC contact condition and assemble matrices
mpc = dolfinx_mpc.MultiPointConstraint(V)
if nonslip:
with Timer("~Contact: Create non-elastic constraint"):
mpc.create_contact_inelastic_condition(mt, 4, 9)
else:
with Timer("~Contact: Create contact constraint"):
nh = dolfinx_mpc.utils.create_normal_approximation(V, mt, 4)
mpc.create_contact_slip_condition(mt, 4, 9, nh)
mpc.finalize()
with Timer("~TEST: Assemble bilinear form"):
A = assemble_matrix(bilinear_form, mpc, bcs=bcs)
with Timer("~TEST: Assemble vector"):
b = assemble_vector(linear_form, mpc)
dolfinx_mpc.apply_lifting(b, [bilinear_form], [bcs], mpc)
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
fem.petsc.set_bc(b, bcs)
with Timer("~MPC: Solve"):
solver.setOperators(A)
uh = b.copy()
uh.set(0)
solver.solve(b, uh)
uh.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
mpc.backsubstitution(uh)
# Write solution to file
# u_h = fem.Function(mpc.function_space)
# u_h.vector.setArray(uh.array)
# u_h.x.scatter_forward()
# u_h.name = "u_{0:.2f}".format(theta)
# import dolfinx.io as io
# with io.XDMFFile(comm, "output/rotated_cube3D.xdmf", "w") as outfile:
# outfile.write_mesh(mesh)
# outfile.write_function(u_h, 0.0, f"Xdmf/Domain/Grid[@Name='{mesh.name}'][1]")
# Solve the MPC problem using a global transformation matrix
# and numpy solvers to get reference values
dolfinx_mpc.utils.log_info(
"Solving reference problem with global matrix (using numpy)")
with Timer("~TEST: Assemble bilinear form (unconstrained)"):
A_org = fem.petsc.assemble_matrix(bilinear_form, bcs)
A_org.assemble()
L_org = fem.petsc.assemble_vector(linear_form)
fem.petsc.apply_lifting(L_org, [bilinear_form], [bcs])
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
fem.petsc.set_bc(L_org, bcs)
with Timer("~TEST: Compare"):
dolfinx_mpc.utils.compare_mpc_lhs(A_org, A, mpc, root=root)
dolfinx_mpc.utils.compare_mpc_rhs(L_org, b, mpc, root=root)
# Gather LHS, RHS and solution on one process
A_csr = dolfinx_mpc.utils.gather_PETScMatrix(A_org, root=root)
K = dolfinx_mpc.utils.gather_transformation_matrix(mpc, root=root)
L_np = dolfinx_mpc.utils.gather_PETScVector(L_org, root=root)
u_mpc = dolfinx_mpc.utils.gather_PETScVector(uh, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc)
list_timings(comm, [TimingType.wall])
def test_vector_possion(Nx, Ny, slave_space, master_space,
get_assemblers): # noqa: F811
assemble_matrix, assemble_vector = get_assemblers
# Create mesh and function space
mesh = create_unit_square(MPI.COMM_WORLD, Nx, Ny)
V = fem.VectorFunctionSpace(mesh, ("Lagrange", 1))
def boundary(x):
return np.isclose(x.T, [0, 0, 0]).all(axis=1)
# Define boundary conditions (HAS TO BE NON-MASTER NODES)
u_bc = fem.Function(V)
with u_bc.vector.localForm() as u_local:
u_local.set(0.0)
bdofsV = fem.locate_dofs_geometrical(V, boundary)
bc = fem.dirichletbc(u_bc, bdofsV)
bcs = [bc]
# Define variational problem
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
x = ufl.SpatialCoordinate(mesh)
f = ufl.as_vector((-5 * x[1], 7 * x[0]))
a = ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx
rhs = ufl.inner(f, v) * ufl.dx
bilinear_form = fem.form(a)
linear_form = fem.form(rhs)
# Setup LU solver
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setType(PETSc.KSP.Type.PREONLY)
solver.getPC().setType(PETSc.PC.Type.LU)
# Create multipoint constraint
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {l2b([1, 0]): {l2b([1, 1]): 0.1, l2b([0.5, 1]): 0.3}}
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c, slave_space, master_space)
mpc.finalize()
with Timer("~TEST: Assemble matrix"):
A = assemble_matrix(bilinear_form, mpc, bcs=bcs)
with Timer("~TEST: Assemble vector"):
b = dolfinx_mpc.assemble_vector(linear_form, mpc)
dolfinx_mpc.apply_lifting(b, [bilinear_form], [bcs], mpc)
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
fem.petsc.set_bc(b, bcs)
solver.setOperators(A)
uh = b.copy()
uh.set(0)
solver.solve(b, uh)
uh.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
mpc.backsubstitution(uh)
# Generate reference matrices for unconstrained problem
A_org = fem.petsc.assemble_matrix(bilinear_form, bcs)
A_org.assemble()
L_org = fem.petsc.assemble_vector(linear_form)
fem.petsc.apply_lifting(L_org, [bilinear_form], [bcs])
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
fem.petsc.set_bc(L_org, bcs)
root = 0
comm = mesh.comm
with Timer("~TEST: Compare"):
dolfinx_mpc.utils.compare_mpc_lhs(A_org, A, mpc, root=root)
dolfinx_mpc.utils.compare_mpc_rhs(L_org, b, mpc, root=root)
# Gather LHS, RHS and solution on one process
A_csr = dolfinx_mpc.utils.gather_PETScMatrix(A_org, root=root)
K = dolfinx_mpc.utils.gather_transformation_matrix(mpc, root=root)
L_np = dolfinx_mpc.utils.gather_PETScVector(L_org, root=root)
u_mpc = dolfinx_mpc.utils.gather_PETScVector(uh, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc)
list_timings(comm, [TimingType.wall])
def reference_periodic(tetra: bool,
r_lvl: int = 0,
out_hdf5: h5py.File = None,
xdmf: bool = False,
boomeramg: bool = False,
kspview: bool = False,
degree: int = 1):
# Create mesh and finite element
if tetra:
# Tet setup
N = 3
mesh = create_unit_cube(MPI.COMM_WORLD, N, N, N)
for i in range(r_lvl):
mesh.topology.create_entities(mesh.topology.dim - 2)
mesh = refine(mesh, redistribute=True)
N *= 2
else:
# Hex setup
N = 3
for i in range(r_lvl):
N *= 2
mesh = create_unit_cube(MPI.COMM_WORLD, N, N, N, CellType.hexahedron)
V = FunctionSpace(mesh, ("CG", degree))
# Create Dirichlet boundary condition
def dirichletboundary(x):
return np.logical_or(
np.logical_or(np.isclose(x[1], 0), np.isclose(x[1], 1)),
np.logical_or(np.isclose(x[2], 0), np.isclose(x[2], 1)))
mesh.topology.create_connectivity(2, 1)
geometrical_dofs = locate_dofs_geometrical(V, dirichletboundary)
bc = dirichletbc(PETSc.ScalarType(0), geometrical_dofs, V)
bcs = [bc]
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
a = inner(grad(u), grad(v)) * dx
x = SpatialCoordinate(mesh)
dx_ = x[0] - 0.9
dy_ = x[1] - 0.5
dz_ = x[2] - 0.1
f = x[0] * sin(5.0 * pi * x[1]) + 1.0 * exp(
-(dx_ * dx_ + dy_ * dy_ + dz_ * dz_) / 0.02)
rhs = inner(f, v) * dx
# Assemble rhs, RHS and apply lifting
bilinear_form = form(a)
linear_form = form(rhs)
A_org = assemble_matrix(bilinear_form, bcs)
A_org.assemble()
L_org = assemble_vector(linear_form)
apply_lifting(L_org, [bilinear_form], [bcs])
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
set_bc(L_org, bcs)
# Create PETSc nullspace
nullspace = PETSc.NullSpace().create(constant=True)
PETSc.Mat.setNearNullSpace(A_org, nullspace)
# Set PETSc options
opts = PETSc.Options()
if boomeramg:
opts["ksp_type"] = "cg"
opts["ksp_rtol"] = 1.0e-5
opts["pc_type"] = "hypre"
opts['pc_hypre_type'] = 'boomeramg'
opts["pc_hypre_boomeramg_max_iter"] = 1
opts["pc_hypre_boomeramg_cycle_type"] = "v"
# opts["pc_hypre_boomeramg_print_statistics"] = 1
else:
opts["ksp_type"] = "cg"
opts["ksp_rtol"] = 1.0e-12
opts["pc_type"] = "gamg"
opts["pc_gamg_type"] = "agg"
opts["pc_gamg_sym_graph"] = True
# Use Chebyshev smoothing for multigrid
opts["mg_levels_ksp_type"] = "richardson"
opts["mg_levels_pc_type"] = "sor"
# opts["help"] = None # List all available options
# opts["ksp_view"] = None # List progress of solver
# Initialize PETSc solver, set options and operator
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setFromOptions()
solver.setOperators(A_org)
# Solve linear problem
u_ = Function(V)
start = perf_counter()
with Timer("Solve"):
solver.solve(L_org, u_.vector)
end = perf_counter()
u_.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
if kspview:
solver.view()
it = solver.getIterationNumber()
num_dofs = V.dofmap.index_map.size_global * V.dofmap.index_map_bs
if out_hdf5 is not None:
d_set = out_hdf5.get("its")
d_set[r_lvl] = it
d_set = out_hdf5.get("num_dofs")
d_set[r_lvl] = num_dofs
d_set = out_hdf5.get("solve_time")
d_set[r_lvl, MPI.COMM_WORLD.rank] = end - start
if MPI.COMM_WORLD.rank == 0:
print("Rlvl {0:d}, Iterations {1:d}".format(r_lvl, it))
# Output solution to XDMF
if xdmf:
ext = "tet" if tetra else "hex"
fname = "results/reference_periodic_{0:d}_{1:s}.xdmf".format(
r_lvl, ext)
u_.name = "u_" + ext + "_unconstrained"
with XDMFFile(MPI.COMM_WORLD, fname, "w") as out_periodic:
out_periodic.write_mesh(mesh)
out_periodic.write_function(
u_, 0.0,
"Xdmf/Domain/" + "Grid[@Name='{0:s}'][1]".format(mesh.name))
def demo_periodic3D(celltype: CellType):
# Create mesh and finite element
if celltype == CellType.tetrahedron:
# Tet setup
N = 10
mesh = create_unit_cube(MPI.COMM_WORLD, N, N, N)
V = fem.VectorFunctionSpace(mesh, ("CG", 1))
else:
# Hex setup
N = 10
mesh = create_unit_cube(MPI.COMM_WORLD, N, N, N, CellType.hexahedron)
V = fem.VectorFunctionSpace(mesh, ("CG", 2))
def dirichletboundary(x: NDArray[np.float64]) -> NDArray[np.bool_]:
return np.logical_or(
np.logical_or(np.isclose(x[1], 0), np.isclose(x[1], 1)),
np.logical_or(np.isclose(x[2], 0), np.isclose(x[2], 1)))
# Create Dirichlet boundary condition
zero = PETSc.ScalarType([0, 0, 0])
geometrical_dofs = fem.locate_dofs_geometrical(V, dirichletboundary)
bc = fem.dirichletbc(zero, geometrical_dofs, V)
bcs = [bc]
def PeriodicBoundary(x):
return np.isclose(x[0], 1)
facets = locate_entities_boundary(mesh, mesh.topology.dim - 1,
PeriodicBoundary)
arg_sort = np.argsort(facets)
mt = meshtags(mesh, mesh.topology.dim - 1, facets[arg_sort],
np.full(len(facets), 2, dtype=np.int32))
def periodic_relation(x):
out_x = np.zeros(x.shape)
out_x[0] = 1 - x[0]
out_x[1] = x[1]
out_x[2] = x[2]
return out_x
with Timer("~~Periodic: Compute mpc condition"):
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_periodic_constraint_topological(V.sub(0), mt, 2,
periodic_relation, bcs, 1)
mpc.finalize()
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
a = inner(grad(u), grad(v)) * dx
x = SpatialCoordinate(mesh)
dx_ = x[0] - 0.9
dy_ = x[1] - 0.5
dz_ = x[2] - 0.1
f = as_vector((x[0] * sin(5.0 * pi * x[1]) +
1.0 * exp(-(dx_ * dx_ + dy_ * dy_ + dz_ * dz_) / 0.02),
0.1 * dx_ * dz_, 0.1 * dx_ * dy_))
rhs = inner(f, v) * dx
petsc_options: Dict[str, Union[str, float, int]]
if complex_mode:
rtol = 1e-16
petsc_options = {"ksp_type": "preonly", "pc_type": "lu"}
else:
rtol = 1e-8
petsc_options = {
"ksp_type": "cg",
"ksp_rtol": rtol,
"pc_type": "hypre",
"pc_hypre_typ": "boomeramg",
"pc_hypre_boomeramg_max_iter": 1,
"pc_hypre_boomeramg_cycle_type": "v",
"pc_hypre_boomeramg_print_statistics": 1
}
problem = LinearProblem(a, rhs, mpc, bcs, petsc_options=petsc_options)
u_h = problem.solve()
# --------------------VERIFICATION-------------------------
print("----Verification----")
u_ = fem.Function(V)
u_.x.array[:] = 0
org_problem = fem.petsc.LinearProblem(a,
rhs,
u=u_,
bcs=bcs,
petsc_options=petsc_options)
with Timer("~Periodic: Unconstrained solve"):
org_problem.solve()
it = org_problem.solver.getIterationNumber()
print(f"Unconstrained solver iterations: {it}")
# Write solutions to file
ext = "tet" if celltype == CellType.tetrahedron else "hex"
u_.name = "u_" + ext + "_unconstrained"
# NOTE: Workaround as tabulate dof coordinates does not like extra ghosts
u_out = fem.Function(V)
old_local = u_out.x.map.size_local * u_out.x.bs
old_ghosts = u_out.x.map.num_ghosts * u_out.x.bs
mpc_local = u_h.x.map.size_local * u_h.x.bs
assert (old_local == mpc_local)
u_out.x.array[:old_local + old_ghosts] = u_h.x.array[:mpc_local +
old_ghosts]
u_out.name = "u_" + ext
fname = f"results/demo_periodic3d_{ext}.bp"
out_periodic = VTXWriter(MPI.COMM_WORLD, fname, u_out)
out_periodic.write(0)
out_periodic.close()
root = 0
with Timer("~Demo: Verification"):
dolfinx_mpc.utils.compare_mpc_lhs(org_problem.A,
problem.A,
mpc,
root=root)
dolfinx_mpc.utils.compare_mpc_rhs(org_problem.b,
problem.b,
mpc,
root=root)
# Gather LHS, RHS and solution on one process
A_csr = dolfinx_mpc.utils.gather_PETScMatrix(org_problem.A, root=root)
K = dolfinx_mpc.utils.gather_transformation_matrix(mpc, root=root)
L_np = dolfinx_mpc.utils.gather_PETScVector(org_problem.b, root=root)
u_mpc = dolfinx_mpc.utils.gather_PETScVector(u_h.vector, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc, rtol=rtol)
def bench_elasticity_one(r_lvl: int = 0,
out_hdf5: h5py.File = None,
xdmf: bool = False,
boomeramg: bool = False,
kspview: bool = False):
N = 3
mesh = create_unit_cube(MPI.COMM_WORLD, N, N, N)
for i in range(r_lvl):
mesh.topology.create_entities(mesh.topology.dim - 2)
mesh = refine(mesh, redistribute=True)
fdim = mesh.topology.dim - 1
V = VectorFunctionSpace(mesh, ("Lagrange", 1))
# Generate Dirichlet BC on lower boundary (Fixed)
u_bc = Function(V)
with u_bc.vector.localForm() as u_local:
u_local.set(0.0)
def boundaries(x):
return np.isclose(x[0], np.finfo(float).eps)
facets = locate_entities_boundary(mesh, fdim, boundaries)
topological_dofs = locate_dofs_topological(V, fdim, facets)
bc = dirichletbc(u_bc, topological_dofs)
bcs = [bc]
# Create traction meshtag
def traction_boundary(x):
return np.isclose(x[0], 1)
t_facets = locate_entities_boundary(mesh, fdim, traction_boundary)
facet_values = np.ones(len(t_facets), dtype=np.int32)
arg_sort = np.argsort(t_facets)
mt = meshtags(mesh, fdim, t_facets[arg_sort], facet_values[arg_sort])
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
# Elasticity parameters
E = 1.0e4
nu = 0.1
mu = Constant(mesh, E / (2.0 * (1.0 + nu)))
lmbda = Constant(mesh, E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu)))
g = Constant(mesh, (0, 0, -1e2))
# Stress computation
def sigma(v):
return 2.0 * mu * sym(grad(v)) + lmbda * tr(sym(grad(v))) * Identity(
len(v))
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
a = inner(sigma(u), grad(v)) * dx
rhs = inner(g, v) * ds(domain=mesh, subdomain_data=mt, subdomain_id=1)
# Create MPC
with Timer("~Elasticity: Init constraint"):
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {l2b([1, 0, 0]): {l2b([1, 0, 1]): 0.5}}
mpc = MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c, 2, 2)
mpc.finalize()
# Setup MPC system
bilinear_form = form(a)
linear_form = form(rhs)
with Timer("~Elasticity: Assemble LHS and RHS"):
A = assemble_matrix(bilinear_form, mpc, bcs=bcs)
b = assemble_vector(linear_form, mpc)
# Apply boundary conditions
apply_lifting(b, [bilinear_form], [bcs], mpc)
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
set_bc(b, bcs)
# Create functionspace and function for mpc vector
# Solve Linear problem
solver = PETSc.KSP().create(MPI.COMM_WORLD)
opts = PETSc.Options()
if boomeramg:
opts["ksp_type"] = "cg"
opts["ksp_rtol"] = 1.0e-5
opts["pc_type"] = "hypre"
opts['pc_hypre_type'] = 'boomeramg'
opts["pc_hypre_boomeramg_max_iter"] = 1
opts["pc_hypre_boomeramg_cycle_type"] = "v"
# opts["pc_hypre_boomeramg_print_statistics"] = 1
else:
opts["ksp_rtol"] = 1.0e-10
opts["pc_type"] = "gamg"
opts["pc_gamg_type"] = "agg"
opts["pc_gamg_coarse_eq_limit"] = 1000
opts["pc_gamg_sym_graph"] = True
opts["mg_levels_ksp_type"] = "chebyshev"
opts["mg_levels_pc_type"] = "jacobi"
opts["mg_levels_esteig_ksp_type"] = "cg"
opts["matptap_via"] = "scalable"
# opts["help"] = None # List all available options
# opts["ksp_view"] = None # List progress of solver
with Timer("~Elasticity: Solve problem") as timer:
null_space = rigid_motions_nullspace(mpc.function_space)
A.setNearNullSpace(null_space)
solver.setFromOptions()
solver.setOperators(A)
# Solve linear problem
uh = b.copy()
uh.set(0)
solver.solve(b, uh)
uh.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
mpc.backsubstitution(uh)
solver_time = timer.elapsed()
it = solver.getIterationNumber()
if kspview:
solver.view()
# Print max usage of summary
mem = sum(
MPI.COMM_WORLD.allgather(
resource.getrusage(resource.RUSAGE_SELF).ru_maxrss))
num_dofs = V.dofmap.index_map.size_global * V.dofmap.index_map_bs
if MPI.COMM_WORLD.rank == 0:
print(f"Rlvl {r_lvl}, Iterations {it}")
print(f"Rlvl {r_lvl}, Max usage {mem} (kb), #dofs {num_dofs}")
if out_hdf5 is not None:
d_set = out_hdf5.get("its")
d_set[r_lvl] = it
d_set = out_hdf5.get("num_dofs")
d_set[r_lvl] = num_dofs
d_set = out_hdf5.get("solve_time")
d_set[r_lvl, MPI.COMM_WORLD.rank] = solver_time[0]
if xdmf:
# Write solution to file
u_h = Function(mpc.function_space)
u_h.vector.setArray(uh.array)
u_h.name = "u_mpc"
fname = f"results/bench_elasticity_{r_lvl}.xdmf"
with XDMFFile(MPI.COMM_WORLD, fname, "w") as outfile:
outfile.write_mesh(mesh)
outfile.write_function(u_h)