A representation of finite element variational forms. More...

#include <Form.h>

Public Types
using	scalar_type = T
	Scalar type.

using	geometry_type = U
	Geometry type.

Public Member Functions
template<typename X > requires std::is_convertible_v< std::remove_cvref_t<X>, std::map<IntegralType, std::vector<integral_data< scalar_type, geometry_type>>>>
	Form (const std::vector< std::shared_ptr< const FunctionSpace< geometry_type > > > &V, X &&integrals, const std::vector< std::shared_ptr< const Function< scalar_type, geometry_type > > > &coefficients, const std::vector< std::shared_ptr< const Constant< scalar_type > > > &constants, bool needs_facet_permutations, const std::map< std::shared_ptr< const mesh::Mesh< geometry_type > >, std::span< const std::int32_t > > &entity_maps, std::shared_ptr< const mesh::Mesh< geometry_type > > mesh=nullptr)
	Create a finite element form.

	Form (const Form &form)=delete
	Copy constructor.

	Form (Form &&form)=default
	Move constructor.

virtual	~Form ()=default
	Destructor.

int	rank () const
	Rank of the form.

std::shared_ptr< const mesh::Mesh< geometry_type > >	mesh () const
	Extract common mesh for the form.

const std::vector< std::shared_ptr< const FunctionSpace< geometry_type > > > &	function_spaces () const
	Function spaces for all arguments.

std::function< void(scalar_type , const scalar_type , const scalar_type , const geometry_type , const int , const uint8_t )>	kernel (IntegralType type, int i) const
	Get the kernel function for integral `i` on given domain type.

std::set< IntegralType >	integral_types () const
	Get types of integrals in the form.

int	num_integrals (IntegralType type) const
	Number of integrals on given domain type.

std::vector< int >	active_coeffs (IntegralType type, std::size_t i) const
	Indices of coefficients that are active for a given integral (kernel).

std::vector< int >	integral_ids (IntegralType type) const
	Get the IDs for integrals (kernels) for given integral type.

std::span< const std::int32_t >	domain (IntegralType type, int i) const
	Get the list of mesh entity indices for the ith integral (kernel) of a given type.

std::vector< std::int32_t >	domain (IntegralType type, int i, const mesh::Mesh< geometry_type > &mesh) const
	Compute the list of entity indices in `mesh` for the ith integral (kernel) of a given type (i.e. cell, exterior facet, or interior facet).

const std::vector< std::shared_ptr< const Function< scalar_type, geometry_type > > > &	coefficients () const
	Access coefficients.

bool	needs_facet_permutations () const
	Get bool indicating whether permutation data needs to be passed into these integrals.

std::vector< int >	coefficient_offsets () const
	Offset for each coefficient expansion array on a cell.

const std::vector< std::shared_ptr< const Constant< scalar_type > > > &	constants () const
	Access constants.

Detailed Description

template<dolfinx::scalar T, std::floating_point U = dolfinx::scalar_value_type_t<T>>
class dolfinx::fem::Form< T, U >

A representation of finite element variational forms.

A note on the order of trial and test spaces: FEniCS numbers argument spaces starting with the leading dimension of the corresponding tensor (matrix). In other words, the test space is numbered 0 and the trial space is numbered 1. However, in order to have a notation that agrees with most existing finite element literature, in particular

\[ a = a(u, v) \]

the spaces are numbered from right to left

\[ a: V_1 \times V_0 \rightarrow \mathbb{R} \]

This is reflected in the ordering of the spaces that should be supplied to generated subclasses. In particular, when a bilinear form is initialized, it should be initialized as a(V_1, V_0) = / ..., where V_1 is the trial space and V_0 is the test space. However, when a form is initialized by a list of argument spaces (the variable function_spaces in the constructors below), the list of spaces should start with space number 0 (the test space) and then space number 1 (the trial space).

Template Parameters

T	Scalar type in the form.
U	Float (real) type used for the finite element and geometry.
Kern	Element kernel.

Constructor & Destructor Documentation

◆ Form()

template<dolfinx::scalar T, std::floating_point U = dolfinx::scalar_value_type_t<T>>

template<typename X >
requires std::is_convertible_v< std::remove_cvref_t<X>, std::map<IntegralType, std::vector<integral_data< scalar_type, geometry_type>>>>

Form	(	const std::vector< std::shared_ptr< const FunctionSpace< geometry_type > > > &	V,
		X &&	integrals,
		const std::vector< std::shared_ptr< const Function< scalar_type, geometry_type > > > &	coefficients,
		const std::vector< std::shared_ptr< const Constant< scalar_type > > > &	constants,
		bool	needs_facet_permutations,
		const std::map< std::shared_ptr< const mesh::Mesh< geometry_type > >, std::span< const std::int32_t > > &	entity_maps,
		std::shared_ptr< const mesh::Mesh< geometry_type > >	mesh = nullptr )

inline

Create a finite element form.

Note: User applications will normally call a factory function rather using this interface directly.

Parameters

[in]	V	Function spaces for the form arguments.
[in]	integrals	The integrals in the form. For each integral type, there is a list of integral data.
[in]	coefficients	Coefficients in the form.
[in]	constants	Constants in the form.
[in]	needs_facet_permutations	Set to `true` is any of the integration kernels require cell permutation data.
[in]	entity_maps	If any trial functions, test functions, or coefficients in the form are not defined over the same mesh as the integration domain, `entity_maps` must be supplied. For each key (a mesh, different to the integration domain mesh) a map should be provided relating the entities in the integration domain mesh to the entities in the key mesh e.g. for a pair (msh, emap) in `entity_maps`, `emap[i]` is the entity in `msh` corresponding to entity `i` in the integration domain mesh.
[in]	mesh	Mesh of the domain. This is required when there are no argument functions from which the mesh can be extracted, e.g. for functionals.

Note: For the single domain case, pass an empty entity_maps.

Precondition: The integral data in integrals must be sorted by domain (domain id).

Member Function Documentation

◆ active_coeffs()

template<dolfinx::scalar T, std::floating_point U = dolfinx::scalar_value_type_t<T>>

std::vector< int > active_coeffs	(	IntegralType	type,
		std::size_t	i ) const

inline

Indices of coefficients that are active for a given integral (kernel).

A form is split into multiple integrals (kernels) and each integral might container only a subset of all coefficients in the form. This function returns an indicator array for a given integral kernel that signifies which coefficients are present.

Parameters

[in]	type	Integral type.
[in]	i	Index of the integral.

◆ coefficient_offsets()

template<dolfinx::scalar T, std::floating_point U = dolfinx::scalar_value_type_t<T>>

std::vector< int > coefficient_offsets ( ) const

inline

Offset for each coefficient expansion array on a cell.

Used to pack data for multiple coefficients in a flat array. The last entry is the size required to store all coefficients.

◆ domain() [1/2]

template<dolfinx::scalar T, std::floating_point U = dolfinx::scalar_value_type_t<T>>

std::span< const std::int32_t > domain	(	IntegralType	type,
		int	i ) const

inline

Get the list of mesh entity indices for the ith integral (kernel) of a given type.

For IntegralType::cell, returns a list of cell indices.

For IntegralType::exterior_facet, returns a list of (cell_index, local_facet_index) pairs. Data is flattened with row-major layout, shape=(num_facets, 2).

For IntegralType::interior_facet, returns list of tuples of the form (cell_index_0, local_facet_index_0, cell_index_1, / local_facet_index_1). Data is flattened with row-major layout, shape=(num_facets, 4).

Parameters

[in]	type	Integral domain type.
[in]	i	Integral ID, i.e. (sub)domain index.

Returns: List of active entities for the given integral (kernel).

◆ domain() [2/2]

template<dolfinx::scalar T, std::floating_point U = dolfinx::scalar_value_type_t<T>>

std::vector< std::int32_t > domain	(	IntegralType	type,
		int	i,
		const mesh::Mesh< geometry_type > &	mesh ) const

inline

Compute the list of entity indices in mesh for the ith integral (kernel) of a given type (i.e. cell, exterior facet, or interior facet).

Parameters

type	Integral type.
i	Integral ID, i.e. the (sub)domain index.
mesh	The mesh the entities are numbered with respect to.

Returns: List of active entities in mesh for the given integral.

◆ function_spaces()

template<dolfinx::scalar T, std::floating_point U = dolfinx::scalar_value_type_t<T>>

const std::vector< std::shared_ptr< const FunctionSpace< geometry_type > > > & function_spaces ( ) const

inline

Function spaces for all arguments.

Returns: Function spaces.

◆ integral_ids()

template<dolfinx::scalar T, std::floating_point U = dolfinx::scalar_value_type_t<T>>

std::vector< int > integral_ids ( IntegralType type ) const

inline

Get the IDs for integrals (kernels) for given integral type.

The IDs correspond to the domain IDs which the integrals are defined for in the form. ID=-1 is the default integral over the whole domain.

Parameters

[in] type Integral type.

Returns: List of IDs for given integral type.

◆ integral_types()

template<dolfinx::scalar T, std::floating_point U = dolfinx::scalar_value_type_t<T>>

std::set< IntegralType > integral_types ( ) const

inline

Get types of integrals in the form.

Returns: Integrals types.

◆ kernel()

template<dolfinx::scalar T, std::floating_point U = dolfinx::scalar_value_type_t<T>>

std::function< void(scalar_type , const scalar_type , const scalar_type , const geometry_type , const int , const uint8_t )> kernel	(	IntegralType	type,
		int	i ) const

inline

Get the kernel function for integral i on given domain type.

Parameters

[in]	type	Integral type.
[in]	i	Domain identifier (index).

Returns: Function to call for tabulate_tensor.

◆ mesh()

template<dolfinx::scalar T, std::floating_point U = dolfinx::scalar_value_type_t<T>>

std::shared_ptr< const mesh::Mesh< geometry_type > > mesh ( ) const

inline

Extract common mesh for the form.

Returns: The mesh.

◆ needs_facet_permutations()

template<dolfinx::scalar T, std::floating_point U = dolfinx::scalar_value_type_t<T>>

bool needs_facet_permutations ( ) const

inline

Get bool indicating whether permutation data needs to be passed into these integrals.

Returns: True if cell permutation data is required

◆ num_integrals()

template<dolfinx::scalar T, std::floating_point U = dolfinx::scalar_value_type_t<T>>

int num_integrals ( IntegralType type ) const

inline

Number of integrals on given domain type.

Parameters

[in] type Integral type.

Returns: Number of integrals.

◆ rank()

template<dolfinx::scalar T, std::floating_point U = dolfinx::scalar_value_type_t<T>>

int rank ( ) const

inline

Rank of the form.

bilinear form = 2, linear form = 1, functional = 0, etc.

Returns: The rank of the form

The documentation for this class was generated from the following files:

/__w/dolfinx/dolfinx/cpp/dolfinx/fem/assembler.h
/__w/dolfinx/dolfinx/cpp/dolfinx/fem/Form.h

Public Types

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Form()

Member Function Documentation

◆ active_coeffs()

◆ coefficient_offsets()

◆ domain() [1/2]

◆ domain() [2/2]

◆ function_spaces()

◆ integral_ids()

◆ integral_types()

◆ kernel()

◆ mesh()

◆ needs_facet_permutations()

◆ num_integrals()

◆ rank()