sfepy.discrete.fem.poly_spaces module

class sfepy.discrete.fem.poly_spaces.LagrangeNodes(**kwargs)[source]

Helper class for defining nodes of Lagrange elements.

static append_bubbles(nodes, nts, iseq, nt, order)[source]
static append_edges(nodes, nts, iseq, nt, edges, order)[source]
static append_faces(nodes, nts, iseq, nt, faces, order)[source]
static append_tp_bubbles(nodes, nts, iseq, nt, ao)[source]
static append_tp_edges(nodes, nts, iseq, nt, edges, ao)[source]
static append_tp_faces(nodes, nts, iseq, nt, faces, ao)[source]
class sfepy.discrete.fem.poly_spaces.LagrangePolySpace(name, geometry, order)[source]
create_context(self, cmesh, eps, check_errors, i_max, newton_eps, tdim=None)[source]
class sfepy.discrete.fem.poly_spaces.LagrangeSimplexBPolySpace(name, geometry, order, init_context=True)[source]

Lagrange polynomial space with forced bubble function on a simplex domain.

create_context(self, *args, **kwargs)[source]
name = 'lagrange_simplex_bubble'
class sfepy.discrete.fem.poly_spaces.LagrangeSimplexPolySpace(name, geometry, order, init_context=True)[source]

Lagrange polynomial space on a simplex domain.

name = 'lagrange_simplex'
class sfepy.discrete.fem.poly_spaces.LagrangeTensorProductPolySpace(name, geometry, order, init_context=True)[source]

Lagrange polynomial space on a tensor product domain.

name = 'lagrange_tensor_product'
class sfepy.discrete.fem.poly_spaces.LobattoTensorProductPolySpace(name, geometry, order)[source]

Hierarchical polynomial space using Lobatto functions.

Each row of the nodes attribute defines indices of Lobatto functions that need to be multiplied together to evaluate the corresponding shape function. This defines the ordering of basis functions on the reference element.

name = 'lobatto_tensor_product'
class sfepy.discrete.fem.poly_spaces.NodeDescription(node_types, nodes)[source]

Describe FE nodes defined on different parts of a reference element.


Return True if the element has some edge, face or bubble nodes.

class sfepy.discrete.fem.poly_spaces.PolySpace(name, geometry, order)[source]

Abstract polynomial space class.

static any_from_args(name, geometry, order, base='lagrange', force_bubble=False)[source]

Construct a particular polynomial space classes according to the arguments passed in.

eval_base(self, coors, diff=0, ori=None, force_axis=False, transform=None, suppress_errors=False, eps=1e-15)[source]

Evaluate the basis or its first or second derivatives in points given by coordinates. The real work is done in _eval_base() implemented in subclasses.

Note that the second derivative code is a work-in-progress and only coors and transform arguments are used.


The coordinates of points where the basis is evaluated. See Notes.

diff0, 1 or 2

If nonzero, return the given derivative.

oriarray_like, optional

Optional orientation of element facets for per element basis.


If True, force the resulting array shape to have one more axis even when ori is None.

transformarray_like, optional

The basis transform array.


If True, do not report points outside the reference domain.


Accuracy for comparing coordinates.


The basis (shape (n_coor, 1, n_base)) or its first derivative (shape (n_coor, dim, n_base)) or its second derivative (shape (n_coor, dim, dim, n_base)) evaluated in the given points. An additional axis is pre-pended of length n_cell, if ori is given, or of length 1, if force_axis is True.


If coors.ndim == 3, several point sets are assumed, with equal number of points in each of them. This is the case, for example, of the values of the volume base functions on the element facets. The indexing (of bf_b(g)) is then (ifa,iqp,:,n_ep), so that the facet can be set in C using FMF_SetCell.

keys = {(1, 2): 'simplex', (2, 3): 'simplex', (2, 4): 'tensor_product', (3, 4): 'simplex', (3, 8): 'tensor_product'}
static suggest_name(geometry, order, base='lagrange', force_bubble=False)[source]

Suggest the polynomial space name given its constructor parameters.

sfepy.discrete.fem.poly_spaces.transform_basis(transform, bf)[source]

Transform a basis bf using transform array of matrices.