def test_sub_constant_bc(mesh_factory):
"""Test that setting a dirichletbc with on a component of a vector
valued function yields the same result as setting it with a
function"""
func, args = mesh_factory
mesh = func(*args)
tdim = mesh.topology.dim
V = VectorFunctionSpace(mesh, ("Lagrange", 1))
c = Constant(mesh, PETSc.ScalarType(3.14))
boundary_facets = locate_entities_boundary(
mesh, tdim - 1, lambda x: np.ones(x.shape[1], dtype=bool))
for i in range(V.num_sub_spaces):
Vi = V.sub(i).collapse()[0]
u_bci = Function(Vi)
u_bci.x.array[:] = PETSc.ScalarType(c.value)
boundary_dofsi = locate_dofs_topological((V.sub(i), Vi), tdim - 1,
boundary_facets)
bc_fi = dirichletbc(u_bci, boundary_dofsi, V.sub(i))
boundary_dofs = locate_dofs_topological(V.sub(i), tdim - 1,
boundary_facets)
bc_c = dirichletbc(c, boundary_dofs, V.sub(i))
u_f = Function(V)
set_bc(u_f.vector, [bc_fi])
u_c = Function(V)
set_bc(u_c.vector, [bc_c])
assert np.allclose(u_f.vector.array, u_c.vector.array)
def test_vector_constant_bc(mesh_factory):
"""Test that setting a dirichletbc with a vector valued constant
yields the same result as setting it with a function"""
func, args = mesh_factory
mesh = func(*args)
tdim = mesh.topology.dim
V = VectorFunctionSpace(mesh, ("Lagrange", 1))
assert V.num_sub_spaces == mesh.geometry.dim
c = np.arange(1, mesh.geometry.dim + 1, dtype=PETSc.ScalarType)
boundary_facets = locate_entities_boundary(
mesh, tdim - 1, lambda x: np.ones(x.shape[1], dtype=bool))
# Set using sub-functions
Vs = [V.sub(i).collapse()[0] for i in range(V.num_sub_spaces)]
boundary_dofs = [
locate_dofs_topological((V.sub(i), Vs[i]), tdim - 1, boundary_facets)
for i in range(len(Vs))
]
u_bcs = [Function(Vs[i]) for i in range(len(Vs))]
bcs_f = []
for i, u in enumerate(u_bcs):
u_bcs[i].x.array[:] = c[i]
bcs_f.append(dirichletbc(u_bcs[i], boundary_dofs[i], V.sub(i)))
u_f = Function(V)
set_bc(u_f.vector, bcs_f)
# Set using constant
boundary_dofs = locate_dofs_topological(V, tdim - 1, boundary_facets)
bc_c = dirichletbc(c, boundary_dofs, V)
u_c = Function(V)
u_c.x.array[:] = 0.0
set_bc(u_c.vector, [bc_c])
assert np.allclose(u_f.x.array, u_c.x.array)
def amg_solve(N, method):
# Elasticity parameters
E = 1.0e9
nu = 0.3
mu = E / (2.0 * (1.0 + nu))
lmbda = 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(2)
# Define problem
mesh = create_unit_square(MPI.COMM_WORLD, N, N)
V = VectorFunctionSpace(mesh, 'Lagrange', 1)
u = TrialFunction(V)
v = TestFunction(V)
facetdim = mesh.topology.dim - 1
bndry_facets = locate_entities_boundary(
mesh, facetdim, lambda x: np.full(x.shape[1], True))
bdofs = locate_dofs_topological(V.sub(0), V, facetdim, bndry_facets)
bc = dirichletbc(PETSc.ScalarType(0), bdofs, V.sub(0))
# Forms
a, L = inner(sigma(u), grad(v)) * dx, dot(ufl.as_vector(
(1.0, 1.0)), v) * dx
# Assemble linear algebra objects
A = assemble_matrix(a, [bc])
A.assemble()
b = assemble_vector(L)
apply_lifting(b, [a], [[bc]])
b.ghostUpdate(addv=PETSc.InsertMode.ADD,
mode=PETSc.ScatterMode.REVERSE)
set_bc(b, [bc])
# Create solution function
u = Function(V)
# Create near null space basis and orthonormalize
null_space = build_nullspace(V, u.vector)
# Attached near-null space to matrix
A.set_near_nullspace(null_space)
# Test that basis is orthonormal
assert null_space.is_orthonormal()
# Create PETSC smoothed aggregation AMG preconditioner, and
# create CG solver
solver = PETSc.KSP().create(mesh.comm)
solver.setType("cg")
# Set matrix operator
solver.setOperators(A)
# Compute solution and return number of iterations
return solver.solve(b, u.vector)
V.dofmap.index_map_bs]
coords = x[local_dofs]
num_nodes = len(coords)
glob_num_nodes = MPI.COMM_WORLD.allreduce(num_nodes, op=MPI.SUM)
recvbuf = None
if MPI.COMM_WORLD.rank == 0:
recvbuf = np.zeros(3 * glob_num_nodes, dtype=np.float64)
sendbuf = coords.reshape(-1)
sendcounts = np.array(MPI.COMM_WORLD.gather(len(sendbuf), 0))
MPI.COMM_WORLD.Gatherv(sendbuf, (recvbuf, sendcounts), root=0)
glob_coords = MPI.COMM_WORLD.bcast(recvbuf, root=0).reshape((-1, 3))
return glob_coords
# Create pairs of dofs at each boundary
V0, _ = V.sub(0).collapse()
facets_r = locate_entities_boundary(mesh, fdim, lambda x: np.isclose(x[0], 1))
dofs_r = locate_dofs_topological(V0, fdim, facets_r)
facets_l = locate_entities_boundary(mesh, fdim,
lambda x: np.isclose(x[0], 1.1))
dofs_l = locate_dofs_topological(V0, fdim, facets_l)
# Given the local coordinates of the dofs, distribute them on all processors
nodes = [
gather_dof_coordinates(V0, dofs_r),
gather_dof_coordinates(V0, dofs_l)
]
pairs = []
for x in nodes[0]:
for y in nodes[1]: