encoding=dolfinx.cpp.io.XDMFFile.Encoding.ASCII)
mesh = infile.read_mesh(name="Grid")
infile.close()
# Stress (Se) and displacement (Ue) elements
Se = ufl.TensorElement("DG", mesh.ufl_cell(), 1, symmetry=True)
Ue = ufl.VectorElement("CG", mesh.ufl_cell(), 2)
S = dolfinx.FunctionSpace(mesh, Se)
U = dolfinx.FunctionSpace(mesh, Ue)
# Get local dofmap sizes for later local tensor tabulations
Ssize = S.dolfin_element().space_dimension()
Usize = U.dolfin_element().space_dimension()
sigma, tau = ufl.TrialFunction(S), ufl.TestFunction(S)
u, v = ufl.TrialFunction(U), ufl.TestFunction(U)
def free_end(x):
"""Marks the leftmost points of the cantilever"""
return numpy.isclose(x[0], 48.0)
def left(x):
"""Marks left part of boundary, where cantilever is attached to wall"""
return numpy.isclose(x[0], 0.0)
# Locate all facets at the free end and assign them value 1
free_end_facets = locate_entities_boundary(mesh, 1, free_end)
def test_assembly_ds_domains(mode):
mesh = dolfinx.generation.UnitSquareMesh(MPI.COMM_WORLD, 10, 10, ghost_mode=mode)
V = dolfinx.FunctionSpace(mesh, ("CG", 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
def bottom(x):
return numpy.isclose(x[1], 0.0)
def top(x):
return numpy.isclose(x[1], 1.0)
def left(x):
return numpy.isclose(x[0], 0.0)
def right(x):
return numpy.isclose(x[0], 1.0)
bottom_facets = locate_entities_boundary(mesh, mesh.topology.dim - 1, bottom)
bottom_vals = numpy.full(bottom_facets.shape, 1, numpy.intc)
top_facets = locate_entities_boundary(mesh, mesh.topology.dim - 1, top)
top_vals = numpy.full(top_facets.shape, 2, numpy.intc)
left_facets = locate_entities_boundary(mesh, mesh.topology.dim - 1, left)
left_vals = numpy.full(left_facets.shape, 3, numpy.intc)
right_facets = locate_entities_boundary(mesh, mesh.topology.dim - 1, right)
right_vals = numpy.full(right_facets.shape, 6, numpy.intc)
indices = numpy.hstack((bottom_facets, top_facets, left_facets, right_facets))
values = numpy.hstack((bottom_vals, top_vals, left_vals, right_vals))
indices, pos = numpy.unique(indices, return_index=True)
marker = dolfinx.mesh.MeshTags(mesh, mesh.topology.dim - 1, indices, values[pos])
ds = ufl.Measure('ds', subdomain_data=marker, domain=mesh)
w = dolfinx.Function(V)
with w.vector.localForm() as w_local:
w_local.set(0.5)
# Assemble matrix
a = w * ufl.inner(u, v) * (ds(1) + ds(2) + ds(3) + ds(6))
A = dolfinx.fem.assemble_matrix(a)
A.assemble()
norm1 = A.norm()
a2 = w * ufl.inner(u, v) * ds
A2 = dolfinx.fem.assemble_matrix(a2)
A2.assemble()
norm2 = A2.norm()
assert norm1 == pytest.approx(norm2, 1.0e-12)
# Assemble vector
L = ufl.inner(w, v) * (ds(1) + ds(2) + ds(3) + ds(6))
b = dolfinx.fem.assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
L2 = ufl.inner(w, v) * ds
b2 = dolfinx.fem.assemble_vector(L2)
b2.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
assert b.norm() == pytest.approx(b2.norm(), 1.0e-12)
# Assemble scalar
L = w * (ds(1) + ds(2) + ds(3) + ds(6))
s = dolfinx.fem.assemble_scalar(L)
s = mesh.mpi_comm().allreduce(s, op=MPI.SUM)
L2 = w * ds
s2 = dolfinx.fem.assemble_scalar(L2)
s2 = mesh.mpi_comm().allreduce(s2, op=MPI.SUM)
assert (s == pytest.approx(s2, 1.0e-12) and 2.0 == pytest.approx(s, 1.0e-12))
def σ(v):
"""Return an expression for the stress σ given a displacement field"""
return 2.0 * μ * ufl.sym(grad(v)) + λ * ufl.tr(ufl.sym(
grad(v))) * ufl.Identity(len(v))
# -
# A function space space is created and the elasticity variational
# problem defined:
V = VectorFunctionSpace(msh, ("Lagrange", 1))
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
a = form(inner(σ(u), grad(v)) * dx)
L = form(inner(f, v) * dx)
# A homogeneous (zero) boundary condition is created on $x_0 = 0$ and
# $x_1 = 1$ by finding all boundary facets on $x_0 = 0$ and # $x_1 = 1$,
# and then creating a Dirichlet boundary condition object.
facets = locate_entities_boundary(
msh,
dim=2,
marker=lambda x: np.logical_or(np.isclose(x[0], 0.0), np.isclose(
x[1], 1.0)))
bc = dirichletbc(np.zeros(3, dtype=dtype),
locate_dofs_topological(V, entity_dim=2, entities=facets),
V=V)
def dg_injection_kernel(Vf, Vc, ncell):
from firedrake import Tensor, AssembledVector, TestFunction, TrialFunction
from firedrake.slate.slac import compile_expression
macro_builder = MacroKernelBuilder(ScalarType_c, ncell)
f = ufl.Coefficient(Vf)
macro_builder.set_coefficients([f])
macro_builder.set_coordinates(Vf.mesh())
Vfe = create_element(Vf.ufl_element())
macro_quadrature_rule = make_quadrature(Vfe.cell, estimate_total_polynomial_degree(ufl.inner(f, f)))
index_cache = {}
parameters = default_parameters()
integration_dim, entity_ids = lower_integral_type(Vfe.cell, "cell")
macro_cfg = dict(interface=macro_builder,
ufl_cell=Vf.ufl_cell(),
precision=parameters["precision"],
integration_dim=integration_dim,
entity_ids=entity_ids,
index_cache=index_cache,
quadrature_rule=macro_quadrature_rule,
complex_mode=complex_mode)
fexpr, = fem.compile_ufl(f, **macro_cfg)
X = ufl.SpatialCoordinate(Vf.mesh())
C_a, = fem.compile_ufl(X, **macro_cfg)
detJ = ufl_utils.preprocess_expression(abs(ufl.JacobianDeterminant(f.ufl_domain())),
complex_mode=complex_mode)
macro_detJ, = fem.compile_ufl(detJ, **macro_cfg)
Vce = create_element(Vc.ufl_element())
coarse_builder = firedrake_interface.KernelBuilder("cell", "otherwise", 0, ScalarType_c)
coarse_builder.set_coordinates(Vc.mesh())
argument_multiindices = (Vce.get_indices(), )
argument_multiindex, = argument_multiindices
return_variable, = coarse_builder.set_arguments((ufl.TestFunction(Vc), ), argument_multiindices)
integration_dim, entity_ids = lower_integral_type(Vce.cell, "cell")
# Midpoint quadrature for jacobian on coarse cell.
quadrature_rule = make_quadrature(Vce.cell, 0)
coarse_cfg = dict(interface=coarse_builder,
ufl_cell=Vc.ufl_cell(),
precision=parameters["precision"],
integration_dim=integration_dim,
entity_ids=entity_ids,
index_cache=index_cache,
quadrature_rule=quadrature_rule,
complex_mode=complex_mode)
X = ufl.SpatialCoordinate(Vc.mesh())
K = ufl_utils.preprocess_expression(ufl.JacobianInverse(Vc.mesh()),
complex_mode=complex_mode)
C_0, = fem.compile_ufl(X, **coarse_cfg)
K, = fem.compile_ufl(K, **coarse_cfg)
i = gem.Index()
j = gem.Index()
C_0 = gem.Indexed(C_0, (j, ))
C_0 = gem.index_sum(C_0, quadrature_rule.point_set.indices)
C_a = gem.Indexed(C_a, (j, ))
X_a = gem.Sum(C_0, gem.Product(gem.Literal(-1), C_a))
K_ij = gem.Indexed(K, (i, j))
K_ij = gem.index_sum(K_ij, quadrature_rule.point_set.indices)
X_a = gem.index_sum(gem.Product(K_ij, X_a), (j, ))
C_0, = quadrature_rule.point_set.points
C_0 = gem.Indexed(gem.Literal(C_0), (i, ))
# fine quad points in coarse reference space.
X_a = gem.Sum(C_0, gem.Product(gem.Literal(-1), X_a))
X_a = gem.ComponentTensor(X_a, (i, ))
# Coarse basis function evaluated at fine quadrature points
phi_c = fem.fiat_to_ufl(Vce.point_evaluation(0, X_a, (Vce.cell.get_dimension(), 0)), 0)
tensor_indices = tuple(gem.Index(extent=d) for d in f.ufl_shape)
phi_c = gem.Indexed(phi_c, argument_multiindex + tensor_indices)
fexpr = gem.Indexed(fexpr, tensor_indices)
quadrature_weight = macro_quadrature_rule.weight_expression
expr = gem.Product(gem.IndexSum(gem.Product(phi_c, fexpr), tensor_indices),
gem.Product(macro_detJ, quadrature_weight))
quadrature_indices = macro_builder.indices + macro_quadrature_rule.point_set.indices
reps = spectral.Integrals([expr], quadrature_indices, argument_multiindices, parameters)
assignments = spectral.flatten([(return_variable, reps)], index_cache)
return_variables, expressions = zip(*assignments)
expressions = impero_utils.preprocess_gem(expressions, **spectral.finalise_options)
assignments = list(zip(return_variables, expressions))
impero_c = impero_utils.compile_gem(assignments, quadrature_indices + argument_multiindex,
remove_zeros=True)
index_names = []
def name_index(index, name):
index_names.append((index, name))
if index in index_cache:
for multiindex, suffix in zip(index_cache[index],
string.ascii_lowercase):
name_multiindex(multiindex, name + suffix)
def name_multiindex(multiindex, name):
if len(multiindex) == 1:
name_index(multiindex[0], name)
else:
for i, index in enumerate(multiindex):
name_index(index, name + str(i))
name_multiindex(quadrature_indices, 'ip')
for multiindex, name in zip(argument_multiindices, ['j', 'k']):
name_multiindex(multiindex, name)
index_names.extend(zip(macro_builder.indices, ["entity"]))
body = generate_coffee(impero_c, index_names, parameters["precision"], ScalarType_c)
retarg = ast.Decl(ScalarType_c, ast.Symbol("R", rank=(Vce.space_dimension(), )))
local_tensor = coarse_builder.local_tensor
local_tensor.init = ast.ArrayInit(numpy.zeros(Vce.space_dimension(), dtype=ScalarType_c))
body.children.insert(0, local_tensor)
args = [retarg] + macro_builder.kernel_args + [macro_builder.coordinates_arg,
coarse_builder.coordinates_arg]
# Now we have the kernel that computes <f, phi_c>dx_c
# So now we need to hit it with the inverse mass matrix on dx_c
u = TrialFunction(Vc)
v = TestFunction(Vc)
expr = Tensor(ufl.inner(u, v)*ufl.dx).inv * AssembledVector(ufl.Coefficient(Vc))
Ainv, = compile_expression(expr)
Ainv = Ainv.kinfo.kernel
A = ast.Symbol(local_tensor.sym.symbol)
R = ast.Symbol("R")
body.children.append(ast.FunCall(Ainv.name, R, coarse_builder.coordinates_arg.sym, A))
from coffee.base import Node
assert isinstance(Ainv._code, Node)
return op2.Kernel(ast.Node([Ainv._code,
ast.FunDecl("void", "pyop2_kernel_injection_dg", args, body,
pred=["static", "inline"])]),
name="pyop2_kernel_injection_dg",
cpp=True,
include_dirs=Ainv._include_dirs,
headers=Ainv._headers)
del dof_dict_i
uD_i = dolfinx.Function(V_i)
uD_i.interpolate(lambda x: 1 + x[0]**2 + 2 * x[1]**2)
uD_i.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
fdim_i = mesh_i.topology.dim - 1
mesh_i.topology.create_connectivity(fdim_i, mesh_i.topology.dim)
boundary_facets_i = np.where(
np.array(dolfinx.cpp.mesh.compute_boundary_facets(mesh_i.topology)) ==
1)[0]
boundary_dofs_i = dolfinx.fem.locate_dofs_topological(
V_i, fdim_i, boundary_facets_i)
bc_i = dolfinx.DirichletBC(uD_i, boundary_dofs_i)
u_i = ufl.TrialFunction(V_i)
v_i = ufl.TestFunction(V_i)
f_i = dolfinx.Constant(mesh_i, -6)
a_i = ufl.dot(ufl.grad(u_i), ufl.grad(v_i)) * ufl.dx
A_i = dolfinx.fem.assemble_matrix(a_i, bcs=[bc_i])
A_i.assemble()
assert isinstance(A_i, PETSc.Mat)
ai, aj, av = A_i.getValuesCSR()
A_sp_i = scp.sparse.csr_matrix((av, aj, ai))
del A_i, av, ai, aj
# Stores the Sparse version of the Stiffness Matrices
A_sp_dict[i] = (A_sp_i, i)
L_i = f_i * v_i * ufl.dx
b_i = dolfinx.fem.create_vector(L_i)
with b_i.localForm() as loc_b:
loc_b.set(0)
dolfinx.fem.assemble_vector(b_i, L_i)