def check(mesh, edges):
"""Compute the physical coordinates of the dofs on the given local edges"""
V = FunctionSpace(mesh, ("Lagrange", 3))
assert len(edges) == 2
dofmap = V.dofmap()
dofs = [dofmap.cell_dofs(c) for c in range(len(edges))]
edge_dofs_local = [dofmap.tabulate_entity_dofs(1, e) for e in edges]
for edofs in edge_dofs_local:
assert len(edofs) == 2
edge_dofs = [dofs[0][edge_dofs_local[0]], dofs[1][edge_dofs_local[1]]]
assert set(edge_dofs[0]) == set(edge_dofs[1])
X = V.element().dof_reference_coordinates()
coord_dofs = mesh.coordinate_dofs().entity_points()
x_g = mesh.geometry.points
x_dofs = []
cmap = fem.create_coordinate_map(mesh.ufl_domain())
for c in range(len(edges)):
x_coord_new = np.zeros([3, 2])
for v in range(3):
x_coord_new[v] = x_g[coord_dofs[c, v], :2]
x = X.copy()
cmap.compute_physical_coordinates(x, X, x_coord_new)
x_dofs.append(x[edge_dofs_local[c]])
return x_dofs
def test_pointsource_mixed_space(mesh, point):
"""Tests point source when given constructor PointSource(V, point,
mag) with a vector for a mixed function space that isn't placed at
a node for 1D, 2D and 3D. Global points given to constructor from
rank 0 processor.
"""
rank = MPI.rank(mesh.mpi_comm())
ele1 = FiniteElement("CG", mesh.ufl_cell(), 1)
ele2 = FiniteElement("DG", mesh.ufl_cell(), 2)
ele3 = VectorElement("CG", mesh.ufl_cell(), 2)
V = FunctionSpace(mesh, MixedElement([ele1, ele2, ele3]))
value_dimension = V.element().value_dimension(0)
v = TestFunction(V)
b = assemble(dot(Constant([0.0] * value_dimension), v) * dx)
if rank == 0:
ps = PointSource(V, point, 10.0)
else:
ps = PointSource(V, [])
ps.apply(b)
# Checks array sums to correct value
b_sum = b.sum()
assert round(b_sum - 10.0 * value_dimension) == 0
def test_pointsource_mixed_space(mesh, point):
"""Tests point source when given constructor PointSource(V, point,
mag) with a vector for a mixed function space that isn't placed at
a node for 1D, 2D and 3D. Global points given to constructor from
rank 0 processor.
"""
rank = MPI.rank(mesh.mpi_comm())
ele1 = FiniteElement("CG", mesh.ufl_cell(), 1)
ele2 = FiniteElement("DG", mesh.ufl_cell(), 2)
ele3 = VectorElement("CG", mesh.ufl_cell(), 2)
V = FunctionSpace(mesh, MixedElement([ele1, ele2, ele3]))
value_dimension = V.element().value_dimension(0)
v = TestFunction(V)
b = assemble(dot(Constant([0.0]*value_dimension), v)*dx)
if rank == 0:
ps = PointSource(V, point, 10.0)
else:
ps = PointSource(V, [])
ps.apply(b)
# Checks array sums to correct value
b_sum = b.sum()
assert round(b_sum - 10.0*value_dimension) == 0
def test_simplex(self):
print('\n== Testing DOFs ====')
for dim, p in itertools.product([2, 3], range(1, 6)):
print('dim={}; p={}'.format(dim, p))
mesh = get_reference_element(dim)
W = FunctionSpace(mesh, "DG", p)
cell = Cell(mesh, 0)
dofs = W.element().tabulate_dof_coordinates(cell)
dofs2 = get_dof_coordinates(dim, pol_order=p)
dofs = dofs[np.lexsort(dofs.T)]
dofs2 = dofs2[np.lexsort(dofs2.T)]
self.assertAlmostEqual(0,
np.linalg.norm(dofs - dofs2),
delta=1e-14)
self.assertAlmostEqual(W.element().space_dimension(),
dimP(dim, p),
delta=1e-13)
print('...ok')
print('saving the matrices...')
savemat(filen_data,
dict(A=A, B0=B0, A_T=A_T),
do_compression=True)
else:
data = loadmat(filen_data)
A = data['A']
A_T = data['A_T']
B0 = data['B0']
mem_eff = mesh.num_cells() * A_T[0].size / mem_sparse(A)
com_eff = (2 * (nnz(B0) - ones(B0)) * mesh.num_cells() +
mesh.num_cells() * A_T[0].size) / nnz(A)
mem_Aloc = V.element().space_dimension()**2
print(
'[Ne, p, mem_sparse(A), mem_Aloc, nnz(A_T[0]), nnz(B0), mem_eff, com_eff]'
)
for val in [
Ne, p,
mem_sparse(A), mem_Aloc,
mesh.num_cells() * A_T[0].size, A_T[0].size,
nnz(B0), mem_eff, com_eff
]:
if isinstance(val, int):
ss += ' {:,} &'.format(val)
elif isinstance(val, float):
ss += ' %.2f &' % val
ss = ss[:-1]
ss += ' \\\\ \n'
