def exterior_facets(self):
if self._plex.getStratumSize("exterior_facets", 1) > 0:
# Compute the facet_numbering
# Order exterior facets by OP2 entity class
exterior_facets, exterior_facet_classes = \
dmplex.get_facets_by_class(self._plex, "exterior_facets")
# Derive attached boundary IDs
if self._plex.hasLabel("boundary_ids"):
boundary_ids = np.zeros(exterior_facets.size, dtype=np.int32)
for i, facet in enumerate(exterior_facets):
boundary_ids[i] = self._plex.getLabelValue("boundary_ids", facet)
unique_ids = np.sort(self._plex.getLabelIdIS("boundary_ids").indices)
else:
boundary_ids = None
unique_ids = None
exterior_local_facet_number, exterior_facet_cell = \
dmplex.facet_numbering(self._plex, "exterior",
exterior_facets,
self._cell_numbering,
self.cell_closure)
return _Facets(self, exterior_facet_classes, "exterior",
exterior_facet_cell, exterior_local_facet_number,
boundary_ids, unique_markers=unique_ids)
else:
if self._plex.hasLabel("boundary_ids"):
unique_ids = np.sort(self._plex.getLabelIdIS("boundary_ids").indices)
else:
unique_ids = None
return _Facets(self, 0, "exterior", None, None,
unique_markers=unique_ids)
def interior_facets(self):
if self._plex.getStratumSize("interior_facets", 1) > 0:
# Compute the facet_numbering
# Order interior facets by OP2 entity class
interior_facets, interior_facet_classes = \
dmplex.get_facets_by_class(self._plex, "interior_facets")
interior_local_facet_number, interior_facet_cell = \
dmplex.facet_numbering(self._plex, "interior",
interior_facets,
self._cell_numbering,
self.cell_closure)
return _Facets(self, interior_facet_classes, "interior",
interior_facet_cell, interior_local_facet_number)
else:
return _Facets(self, 0, "interior", None, None)
def __init__(self, mesh, element, name=None, dim=1, rank=0):
"""
:param mesh: :class:`Mesh` to build this space on
:param element: :class:`ufl.FiniteElementBase` to build this space from
:param name: user-defined name for this space
:param dim: vector space dimension of a :class:`.VectorFunctionSpace`
:param rank: rank of the space, not the value rank
"""
self._ufl_element = element
# Compute the FIAT version of the UFL element above
self.fiat_element = fiat_utils.fiat_from_ufl_element(element)
if isinstance(mesh, mesh_t.ExtrudedMesh):
# Set up some extrusion-specific things
# The bottom layer maps will come from element_dof_list
# dof_count is the total number of dofs in the extruded mesh
# Get the flattened version of the FIAT element
self.flattened_element = self.fiat_element.flattened_element()
entity_dofs = self.flattened_element.entity_dofs()
self._dofs_per_cell = [len(entity)*len(entity[0]) for d, entity in entity_dofs.iteritems()]
# Compute the number of DoFs per dimension on top/bottom and sides
entity_dofs = self.fiat_element.entity_dofs()
top_dim = mesh._plex.getDimension()
self._xtr_hdofs = [len(entity_dofs[(d, 0)][0]) for d in range(top_dim+1)]
self._xtr_vdofs = [len(entity_dofs[(d, 1)][0]) for d in range(top_dim+1)]
# Compute the dofs per column
self.dofs_per_column = eutils.compute_extruded_dofs(self.fiat_element,
self.flattened_element.entity_dofs(),
mesh._layers)
# Compute the offset for the extrusion process
self.offset = eutils.compute_offset(self.fiat_element.entity_dofs(),
self.flattened_element.entity_dofs(),
self.fiat_element.space_dimension())
# Compute the top and bottom masks to identify boundary dofs
b_mask = self.fiat_element.get_lower_mask()
t_mask = self.fiat_element.get_upper_mask()
self.bt_masks = (b_mask, t_mask)
self.extruded = True
self._dofs_per_entity = self.dofs_per_column
else:
# If not extruded specific, set things to None/False, etc.
self.offset = None
self.bt_masks = None
self.dofs_per_column = np.zeros(1, np.int32)
self.extruded = False
entity_dofs = fiat_utils.flat_entity_dofs(self.fiat_element)
self._dofs_per_entity = [len(entity[0]) for d, entity in entity_dofs.iteritems()]
self._dofs_per_cell = [len(entity)*len(entity[0]) for d, entity in entity_dofs.iteritems()]
self.name = name
self._dim = dim
self._mesh = mesh
self._index = None
# Create the PetscSection mapping topological entities to DoFs
try:
# Old style createSection
self._global_numbering = mesh._plex.createSection(1, [1], self._dofs_per_entity,
perm=mesh._plex_renumbering)
except:
# New style
self._global_numbering = mesh._plex.createSection([1], self._dofs_per_entity,
perm=mesh._plex_renumbering)
mesh._plex.setDefaultSection(self._global_numbering)
self._universal_numbering = mesh._plex.getDefaultGlobalSection()
# Re-initialise the DefaultSF with the numbering for this FS
mesh._plex.createDefaultSF(self._global_numbering,
self._universal_numbering)
# Derive the Halo from the DefaultSF
self._halo = halo.Halo(mesh._plex.getDefaultSF(),
self._global_numbering,
self._universal_numbering)
# Compute entity class offsets
self.dof_classes = [0, 0, 0, 0]
for d in range(mesh._plex.getDimension()+1):
ncore = mesh._plex.getStratumSize("op2_core", d)
nowned = mesh._plex.getStratumSize("op2_non_core", d)
nhalo = mesh._plex.getStratumSize("op2_exec_halo", d)
nnonexec = mesh._plex.getStratumSize("op2_non_exec_halo", d)
ndofs = self._dofs_per_entity[d]
self.dof_classes[0] += ndofs * ncore
self.dof_classes[1] += ndofs * (ncore + nowned)
self.dof_classes[2] += ndofs * (ncore + nowned + nhalo)
self.dof_classes[3] += ndofs * (ncore + nowned + nhalo + nnonexec)
self._node_count = self._global_numbering.getStorageSize()
self.cell_node_list = mesh.create_cell_node_list(self._global_numbering,
self.fiat_element,
sum(self._dofs_per_cell))
if mesh._plex.getStratumSize("interior_facets", 1) > 0:
# Compute the facet_numbering and store with the parent mesh
if mesh.interior_facets is None:
# Order interior facets by OP2 entity class
interior_facets, interior_facet_classes = \
dmplex.get_facets_by_class(mesh._plex, "interior_facets")
interior_local_facet_number, interior_facet_cell = \
dmplex.facet_numbering(mesh._plex, "interior",
interior_facets,
mesh._cell_numbering,
mesh.cell_closure)
mesh.interior_facets = mesh_t._Facets(mesh, interior_facet_classes,
"interior",
interior_facet_cell,
interior_local_facet_number)
interior_facet_cells = mesh.interior_facets.facet_cell
self.interior_facet_node_list = \
dmplex.get_facet_nodes(interior_facet_cells,
self.cell_node_list)
else:
self.interior_facet_node_list = np.array([], dtype=np.int32)
if mesh.interior_facets is None:
mesh.interior_facets = mesh_t._Facets(self, 0, "exterior", None, None)
if mesh._plex.getStratumSize("exterior_facets", 1) > 0:
# Compute the facet_numbering and store with the parent mesh
if mesh.exterior_facets is None:
# Order exterior facets by OP2 entity class
exterior_facets, exterior_facet_classes = \
dmplex.get_facets_by_class(mesh._plex, "exterior_facets")
# Derive attached boundary IDs
if mesh._plex.hasLabel("boundary_ids"):
boundary_ids = np.zeros(exterior_facets.size, dtype=np.int32)
for i, facet in enumerate(exterior_facets):
boundary_ids[i] = mesh._plex.getLabelValue("boundary_ids", facet)
unique_ids = np.sort(mesh._plex.getLabelIdIS("boundary_ids").indices)
else:
boundary_ids = None
unique_ids = None
exterior_local_facet_number, exterior_facet_cell = \
dmplex.facet_numbering(mesh._plex, "exterior",
exterior_facets,
mesh._cell_numbering,
mesh.cell_closure)
mesh.exterior_facets = mesh_t._Facets(mesh, exterior_facet_classes,
"exterior",
exterior_facet_cell,
exterior_local_facet_number,
boundary_ids,
unique_markers=unique_ids)
exterior_facet_cells = mesh.exterior_facets.facet_cell
self.exterior_facet_node_list = \
dmplex.get_facet_nodes(exterior_facet_cells,
self.cell_node_list)
else:
self.exterior_facet_node_list = np.array([], dtype=np.int32)
if mesh.exterior_facets is None:
if mesh._plex.hasLabel("boundary_ids"):
unique_ids = np.sort(mesh._plex.getLabelIdIS("boundary_ids").indices)
else:
unique_ids = None
mesh.exterior_facets = mesh_t._Facets(self, 0, "exterior", None, None,
unique_markers=unique_ids)
# Note: this is the function space rank. The value rank may be different.
self.rank = rank
# Empty map caches. This is a sui generis cache
# implementation because of the need to support boundary
# conditions.
self._cell_node_map_cache = {}
self._exterior_facet_map_cache = {}
self._interior_facet_map_cache = {}