firedrake.cython package¶
Submodules¶
firedrake.cython.dmcommon module¶
- firedrake.cython.dmcommon.cell_facet_labeling(plex, cell_numbering, cell_closures)¶
Computes a labeling for the facet numbers on a particular cell (interior and exterior facet labels with subdomain markers). The i-th local facet is represented as:
cell_facets[c, i]
If cell_facets[c, i, 0] is
0
, then the local faceti
is an exterior facet, otherwise if the result is1
it is interior. cell_facets[c, i, 1] returns the subdomain marker for the local facet.- Parameters:
plex – The DMPlex object representing the mesh topology.
cell_numbering – PETSc.Section describing the global cell numbering
cell_closures – 2D array of ordered cell closures.
- firedrake.cython.dmcommon.clear_adjacency_callback(dm)¶
Clear the callback for DMPlexGetAdjacency.
- Parameters:
dm – The DMPlex object
- firedrake.cython.dmcommon.closure_ordering(dm, vertex_numbering, cell_numbering, entity_per_cell)¶
Apply Fenics local numbering to a cell closure.
- Parameters:
dm – The DM object encapsulating the mesh topology
vertex_numbering – Section describing the universal vertex numbering
cell_numbering – Section describing the global cell numbering
entity_per_cell – List of the number of entity points in each dimension
- Vertices := Ordered according to global/universal
vertex numbering
- Edges/faces := Ordered according to lexicographical
ordering of non-incident vertices
- firedrake.cython.dmcommon.complete_facet_labels(dm)¶
Transfer label values from the facet labels to everything in the closure of the facets.
- firedrake.cython.dmcommon.compute_point_cone_global_sizes(dm)¶
Compute the total number of DMPlex points and the global sum of cone sizes for dm.
- Parameters:
dm – The dm.
- Returns:
A list of global number of points and global sum of cone sizes.
- firedrake.cython.dmcommon.count_labelled_points(dm, name, start, end)¶
Return the number of points in the chart [start, end) that are marked by the given label.
Note
This destroys any index on the label.
- Parameters:
dm – The DM containing the label
name – The label name.
start – The smallest point to consider.
end – One past the largest point to consider.
- firedrake.cython.dmcommon.create_cell_closure(dm, cell_numbering, _closureSize)¶
Create a map from FIAT local entity numbers to DMPlex point numbers for each cell.
- Parameters:
dm – The DM object encapsulating the mesh topology
cell_numbering – Section describing the global cell numbering
_closureSize – Number of entities in the cell
- firedrake.cython.dmcommon.create_halo_exchange_sf(dm)¶
Create the halo exchange sf.
- Parameters:
dm (PETSc.DM) – The section dm.
- Returns:
The halo exchange sf.
- Return type:
PETSc.SF
Notes
The output sf is to update all ghost DoFs including constrained ones if any.
- firedrake.cython.dmcommon.create_section(mesh, nodes_per_entity, on_base=False, block_size=1, boundary_set=None)¶
Create the section describing a global numbering.
- Parameters:
mesh – The mesh.
nodes_per_entity – Number of nodes on each type of topological entity of the mesh. Or, if the mesh is extruded, the number of nodes on, and on top of, each topological entity in the base mesh.
on_base – If True, assume extruded space is actually Foo x Real.
boundary_set – A set of boundary markers, indicating the sub-domains a boundary condition is specified on.
block_size – The integer by which nodes_per_entity is uniformly multiplied to get the true data layout.
- Returns:
A PETSc Section providing the number of dofs, and offset of each dof, on each mesh point.
- Returns:
An integer providing the total number of constrained nodes in the Section.
- firedrake.cython.dmcommon.entity_orientations(mesh, cell_closure)¶
Compute entity orientations.
- Parameters:
mesh – The
MeshTopology
object encapsulating the mesh topologycell_closure – The two-dimensional array, each row of which contains the closure of the associated cell
- Returns:
A 2D array of the same shape as cell_closure, each row of which contains orientations of the entities in the closure of the associated cell
See
entity_orientations()
for details on the returned array.See
get_cell_nodes()
for the usage of the returned array.
- firedrake.cython.dmcommon.exchange_cell_orientations(plex, section, orientations)¶
Halo exchange of cell orientations.
- Parameters:
plex – The DMPlex object encapsulating the mesh topology
section – Section describing the cell numbering
orientations – Cell orientations to exchange, values in the halo will be overwritten.
- firedrake.cython.dmcommon.facet_closure_nodes(V, sub_domain)¶
Extract nodes in the closure of facets with a given marker.
This works fine for interior as well as exterior facets.
- Parameters:
V – the function space
sub_domain – a tuple of mesh markers selecting the facets, or the magic string “on_boundary” indicating the entire boundary.
- Returns:
a numpy array of unique nodes in the closure of facets with the given marker.
- firedrake.cython.dmcommon.facet_numbering(plex, kind, facets, cell_numbering, cell_closures)¶
Compute the parent cell(s) and the local facet number within each parent cell for each given facet.
- Parameters:
plex – The DMPlex object encapsulating the mesh topology
kind – String indicating the facet kind (interior or exterior)
facets – Array of input facets
cell_numbering – Section describing the global cell numbering
cell_closures – 2D array of ordered cell closures
- firedrake.cython.dmcommon.get_cell_markers(dm, cell_numbering, subdomain_id)¶
Get the cells marked by a given subdomain_id.
- Parameters:
dm – The DM for the mesh topology
cell_numbering – Section mapping dm cell points to firedrake cell indices.
subdomain_id – The subdomain_id to look for.
- Raises:
ValueError – if the subdomain_id is not valid.
- Returns:
A numpy array (possibly empty) of the cell ids.
- firedrake.cython.dmcommon.get_cell_nodes(mesh, global_numbering, entity_dofs, entity_permutations, offset)¶
Builds the DoF mapping.
- Parameters:
mesh – The mesh
global_numbering – Section describing the global DoF numbering
entity_dofs – FInAT element entity dofs for the cell
entity_permutations – FInAT element entity permutations for the cell
offset – offsets for each entity dof walking up a column.
Preconditions: This function assumes that cell_closures contains mesh entities ordered by dimension, i.e. vertices first, then edges, faces, and finally the cell. For quadrilateral meshes, edges corresponding to dimension (0, 1) in the FInAT element must precede edges corresponding to dimension (1, 0) in the FInAT element.
- firedrake.cython.dmcommon.get_cell_remote_ranks(plex)¶
Returns an array assigning the rank of the owner to each locally visible cell. Locally owned cells have -1 assigned to them.
- Parameters:
plex – The DMPlex object encapsulating the mesh topology
- firedrake.cython.dmcommon.get_entity_classes(dm)¶
Builds PyOP2 entity class offsets for all entity levels.
- Parameters:
dm – The DM object encapsulating the mesh topology
- firedrake.cython.dmcommon.get_facet_nodes(mesh, cell_nodes, label, offset)¶
Build to DoF mapping from facets.
- Parameters:
mesh – The mesh.
cell_nodes – numpy array mapping from cells to function space nodes.
label – which set of facets to ask for (interior_facets or exterior_facets).
offset – optional offset (extruded only).
- Returns:
numpy array mapping from facets to nodes in the closure of the support of that facet.
- firedrake.cython.dmcommon.get_facet_ordering(plex, facet_numbering)¶
Builds a list of all facets ordered according to the given numbering.
- Parameters:
plex – The DMPlex object encapsulating the mesh topology
facet_numbering – A Section describing the global facet numbering
- firedrake.cython.dmcommon.get_facets_by_class(plex, label, ordering)¶
Builds a list of all facets ordered according to PyOP2 entity classes and computes the respective class offsets.
- Parameters:
plex – The DMPlex object encapsulating the mesh topology
ordering – An array giving the global traversal order of facets
label – Label string that marks the facets to order
- firedrake.cython.dmcommon.get_topological_dimension(dm)¶
Get the topological dimension of a DMPlex or DMSwarm. Assumes that a DMSwarm represents a mesh of vertices (tdim 0).
- Parameters:
dm – A DMPlex or DMSwarm.
- Returns:
For a DMPlex
dm.getDimension()
, for a DMSwarm0
.
- firedrake.cython.dmcommon.label_facets(plex)¶
Add labels to facets in the the plex
Facets on the boundary are marked with “exterior_facets” while all others are marked with “interior_facets”.
- firedrake.cython.dmcommon.make_global_numbering(lsec, gsec)¶
Build an array of global numbers for local dofs
- Parameters:
lsec – Section describing local dof layout and numbers.
gsec – Section describing global dof layout and numbers.
- firedrake.cython.dmcommon.mark_entity_classes(dm)¶
Mark all points in a given DM according to the PyOP2 entity classes:
core : owned and not in send halo owned : owned and in send halo ghost : in halo
by inspecting the pointSF graph.
- Parameters:
dm – The DM object encapsulating the mesh topology
- firedrake.cython.dmcommon.mark_entity_classes_using_cell_dm(swarm)¶
Mark all points in a given Particle in Cell (PIC) DMSwarm according to the PyOP2 entity classes (core, owned, ghost) using the markers of the parent DMPlex or DMSwarm cells (i.e. the cells within which the swarm points are located).
- firedrake.cython.dmcommon.mark_points_with_function_array(plex, section, height, array, dmlabel, label_value)¶
Marks points in a DMLabel using an indicator function array.
- Parameters:
plex – DMPlex representing the mesh topology
section – Section describing the function space DoF layout and order
height – Height of marked points (0 for cells, 1 for facets)
array – Array representing the indicator function whose layout is defined by plex, section, and height
dmlabel – DMLabel that records marked entities
label_value – Value used in dmlabel
- firedrake.cython.dmcommon.orientations_facet2cell(plex, vertex_numbering, cell_ranks, facet_orientations, cell_numbering)¶
Converts local quadrilateral facet orientations into global quadrilateral cell orientations.
- Parameters:
plex – The DMPlex object encapsulating the mesh topology
vertex_numbering – Section describing the universal vertex numbering
facet_orientations – Facet orientations (edge directions) relative to the local DMPlex ordering.
cell_numbering – Section describing the cell numbering
- firedrake.cython.dmcommon.plex_renumbering(plex, entity_classes, reordering=None, boundary_set=None)¶
Build a global node renumbering as a permutation of Plex points.
- Parameters:
plex – The DMPlex object encapsulating the mesh topology
entity_classes – Array of entity class offsets for each dimension.
reordering – A reordering from reordered to original plex points used to provide the traversal order of the cells (i.e. the inverse of the ordering obtained from DMPlexGetOrdering). Optional, if not provided (or
None
), no reordering is applied and the plex is traversed in original order.boundary_set – A set of boundary subdomains, where a DirichletBC is to be applied. This is None if working with a FunctionSpace object, and non-empty if working with a RestrictedFunctionSpace object. If one is provided, this will move all core or owned boundary points to the end of the core+owned block.
The node permutation is derived from a depth-first traversal of the Plex graph over each entity class in turn. The returned IS is the Plex -> PyOP2 permutation. A tuple indicating the start and end of the core/owned constrained block is returned, for use in create_section.
- firedrake.cython.dmcommon.quadrilateral_closure_ordering(plex, vertex_numbering, cell_numbering, cell_orientations)¶
Cellwise orders mesh entities according to the given cell orientations.
- Parameters:
plex – The DMPlex object encapsulating the mesh topology
vertex_numbering – Section describing the universal vertex numbering
cell_numbering – Section describing the cell numbering
cell_orientations – Specifies the starting vertex for each cell, and the order of traversal (CCW or CW).
- firedrake.cython.dmcommon.quadrilateral_facet_orientations(plex, vertex_numbering, cell_ranks)¶
Returns globally synchronised facet orientations (edge directions) incident to locally owned quadrilateral cells.
- Parameters:
plex – The DMPlex object encapsulating the mesh topology
vertex_numbering – Section describing the universal vertex numbering
cell_ranks – MPI rank of the owner of each (visible) non-owned cell, or -1 for (locally) owned cell.
- firedrake.cython.dmcommon.reordered_coords(dm, global_numbering, shape, reference_coord=False)¶
Return coordinates for the dm, reordered according to the global numbering permutation for the coordinate function space.
Shape is a tuple of (mesh.num_vertices(), geometric_dim).
- firedrake.cython.dmcommon.set_adjacency_callback(dm)¶
Set the callback for DMPlexGetAdjacency.
- Parameters:
dm – The DMPlex object.
This is used during DMPlexDistributeOverlap to determine where to grow the halos.
- firedrake.cython.dmcommon.submesh_correct_entity_classes(dm, subdm, ownership_transfer_sf)¶
Correct pyop2 entity classes.
- Parameters:
dm (PETSc.DM) – The original DM.
subdm (PETSc.DM) – The subdm.
ownership_transfer_sf (PETSc.SF) – The ownership transfer sf.
- firedrake.cython.dmcommon.submesh_create(dm, label_name, label_value)¶
Create submesh.
- firedrake.cython.dmcommon.submesh_create_cell_closure_cell_submesh(subdm, dm, subcell_numbering, cell_numbering, cell_closure)¶
Inherit cell_closure from parent.
- Parameters:
subdm (PETSc.DM) – The subdm.
dm (PETSc.DM) – The parent dm.
subcell_numbering (PETSc.Section) – The cell_numbering of the submesh.
cell_numbering (PETSc.Section) – The cell_numbering of the parent mesh.
cell_closure (numpy.ndarray) – The cell_closure of the parent mesh.
- firedrake.cython.dmcommon.submesh_update_facet_labels(dm, subdm)¶
Update facet labels of subdm taking the new exterior facet points into account.
- Parameters:
dm (PETSc.DM) – The parent dm.
subdm (PETSc.DM) – The subdm.
Notes
This function marks the new exterior facets with current max label value + 1 in “Face Sets”.
- firedrake.cython.dmcommon.to_petsc_local_numbering(vec, V)¶
Reorder a PETSc Vec corresponding to a Firedrake Function w.r.t. the PETSc natural numbering.
- Parameters:
vec – the PETSc Vec to reorder; must be a global vector
V – the FunctionSpace of the Function which the Vec comes from
- Ret out:
a copy of the Vec, ordered with the PETSc natural numbering
- firedrake.cython.dmcommon.transform_vec_from_firedrake_to_petsc(dm, finat_element, firedrake_sec, firedrake_vec, petsc_sec, petsc_vec, use_transitive_closure_dg=False)¶
Transform Firedrake vec to PETSc vec.
- Parameters:
dm (PETSc.DM) – PETSc.DM.
finat_element (finat.finiteelementbase.FiniteElementBase) – FInAT element.
firedrake_sec (PETSc.Section) – PETSc.Section representing the Firedrake DoF layout.
firedrake_vec (PETSc.Vec) – PETSc.Vec representing the Firedrake DoF vector.
petsc_sec (PETSc.Section) – PETSc.Section representing the PETSc DoF layout.
petsc_vec (PETSc.Vec) – PETSc.Vec representing the PETSc DoF vector.
use_transitive_closure_dg (bool) – Whether to use PETSc DG element whose DoFs are ordered according to the transitive closure of the cell.
- firedrake.cython.dmcommon.validate_mesh(dm)¶
Perform some validation of the input mesh.
- Parameters:
dm – The DM object encapsulating the mesh topology.
firedrake.cython.extrusion_numbering module¶
Computation dof numberings for extruded meshes¶
On meshes with a constant number of cell layers (i.e. each column contains the same number of cells), it is possible to compute all the correct numberings by just lying to DMPlex about how many degrees of freedom there are on the base topological entities.
This ceases to be true as soon as we permit variable numbers of cells in each column, since now, although the number of degrees of freedom on a cell does not change from column to column, the number that are stacked up on each topological entity does change.
This module implements the necessary chicanery to deal with it.
Computation of topological layer extents¶
First, a picture.
Consider a one-dimensional mesh:
x---0---x---1---x---2---x
Extruded to form the following two-dimensional mesh:
x--------x
| |
| |
2 | |
| |
x--------x--------x--------x
| | |
| | |
1 | | |
| | |
x--------x--------x
| |
| |
0 | |
| |
x--------x
This is constructed by providing the number of cells in each column as well as the starting cell layer:
[[0, 2],
[1, 1],
[2, 1]]
We need to promote this cell layering to layering for all topological entities. Our solution to “interior” facets that only have one side is to require that they are geometrically zero sized, and then guarantee that we never iterate over them. We therefore need to keep track of two bits of information, the layer extent for allocation purposes and also the layer extent for iteration purposes.
We compute both by iterating over the cells and transferring cell layers to points in the closure of each cell. Allocation bounds use min-max on the cell bounds, iteration bounds use max-min.
To simplify some things, we require that the resulting mesh is not topologically disconnected anywhere. Offset cells must, at least, share a vertex with some other cell.
Computation of function space allocation size¶
With the layer extents computed, we need to compute the dof allocation. For this, we need the number of degrees of freedom on the base topological entity, and above it in each cell:
x-------x
| o |
o o o
o o o
| o |
o---o---o
This element has one degree of freedom on each base vertex and cell, two degrees of freedom “above” each vertex, and four above each cell. To compute the number of degrees of freedom on the column of topological entities we sum the number on the entity, multiplied by the number of layers with the number above, multiplied by the number of layers minus one (due to the fencepost error difference). This number of layers naturally changes from entity to entity, and so we can’t compute this up front, but must do it point by point, constructing the PETSc Section as we go.
Computation of function space maps¶
Now we need the maps from topological entities (cells and facets) to the function space nodes they can see. The allocation offsets that the numbering section gives us are wrong, because when we have a step in the column height, the offset will be wrong if we’re looking from the higher cell. Consider a vertex discretisation on the previous mesh, with a numbering:
8--------10
| |
| |
| |
| |
2--------5--------7--------9
| | |
| | |
| | |
| | |
1--------4--------6
| |
| |
| |
| |
0--------3
The cell node map we get by just looking at allocation offsets is:
[[0, 1, 3, 4],
[3, 4, 6, 7],
[6, 7, 9, 10]]
note how the second and third cells have the wrong value for their “left” vertices. Instead, we need to shift the numbering we obtain from the allocation offset by the number of entities we’re skipping over, to result in:
[[0, 1, 3, 4],
[4, 5, 6, 7],
[7, 8, 9, 10]]
Now, when we iterate over cells, we ensure that we access the correct dofs. The same trick needs to be applied to facet maps too.
Computation of boundary nodes¶
For the top and bottom boundary nodes, we walk over the cells at, respectively, the top and bottom of the column and pull out those nodes whose entity height matches the appropriate cell height. As an example:
8--------10
| |
| |
| |
| |
2--------5--------7--------9
| | |
| | |
| | |
| | |
1--------4--------6
| |
| |
| |
| |
0--------3
The bottom boundary nodes are:
[0, 3, 4, 6, 7, 9]
whereas the top are:
[2, 5, 7, 8, 10]
For these strange “interior” facets, we first walk over the cells, picking up the dofs in the closure of the base (ceiling) of the cell, then we walk over facets, picking up all the dofs in the closure of facets that are exposed (there may be more than one of these in the cell column). We don’t have to worry about any lower-dimensional entities, because if a co-dim 2 or greater entity is exposed in a column, then the co-dim 1 entity in its star is also exposed.
For the side boundary nodes, we can make a simplification: we know that the facet heights are always the same as the cell column heights (because there is only one cell in the support of the facet). Hence we just walk over the boundary facets of the base mesh, extract out the nodes on that facet on the bottom cell and walk up the column. This is guaranteed to pick up all the nodes in the closure of the facet column.
- firedrake.cython.extrusion_numbering.entity_layers(mesh, height, label=None)¶
Compute the layers for a given entity type.
- Parameters:
mesh – the extruded mesh to compute layers for.
height – the height of the entity to consider (in the DMPlex sense). e.g. 0 -> cells, 1 -> facets, etc…
label – optional label to select some subset of the points of the given height (may be None meaning select all points).
- Returns:
a numpy array of shape (num_entities, 2) providing the layer extents for iteration on the requested entities.
- firedrake.cython.extrusion_numbering.facet_closure_nodes(V, sub_domain)¶
Extract nodes in the closure of facets with a given marker.
This works fine for interior as well as exterior facets.
Note
Don’t call this function directly, but rather call
facet_closure_nodes()
, which will dispatch here if appropriate.- Parameters:
V – the function space
sub_domain – a mesh marker selecting the part of the boundary
- Returns:
a numpy array of unique nodes on the boundary of the requested subdomain.
- firedrake.cython.extrusion_numbering.layer_extents(dm, cell_numbering, cell_extents)¶
Compute the extents (start and stop layers) for an extruded mesh.
- Parameters:
dm – The DMPlex.
cell_numbering – The cell numbering (plex points to Firedrake points).
cell_extents – The cell layers.
- Returns:
a numpy array of shape (npoints, 4) where npoints is the number of mesh points in the base mesh.
npoints[p, 0:2]
gives the start and stop layers for allocation for mesh pointp
(in plex ordering), whilenpoints[p, 2:4]
gives the start and stop layers for iteration over mesh pointp
(in plex ordering).
Warning
The indexing of this array uses DMPlex point ordering, not Firedrake ordering. So you always need to iterate over plex points and translate to Firedrake numbers if necessary.
- firedrake.cython.extrusion_numbering.node_classes(mesh, nodes_per_entity)¶
Compute the node classes for a given extruded mesh.
- Parameters:
mesh – the extruded mesh.
nodes_per_entity – Number of nodes on, and on top of, each type of topological entity on the base mesh for a single cell layer. Multiplying up by the number of layers happens in this function.
- Returns:
A numpy array of shape (3, ) giving the set entity sizes for the given nodes per entity.
- firedrake.cython.extrusion_numbering.top_bottom_boundary_nodes(mesh, cell_node_list, mask, offsets, kind)¶
Extract top or bottom boundary nodes from an extruded function space.
- Parameters:
mesh – The extruded mesh.
cell_node_list – The map from cells to nodes.
masks – masks for dofs in the closure of the facets of the cell. First the vertical facets, then the horizontal facets (bottom then top).
offsets – Offsets to apply walking up the column.
kind – Whether we should select the bottom, or the top, nodes.
- Returns:
a numpy array of unique indices of nodes on the bottom or top of the mesh.
firedrake.cython.hdf5interface module¶
- firedrake.cython.hdf5interface.get_h5py_file(vwr)¶
Attempt to convert PETSc viewer file handle to h5py File.
- Parameters:
vwr – The PETSc Viewer (must have type HDF5).
Warning
For this to work, h5py and PETSc must both have been compiled against the same HDF5 library (otherwise the file handles are not interchangeable). This is the likeliest reason for failure when attempting the conversion.
firedrake.cython.mgimpl module¶
- firedrake.cython.mgimpl.coarse_to_fine_cells(mc, mf, clgmaps, flgmaps)¶
Return a map from (renumbered) cells in a coarse mesh to those in a refined fine mesh.
- Parameters:
mc – the coarse mesh to create the map from.
mf – the fine mesh to map to.
clgmaps – coarse lgmaps (non-overlapped and overlapped)
flgmaps – fine lgmaps (non-overlapped and overlapped)
- Returns:
Two arrays, one mapping coarse to fine cells, the second fine to coarse cells.
- firedrake.cython.mgimpl.coarse_to_fine_nodes(Vc, Vf, coarse_to_fine_cells)¶
- firedrake.cython.mgimpl.create_lgmap(dm)¶
Create a local to global map for all points in the given DM.
- Parameters:
dm – The DM to create the map for.
Returns a petsc4py LGMap.
- firedrake.cython.mgimpl.filter_labels(dm, keep, *label_names)¶
Remove labels from points that are not in keep. :arg dm: DM object with labels. :arg keep: subsection of the DMs chart on which to retain label values. :arg label_names: names of labels (strings) to clear. When refining, every point “underneath” the refined entity receives its label. But we typically have labels applied only to entities of a given stratum height (and rely on that elsewhere), so clear the labels from everything else.
- firedrake.cython.mgimpl.fine_to_coarse_nodes(Vf, Vc, fine_to_coarse_cells)¶
- firedrake.cython.mgimpl.get_entity_renumbering(plex, section, entity_type)¶
Given a section numbering a type of topological entity, return the renumberings from original plex numbers to new firedrake numbers (and vice versa)
- Parameters:
plex – The DMPlex object
section – The Section defining the renumbering
entity_type – The type of entity (either
"cell"
or"vertex"
)
firedrake.cython.patchimpl module¶
- firedrake.cython.patchimpl.set_patch_jacobian(patch, function, ctx, is_snes=False, interior_facets=False)¶
- firedrake.cython.patchimpl.set_patch_residual(patch, function, ctx, is_snes=False, interior_facets=False)¶
firedrake.cython.spatialindex module¶
- class firedrake.cython.spatialindex.SpatialIndex¶
Bases:
object
Python class for holding a native spatial index object.
- ctypes¶
Returns a ctypes pointer to the native spatial index.
- firedrake.cython.spatialindex.bounding_boxes(sidx, x)¶
Given a spatial index and a point, return the bounding boxes the point is in.
- Parameters:
sidx – the SpatialIndex
x – the point
- Returns:
a numpy array of candidate bounding boxes.
- firedrake.cython.spatialindex.from_regions(regions_lo, regions_hi)¶
Builds a spatial index from a set of maximum bounding regions (MBRs).
regions_lo and regions_hi must have the same size. regions_lo[i] and regions_hi[i] contain the coordinates of the diagonally opposite lower and higher corners of the i-th MBR, respectively.
firedrake.cython.supermeshimpl module¶
- firedrake.cython.supermeshimpl.assemble_mixed_mass_matrix(V_A, V_B, candidates, node_locations_A, node_locations_B, M_SS, lib, mat)¶
- firedrake.cython.supermeshimpl.intersection_finder(mesh_A, mesh_B)¶