sfepy.discrete.fem.fields_base module

Notes

Important attributes of continuous (order > 0) Field and SurfaceField instances:

  • vertex_remap : econn[:, :n_vertex] = vertex_remap[conn]
  • vertex_remap_i : conn = vertex_remap_i[econn[:, :n_vertex]]

where conn is the mesh vertex connectivity, econn is the region-local field connectivity.

class sfepy.discrete.fem.fields_base.FEField(name, dtype, shape, region, approx_order=1)[source]

Base class for finite element fields.

Notes

  • Region can span over several groups -> different Aproximation instances
  • interps and hence node_descs are per region (must have single geometry!)
  • no two interps can be in a same group -> no two aps (with different regions) can be in a same group -> aps can be uniquely indexed with ig

Field shape information:

  • shape - the shape of the base functions in a point
  • n_components - the number of DOFs per FE node
  • val_shape - the shape of field value (the product of DOFs and base functions) in a point
create_mapping(ig, region, integral, integration)[source]

Create a new reference mapping.

create_mesh(extra_nodes=True)[source]

Create a mesh from the field region, optionally including the field extra nodes.

create_output(dofs, var_name, dof_names=None, key=None, extend=True, fill_value=None, linearization=None)[source]

Convert the DOFs corresponding to the field to a dictionary of output data usable by Mesh.write().

Parameters:

dofs : array, shape (n_nod, n_component)

The array of DOFs reshaped so that each column corresponds to one component.

var_name : str

The variable name corresponding to dofs.

dof_names : tuple of str

The names of DOF components.

key : str, optional

The key to be used in the output dictionary instead of the variable name.

extend : bool

Extend the DOF values to cover the whole domain.

fill_value : float or complex

The value used to fill the missing DOF values if extend is True.

linearization : Struct or None

The linearization configuration for higher order approximations.

Returns:

out : dict

The output dictionary.

extend_dofs(dofs, fill_value=None)[source]

Extend DOFs to the whole domain using the fill_value, or the smallest value in dofs if fill_value is None.

get_coor(nods=None)[source]

Get coordinates of the field nodes.

Parameters:

nods : array, optional

The indices of the required nodes. If not given, the coordinates of all the nodes are returned.

get_data_shape(ig, integral, integration='volume', region_name=None)[source]

Get element data dimensions.

Parameters:

ig : int

The element group index.

integral : Integral instance

The integral describing used numerical quadrature.

integration : ‘volume’, ‘plate’, ‘surface’, ‘surface_extra’ or ‘point’

The term integration type.

region_name : str

The name of surface region, required when shape_kind is ‘surface’.

Returns:

data_shape : 4 ints

The (n_el, n_qp, dim, n_en) for volume shape kind, (n_fa, n_qp, dim, n_fn) for surface shape kind and (n_nod, 0, 0, 1) for point shape kind.

Notes

  • n_el, n_fa = number of elements/facets
  • n_qp = number of quadrature points per element/facet
  • dim = spatial dimension
  • n_en, n_fn = number of element/facet nodes
  • n_nod = number of element nodes
get_dofs_in_region_group(region, ig, merge=True)[source]

Return indices of DOFs that belong to the given region and group.

get_output_approx_order()[source]

Get the approximation order used in the output file.

get_true_order()[source]

Get the true approximation order depending on the reference element geometry.

For example, for P1 (linear) approximation the true order is 1, while for Q1 (bilinear) approximation in 2D the true order is 2.

get_vertices()[source]

Return indices of vertices belonging to the field region.

interp_to_qp(dofs)[source]

Interpolate DOFs into quadrature points.

The quadrature order is given by the field approximation order.

Parameters:

dofs : array

The array of DOF values of shape (n_nod, n_component).

Returns:

data_qp : array

The values interpolated into the quadrature points.

integral : Integral

The corresponding integral defining the quadrature points.

is_higher_order()[source]

Return True, if the field’s approximation order is greater than one.

linearize(dofs, min_level=0, max_level=1, eps=0.0001)[source]

Linearize the solution for post-processing.

Parameters:

dofs : array, shape (n_nod, n_component)

The array of DOFs reshaped so that each column corresponds to one component.

min_level : int

The minimum required level of mesh refinement.

max_level : int

The maximum level of mesh refinement.

eps : float

The relative tolerance parameter of mesh adaptivity.

Returns:

mesh : Mesh instance

The adapted, nonconforming, mesh.

vdofs : array

The DOFs defined in vertices of mesh.

levels : array of ints

The refinement level used for each element group.

remove_extra_dofs(dofs)[source]

Remove DOFs defined in higher order nodes (order > 1).

setup_coors(coors=None)[source]

Setup coordinates of field nodes.

class sfepy.discrete.fem.fields_base.H1Mixin(**kwargs)[source]

Methods of fields specific to H1 space.

class sfepy.discrete.fem.fields_base.SurfaceField(name, dtype, shape, region, approx_order=1)[source]

Finite element field base class over surface (element dimension is one less than space dimension).

average_qp_to_vertices(data_qp, integral)[source]

Average data given in quadrature points in region elements into region vertices.

u_n = \sum_e (u_{e,avg} * area_e) / \sum_e area_e = \sum_e \int_{area_e} u / \sum area_e

get_econn(conn_type, region, ig, is_trace=False, integration=None)[source]

Get extended connectivity of the given type in the given region.

setup_extra_data(geometry, info, is_trace)[source]
class sfepy.discrete.fem.fields_base.VolumeField(name, dtype, shape, region, approx_order=1)[source]

Finite element field base class over volume elements (element dimension equals space dimension).

average_qp_to_vertices(data_qp, integral)[source]

Average data given in quadrature points in region elements into region vertices.

u_n = \sum_e (u_{e,avg} * volume_e) / \sum_e volume_e = \sum_e \int_{volume_e} u / \sum volume_e

get_econn(conn_type, region, ig, is_trace=False, integration=None)[source]

Get extended connectivity of the given type in the given region.

setup_extra_data(geometry, info, is_trace)[source]
sfepy.discrete.fem.fields_base.create_expression_output(expression, name, primary_field_name, fields, materials, variables, functions=None, mode='eval', term_mode=None, extra_args=None, verbose=True, kwargs=None, min_level=0, max_level=1, eps=0.0001)[source]

Create output mesh and data for the expression using the adaptive linearizer.

Parameters:

expression : str

The expression to evaluate.

name : str

The name of the data.

primary_field_name : str

The name of field that defines the element groups and polynomial spaces.

fields : dict

The dictionary of fields used in variables.

materials : Materials instance

The materials used in the expression.

variables : Variables instance

The variables used in the expression.

functions : Functions instance, optional

The user functions for materials etc.

mode : one of ‘eval’, ‘el_avg’, ‘qp’

The evaluation mode - ‘qp’ requests the values in quadrature points, ‘el_avg’ element averages and ‘eval’ means integration over each term region.

term_mode : str

The term call mode - some terms support different call modes and depending on the call mode different values are returned.

extra_args : dict, optional

Extra arguments to be passed to terms in the expression.

verbose : bool

If False, reduce verbosity.

kwargs : dict, optional

The variables (dictionary of (variable name) : (Variable instance)) to be used in the expression.

min_level : int

The minimum required level of mesh refinement.

max_level : int

The maximum level of mesh refinement.

eps : float

The relative tolerance parameter of mesh adaptivity.

Returns:

out : dict

The output dictionary.

sfepy.discrete.fem.fields_base.get_eval_expression(expression, ig, fields, materials, variables, functions=None, mode='eval', term_mode=None, extra_args=None, verbose=True, kwargs=None)[source]

Get the function for evaluating an expression given a list of elements, and reference element coordinates.