def callback(self):
"""Finish initialisation."""
del self._callback
if op2.MPI.comm.size > 1:
self._plex.distributeOverlap(1)
self._grown_halos = True
if reorder:
with timed_region("Mesh: reorder"):
old_to_new = self._plex.getOrdering(PETSc.Mat.OrderingType.RCM).indices
reordering = np.empty_like(old_to_new)
reordering[old_to_new] = np.arange(old_to_new.size, dtype=old_to_new.dtype)
else:
# No reordering
reordering = None
self._did_reordering = bool(reorder)
# Mark OP2 entities and derive the resulting Plex renumbering
with timed_region("Mesh: renumbering"):
dmplex.mark_entity_classes(self._plex)
self._entity_classes = dmplex.get_entity_classes(self._plex)
self._plex_renumbering = dmplex.plex_renumbering(self._plex, self._entity_classes, reordering)
with timed_region("Mesh: cell numbering"):
# Derive a cell numbering from the Plex renumbering
entity_dofs = np.zeros(dim + 1, dtype=np.int32)
entity_dofs[-1] = 1
self._cell_numbering = self._plex.createSection([1], entity_dofs, perm=self._plex_renumbering)
entity_dofs[:] = 0
entity_dofs[0] = 1
self._vertex_numbering = self._plex.createSection([1], entity_dofs, perm=self._plex_renumbering)
def callback(self):
"""Finish initialisation."""
del self._callback
if op2.MPI.comm.size > 1:
self._plex.distributeOverlap(1)
self._grown_halos = True
if reorder:
with timed_region("Mesh: reorder"):
old_to_new = self._plex.getOrdering(PETSc.Mat.OrderingType.RCM).indices
reordering = np.empty_like(old_to_new)
reordering[old_to_new] = np.arange(old_to_new.size, dtype=old_to_new.dtype)
else:
# No reordering
reordering = None
self._did_reordering = bool(reorder)
# Mark OP2 entities and derive the resulting Plex renumbering
with timed_region("Mesh: renumbering"):
dmplex.mark_entity_classes(self._plex)
self._entity_classes = dmplex.get_entity_classes(self._plex)
self._plex_renumbering = dmplex.plex_renumbering(self._plex,
self._entity_classes,
reordering)
with timed_region("Mesh: cell numbering"):
# Derive a cell numbering from the Plex renumbering
entity_dofs = np.zeros(dim+1, dtype=np.int32)
entity_dofs[-1] = 1
self._cell_numbering = self._plex.createSection([1], entity_dofs,
perm=self._plex_renumbering)
entity_dofs[:] = 0
entity_dofs[0] = 1
self._vertex_numbering = self._plex.createSection([1], entity_dofs,
perm=self._plex_renumbering)
entity_dofs[:] = 0
entity_dofs[-2] = 1
facet_numbering = self._plex.createSection([1], entity_dofs,
perm=self._plex_renumbering)
self._facet_ordering = dmplex.get_facet_ordering(self._plex, facet_numbering)
def callback(self):
import firedrake.function as function
import firedrake.functionspace as functionspace
del self._callback
if op2.MPI.comm.size > 1:
self._plex.distributeOverlap(1)
self._grown_halos = True
if reorder:
with timed_region("Mesh: reorder"):
old_to_new = self._plex.getOrdering(PETSc.Mat.OrderingType.RCM).indices
reordering = np.empty_like(old_to_new)
reordering[old_to_new] = np.arange(old_to_new.size, dtype=old_to_new.dtype)
else:
# No reordering
reordering = None
# Mark OP2 entities and derive the resulting Plex renumbering
with timed_region("Mesh: renumbering"):
dmplex.mark_entity_classes(self._plex)
self._entity_classes = dmplex.get_entity_classes(self._plex)
self._plex_renumbering = dmplex.plex_renumbering(self._plex,
self._entity_classes,
reordering)
with timed_region("Mesh: cell numbering"):
# Derive a cell numbering from the Plex renumbering
entity_dofs = np.zeros(topological_dim+1, dtype=np.int32)
entity_dofs[-1] = 1
self._cell_numbering = self._plex.createSection([1], entity_dofs,
perm=self._plex_renumbering)
entity_dofs[:] = 0
entity_dofs[0] = 1
self._vertex_numbering = self._plex.createSection([1], entity_dofs,
perm=self._plex_renumbering)
# Note that for bendy elements, this needs to change.
with timed_region("Mesh: coordinate field"):
if periodic_coords is not None:
if self.ufl_cell().geometric_dimension() != 1:
raise NotImplementedError("Periodic coordinates in more than 1D are unsupported")
# We've been passed a periodic coordinate field, so use that.
self._coordinate_fs = functionspace.VectorFunctionSpace(self, "DG", 1)
self.coordinates = function.Function(self._coordinate_fs,
val=periodic_coords,
name="Coordinates")
else:
self._coordinate_fs = functionspace.VectorFunctionSpace(self, "Lagrange", 1)
coordinates = dmplex.reordered_coords(self._plex, self._coordinate_fs._global_numbering,
(self.num_vertices(), geometric_dim))
self.coordinates = function.Function(self._coordinate_fs,
val=coordinates,
name="Coordinates")
self._ufl_domain = ufl.Domain(self.coordinates)
# Build a new ufl element for this function space with the
# correct domain. This is necessary since this function space
# is in the cache and will be picked up by later
# VectorFunctionSpace construction.
self._coordinate_fs._ufl_element = self._coordinate_fs.ufl_element().reconstruct(domain=self.ufl_domain())
# HACK alert!
# Replace coordinate Function by one that has a real domain on it (but don't copy values)
self.coordinates = function.Function(self._coordinate_fs, val=self.coordinates.dat)
# Add subdomain_data to the measure objects we store with
# the mesh. These are weakrefs for consistency with the
# "global" measure objects
self._dx = ufl.Measure('cell', subdomain_data=weakref.ref(self.coordinates))
self._ds = ufl.Measure('exterior_facet', subdomain_data=weakref.ref(self.coordinates))
self._dS = ufl.Measure('interior_facet', subdomain_data=weakref.ref(self.coordinates))
# Set the subdomain_data on all the default measures to this
# coordinate field.
# We don't set the domain on the measure since this causes
# an uncollectable reference in the global space (dx is
# global). Furthermore, it's never used anyway.
for measure in [ufl.dx, ufl.ds, ufl.dS]:
measure._subdomain_data = weakref.ref(self.coordinates)
def callback(self):
import firedrake.function as function
import firedrake.functionspace as functionspace
del self._callback
if op2.MPI.comm.size > 1:
self._plex.distributeOverlap(1)
self._grown_halos = True
if reorder:
with timed_region("Mesh: reorder"):
old_to_new = self._plex.getOrdering(
PETSc.Mat.OrderingType.RCM).indices
reordering = np.empty_like(old_to_new)
reordering[old_to_new] = np.arange(old_to_new.size,
dtype=old_to_new.dtype)
else:
# No reordering
reordering = None
# Mark OP2 entities and derive the resulting Plex renumbering
with timed_region("Mesh: renumbering"):
dmplex.mark_entity_classes(self._plex)
self._entity_classes = dmplex.get_entity_classes(self._plex)
self._plex_renumbering = dmplex.plex_renumbering(
self._plex, self._entity_classes, reordering)
with timed_region("Mesh: cell numbering"):
# Derive a cell numbering from the Plex renumbering
entity_dofs = np.zeros(topological_dim + 1, dtype=np.int32)
entity_dofs[-1] = 1
self._cell_numbering = self._plex.createSection(
[1], entity_dofs, perm=self._plex_renumbering)
entity_dofs[:] = 0
entity_dofs[0] = 1
self._vertex_numbering = self._plex.createSection(
[1], entity_dofs, perm=self._plex_renumbering)
# Note that for bendy elements, this needs to change.
with timed_region("Mesh: coordinate field"):
if periodic_coords is not None:
if self.ufl_cell().geometric_dimension() != 1:
raise NotImplementedError(
"Periodic coordinates in more than 1D are unsupported"
)
# We've been passed a periodic coordinate field, so use that.
self._coordinate_fs = functionspace.VectorFunctionSpace(
self, "DG", 1)
self.coordinates = function.Function(self._coordinate_fs,
val=periodic_coords,
name="Coordinates")
else:
self._coordinate_fs = functionspace.VectorFunctionSpace(
self, "Lagrange", 1)
coordinates = dmplex.reordered_coords(
self._plex, self._coordinate_fs._global_numbering,
(self.num_vertices(), geometric_dim))
self.coordinates = function.Function(self._coordinate_fs,
val=coordinates,
name="Coordinates")
self._ufl_domain = ufl.Domain(self.coordinates)
# Build a new ufl element for this function space with the
# correct domain. This is necessary since this function space
# is in the cache and will be picked up by later
# VectorFunctionSpace construction.
self._coordinate_fs._ufl_element = self._coordinate_fs.ufl_element(
).reconstruct(domain=self.ufl_domain())
# HACK alert!
# Replace coordinate Function by one that has a real domain on it (but don't copy values)
self.coordinates = function.Function(self._coordinate_fs,
val=self.coordinates.dat)
# Add subdomain_data to the measure objects we store with
# the mesh. These are weakrefs for consistency with the
# "global" measure objects
self._dx = ufl.Measure('cell',
subdomain_data=weakref.ref(
self.coordinates))
self._ds = ufl.Measure('exterior_facet',
subdomain_data=weakref.ref(
self.coordinates))
self._dS = ufl.Measure('interior_facet',
subdomain_data=weakref.ref(
self.coordinates))
# Set the subdomain_data on all the default measures to this
# coordinate field.
# We don't set the domain on the measure since this causes
# an uncollectable reference in the global space (dx is
# global). Furthermore, it's never used anyway.
for measure in [ufl.dx, ufl.ds, ufl.dS]:
measure._subdomain_data = weakref.ref(self.coordinates)