DOLFIN-X
DOLFIN-X C++ interface
Namespaces | Classes | Functions
dolfinx::fem Namespace Reference

Finite element method functionality. More...

Namespaces

 impl
 Implementation of assembly.
 

Classes

class  CoordinateElement
 This class manages coordinate mappings for isoparametric cells. More...
 
class  DirichletBC
 Interface for setting (strong) Dirichlet boundary conditions. More...
 
class  DiscreteOperators
 Discrete gradient operators providing derivatives of functions. More...
 
class  DofMap
 Degree-of-freedom map. More...
 
class  DofMapBuilder
 Builds a DofMap on a mesh::Mesh. More...
 
class  ElementDofLayout
 The class represents the degree-of-freedom (dofs) for an element. Dofs are associated with a mesh entity. This class also handles sub-space dofs, which are views into the parent dofs. More...
 
class  FiniteElement
 Finite Element, containing the dof layout on a reference element, and various methods for evaluating and transforming the basis. More...
 
class  Form
 Base class for variational forms. More...
 
class  FormCoefficients
 Storage for the coefficients of a Form consisting of Function and the Element objects they are defined on. More...
 
class  FormIntegrals
 Integrals of a Form, including those defined over cells, interior and exterior facets, and vertices. More...
 
class  ReferenceCellGeometry
 Tabulates the vertex positions for the reference cell. More...
 
class  SparsityPatternBuilder
 This class provides functions to compute the sparsity pattern based on DOF maps. More...
 

Functions

PetscScalar assemble_scalar (const Form &M)
 Assemble functional into scalar. Caller is responsible for accumulation across processes. More...
 
void assemble_vector (Vec b, const Form &L)
 Assemble linear form into an already allocated PETSc vector. Ghost contributions are not accumulated (not sent to owner). Caller is responsible for calling VecGhostUpdateBegin/End. More...
 
void assemble_vector (Eigen::Ref< Eigen::Matrix< PetscScalar, Eigen::Dynamic, 1 >> b, const Form &L)
 Assemble linear form into an Eigen vector. More...
 
void apply_lifting (Vec b, const std::vector< std::shared_ptr< const Form >> &a, const std::vector< std::vector< std::shared_ptr< const DirichletBC >>> &bcs1, const std::vector< Vec > &x0, double scale)
 Modify b such that: More...
 
void apply_lifting (Eigen::Ref< Eigen::Matrix< PetscScalar, Eigen::Dynamic, 1 >> b, const std::vector< std::shared_ptr< const Form >> &a, const std::vector< std::vector< std::shared_ptr< const DirichletBC >>> &bcs1, const std::vector< Eigen::Ref< const Eigen::Matrix< PetscScalar, Eigen::Dynamic, 1 >>> &x0, double scale)
 Modify b such that: More...
 
Eigen::SparseMatrix< PetscScalar, Eigen::RowMajor > assemble_matrix_eigen (const Form &a, const std::vector< std::shared_ptr< const DirichletBC >> &bcs)
 Assemble bilinear form into an Eigen Sparse matrix. More...
 
void assemble_matrix (Mat A, const Form &a, const std::vector< std::shared_ptr< const DirichletBC >> &bcs)
 Assemble bilinear form into a matrix. Matrix must already be initialised. Does not zero or finalise the matrix. More...
 
void assemble_matrix (Mat A, const Form &a, const std::vector< bool > &bc0, const std::vector< bool > &bc1)
 Assemble bilinear form into a matrix. Matrix must already be initialised. Does not zero or finalise the matrix. More...
 
void add_diagonal (Mat A, const function::FunctionSpace &V, const std::vector< std::shared_ptr< const DirichletBC >> &bcs, PetscScalar diagonal=1.0)
 Adds a value to the diagonal of the matrix for rows with a Dirichlet boundary conditions applied. This function is typically called after assembly. The assembly function zeroes Dirichlet rows and columns. This function adds the value only to rows that are locally owned, and therefore does not create a need for parallel communication. For block matrices, this function should normally be called only on the diagonal blocks, i.e. blocks for which the test and trial spaces are the same. More...
 
void add_diagonal (Mat A, const Eigen::Ref< const Eigen::Array< std::int32_t, Eigen::Dynamic, 1 >> &rows, PetscScalar diagonal=1.0)
 Adds a value to the diagonal of a matrix for specified rows. It is typically called after assembly. The assembly function zeroes Dirichlet rows and columns. For block matrices, this function should normally be called only on the diagonal blocks, i.e. blocks for which the test and trial spaces are the same. More...
 
void set_bc (Vec b, const std::vector< std::shared_ptr< const DirichletBC >> &bcs, const Vec x0, double scale=1.0)
 Set bc values in owned (local) part of the PETScVector, multiplied by 'scale'. The vectors b and x0 must have the same local size. The bcs should be on (sub-)spaces of the form L that b represents.
 
void set_bc (Eigen::Ref< Eigen::Matrix< PetscScalar, Eigen::Dynamic, 1 >> b, const std::vector< std::shared_ptr< const DirichletBC >> &bcs, const Eigen::Ref< const Eigen::Matrix< PetscScalar, Eigen::Dynamic, 1 >> &x0, double scale=1.0)
 Set bc values in owned (local) part of the PETScVector, multiplied by 'scale'. The vectors b and x0 must have the same local size. The bcs should be on (sub-)spaces of the form L that b represents.
 
void set_bc (Eigen::Ref< Eigen::Matrix< PetscScalar, Eigen::Dynamic, 1 >> b, const std::vector< std::shared_ptr< const DirichletBC >> &bcs, double scale=1.0)
 Set bc values in owned (local) part of the PETScVector, multiplied by 'scale'. The bcs should be on (sub-)spaces of the form L that b represents.
 
std::vector< std::vector< std::shared_ptr< const fem::DirichletBC > > > bcs_rows (const std::vector< const Form * > &L, const std::vector< std::shared_ptr< const fem::DirichletBC >> &bcs)
 Arrange boundary conditions by block. More...
 
std::vector< std::vector< std::vector< std::shared_ptr< const fem::DirichletBC > > > > bcs_cols (const std::vector< std::vector< std::shared_ptr< const Form >>> &a, const std::vector< std::shared_ptr< const DirichletBC >> &bcs)
 Arrange boundary conditions by block. More...
 
Eigen::Array< std::int32_t, Eigen::Dynamic, Eigen::Dynamic > locate_dofs_topological (const std::vector< std::reference_wrapper< function::FunctionSpace >> &V, const int dim, const Eigen::Ref< const Eigen::ArrayXi > &entities, bool remote=true)
 Build an array of degree-of-freedom indices that are associated with give mesh entities (topological) More...
 
Eigen::Array< std::int32_t, Eigen::Dynamic, Eigen::Dynamic > locate_dofs_geometrical (const std::vector< std::reference_wrapper< function::FunctionSpace >> &V, const std::function< Eigen::Array< bool, Eigen::Dynamic, 1 >(const Eigen::Ref< const Eigen::Array< double, 3, Eigen::Dynamic, Eigen::RowMajor >> &)> &marker)
 Build an array of degree-of-freedom indices based on coordinates of the degree-of-freedom (geometric). More...
 
Eigen::Array< int, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > compute_dof_permutations (const mesh::Topology &topology, const fem::ElementDofLayout &dof_layout)
 Return the dof permutations for all cells. Each row contains the numbers from 0 to (number of dofs on reference - 1) permuted so that edges are oriented towards the higher global vertex index. More...
 
std::array< std::vector< std::shared_ptr< const function::FunctionSpace > >, 2 > block_function_spaces (const Eigen::Ref< const Eigen::Array< const fem::Form *, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor >> &a)
 Extract FunctionSpaces for (0) rows blocks and (1) columns blocks from a rectangular array of bilinear forms. Raises an exception if there is an inconsistency. e.g. if each form in row i does not have the same test space then an exception is raised. More...
 
la::PETScMatrix create_matrix (const Form &a)
 Create a matrix. More...
 
la::SparsityPattern create_sparsity_pattern (const Form &a)
 Create a sparsity pattern for a given form. The pattern is not finalised, i.e. the caller is responsible for calling SparsityPattern::assemble. More...
 
la::PETScMatrix create_matrix_block (const Eigen::Ref< const Eigen::Array< const fem::Form *, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor >> &a)
 Initialise monolithic matrix for an array for bilinear forms. Matrix is not zeroed.
 
la::PETScMatrix create_matrix_nest (const Eigen::Ref< const Eigen::Array< const fem::Form *, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor >> &a)
 Create nested (MatNest) matrix. Matrix is not zeroed.
 
la::PETScVector create_vector_block (const std::vector< const common::IndexMap * > &maps)
 Initialise monolithic vector. Vector is not zeroed.
 
la::PETScVector create_vector_nest (const std::vector< const common::IndexMap * > &maps)
 Create nested (VecNest) vector. Vector is not zeroed.
 
std::int64_t get_global_offset (const std::vector< const common::IndexMap * > &maps, const int field, const std::int64_t index)
 
ElementDofLayout create_element_dof_layout (const ufc_dofmap &dofmap, const mesh::CellType cell_type, const std::vector< int > &parent_map={})
 Create an ElementDofLayout from a ufc_dofmap.
 
DofMap create_dofmap (MPI_Comm comm, const ufc_dofmap &dofmap, mesh::Topology &topology)
 Create dof map on mesh from a ufc_dofmap. More...
 
std::shared_ptr< Formcreate_form (ufc_form *(*fptr)(), const std::vector< std::shared_ptr< const function::FunctionSpace >> &spaces)
 Create a form from a form_create function returning a pointer to a ufc_form, taking care of memory allocation. More...
 
Form create_form (const ufc_form &ufc_form, const std::vector< std::shared_ptr< const function::FunctionSpace >> &spaces)
 Create a Form from UFC input. More...
 
std::vector< std::tuple< int, std::string, std::shared_ptr< function::Function > > > get_coeffs_from_ufc_form (const ufc_form &ufc_form)
 Extract coefficients from a UFC form.
 
std::vector< std::pair< std::string, std::shared_ptr< const function::Constant > > > get_constants_from_ufc_form (const ufc_form &ufc_form)
 Extract coefficients from a UFC form.
 
fem::CoordinateElement create_coordinate_map (const ufc_coordinate_mapping &ufc_cmap)
 Create a CoordinateElement from ufc. More...
 
fem::CoordinateElement create_coordinate_map (ufc_coordinate_mapping *(*fptr)())
 Create a CoordinateElement from ufc. More...
 
std::shared_ptr< function::FunctionSpacecreate_functionspace (ufc_function_space *(*fptr)(const char *), const std::string function_name, std::shared_ptr< mesh::Mesh > mesh)
 Create FunctionSpace from UFC. More...
 
Eigen::Array< PetscScalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > pack_coefficients (const fem::Form &form)
 Pack form coefficients ready for assembly.
 
Eigen::Array< PetscScalar, Eigen::Dynamic, 1 > pack_constants (const fem::Form &form)
 Pack form constants ready for assembly.
 

Detailed Description

Finite element method functionality.

Classes and algorithms for finite element method operations, e.g. assembly.

Function Documentation

◆ add_diagonal() [1/2]

void dolfinx::fem::add_diagonal ( Mat  A,
const Eigen::Ref< const Eigen::Array< std::int32_t, Eigen::Dynamic, 1 >> &  rows,
PetscScalar  diagonal = 1.0 
)

Adds a value to the diagonal of a matrix for specified rows. It is typically called after assembly. The assembly function zeroes Dirichlet rows and columns. For block matrices, this function should normally be called only on the diagonal blocks, i.e. blocks for which the test and trial spaces are the same.

Parameters
[in,out]AThe matrix to add diagonal values to
[in]rowsThe rows, in local indices, for which to add a value to the diagonal
[in]diagonalThe value to add to the diagonal for the specified rows

◆ add_diagonal() [2/2]

void dolfinx::fem::add_diagonal ( Mat  A,
const function::FunctionSpace V,
const std::vector< std::shared_ptr< const DirichletBC >> &  bcs,
PetscScalar  diagonal = 1.0 
)

Adds a value to the diagonal of the matrix for rows with a Dirichlet boundary conditions applied. This function is typically called after assembly. The assembly function zeroes Dirichlet rows and columns. This function adds the value only to rows that are locally owned, and therefore does not create a need for parallel communication. For block matrices, this function should normally be called only on the diagonal blocks, i.e. blocks for which the test and trial spaces are the same.

Parameters
[in,out]AThe matrix to add diagonal values to
[in]VThe function space for the rows and columns of the matrix. It is used to extract only the Dirichlet boundary conditions that are define on V or subspaces of V.
[in]bcsThe Dirichlet boundary condtions
[in]diagonalThe value to add to the diagonal for rows with a boundary condition applied

◆ apply_lifting() [1/2]

void dolfinx::fem::apply_lifting ( Eigen::Ref< Eigen::Matrix< PetscScalar, Eigen::Dynamic, 1 >>  b,
const std::vector< std::shared_ptr< const Form >> &  a,
const std::vector< std::vector< std::shared_ptr< const DirichletBC >>> &  bcs1,
const std::vector< Eigen::Ref< const Eigen::Matrix< PetscScalar, Eigen::Dynamic, 1 >>> &  x0,
double  scale 
)

Modify b such that:

b <- b - scale * A_j (g_j - x0_j)

where j is a block (nest) index. For a non-blocked problem j = 0. The boundary conditions bcs1 are on the trial spaces V_j. The forms in [a] must have the same test space as L (from which b was built), but the trial space may differ. If x0 is not supplied, then it is treated as zero.

Ghost contributions are not accumulated (not sent to owner). Caller is responsible for calling VecGhostUpdateBegin/End.

◆ apply_lifting() [2/2]

void dolfinx::fem::apply_lifting ( Vec  b,
const std::vector< std::shared_ptr< const Form >> &  a,
const std::vector< std::vector< std::shared_ptr< const DirichletBC >>> &  bcs1,
const std::vector< Vec > &  x0,
double  scale 
)

Modify b such that:

b <- b - scale * A_j (g_j - x0_j)

where j is a block (nest) index. For a non-blocked problem j = 0. The boundary conditions bcs1 are on the trial spaces V_j. The forms in [a] must have the same test space as L (from which b was built), but the trial space may differ. If x0 is not supplied, then it is treated as zero.

Ghost contributions are not accumulated (not sent to owner). Caller is responsible for calling VecGhostUpdateBegin/End.

◆ assemble_matrix() [1/2]

void dolfinx::fem::assemble_matrix ( Mat  A,
const Form a,
const std::vector< bool > &  bc0,
const std::vector< bool > &  bc1 
)

Assemble bilinear form into a matrix. Matrix must already be initialised. Does not zero or finalise the matrix.

Parameters
[in,out]AThe matrix to assemble in to. Matrix must be initialised.
[in]aThe bilinear form to assemble
[in]bc0Boundary condition markers for the rows. If bc[i] is true then rows i in A will be zeroed. The index i is a local index.
[in]bc1Boundary condition markers for the columns. If bc[i] is true then rows i in A will be zeroed. The index i is a local index.

◆ assemble_matrix() [2/2]

void dolfinx::fem::assemble_matrix ( Mat  A,
const Form a,
const std::vector< std::shared_ptr< const DirichletBC >> &  bcs 
)

Assemble bilinear form into a matrix. Matrix must already be initialised. Does not zero or finalise the matrix.

Parameters
[in,out]AThe PETsc matrix to assemble the form into. The matrix size/layout must be initialised before calling this function. The matrix is not zeroed and it is not finalised (shared entries not communicated).
[in]aThe bilinear from to assemble
[in]bcsBoundary conditions to apply. For boundary condition dofs the row and column are zeroed. The diagonal entry is not set.

◆ assemble_matrix_eigen()

Eigen::SparseMatrix< PetscScalar, Eigen::RowMajor > dolfinx::fem::assemble_matrix_eigen ( const Form a,
const std::vector< std::shared_ptr< const DirichletBC >> &  bcs 
)

Assemble bilinear form into an Eigen Sparse matrix.

Parameters
[in]aThe bilinear from to assemble
[in]bcsBoundary conditions to apply. For boundary condition dofs the row and column are zeroed. The diagonal entry is not set.

◆ assemble_scalar()

PetscScalar dolfinx::fem::assemble_scalar ( const Form M)

Assemble functional into scalar. Caller is responsible for accumulation across processes.

Parameters
[in]MThe form (functional) to assemble
Returns
The contribution to the form (functional) from the local process

◆ assemble_vector() [1/2]

void dolfinx::fem::assemble_vector ( Eigen::Ref< Eigen::Matrix< PetscScalar, Eigen::Dynamic, 1 >>  b,
const Form L 
)

Assemble linear form into an Eigen vector.

Parameters
[in,out]bThe Eigen vector to be assembled. It will not be zeroed before assembly.
[in]LThe linear forms to assemble into b

◆ assemble_vector() [2/2]

void dolfinx::fem::assemble_vector ( Vec  b,
const Form L 
)

Assemble linear form into an already allocated PETSc vector. Ghost contributions are not accumulated (not sent to owner). Caller is responsible for calling VecGhostUpdateBegin/End.

Parameters
[in,out]bThe PETsc vector to assemble the form into. The vector must already be initialised with the correct size. The process-local contribution of the form is assembled into this vector. It is not zeroed before assembly.
[in]LThe linear form to assemble

◆ bcs_cols()

std::vector< std::vector< std::vector< std::shared_ptr< const fem::DirichletBC > > > > dolfinx::fem::bcs_cols ( const std::vector< std::vector< std::shared_ptr< const Form >>> &  a,
const std::vector< std::shared_ptr< const DirichletBC >> &  bcs 
)

Arrange boundary conditions by block.

Parameters
[in]aBiinear forms for each block
[in]bcsBoundary conditions
Returns
The boundary conditions collected by block, i.e. bcs_block[i] is the list of boundary conditions applied to the trial space of a[i]. The order within bcs_block[i] preserves the input order of the bcs array.

◆ bcs_rows()

std::vector< std::vector< std::shared_ptr< const fem::DirichletBC > > > dolfinx::fem::bcs_rows ( const std::vector< const Form * > &  L,
const std::vector< std::shared_ptr< const fem::DirichletBC >> &  bcs 
)

Arrange boundary conditions by block.

Parameters
[in]LLinear forms for each block
[in]bcsBoundary conditions
Returns
The boundary conditions collected by block, i.e. bcs_block[i] is the list of boundary conditions applied to L[i]. The order within bcs_block[i] preserves the input order of the bcs array.

◆ block_function_spaces()

std::array< std::vector< std::shared_ptr< const function::FunctionSpace > >, 2 > dolfinx::fem::block_function_spaces ( const Eigen::Ref< const Eigen::Array< const fem::Form *, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor >> &  a)

Extract FunctionSpaces for (0) rows blocks and (1) columns blocks from a rectangular array of bilinear forms. Raises an exception if there is an inconsistency. e.g. if each form in row i does not have the same test space then an exception is raised.

Parameters
[in]aA rectangular block on bilinear forms
Returns
Function spaces for each row blocks (0) and for each column blocks (1).

◆ compute_dof_permutations()

Eigen::Array< int, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > dolfinx::fem::compute_dof_permutations ( const mesh::Topology topology,
const fem::ElementDofLayout dof_layout 
)

Return the dof permutations for all cells. Each row contains the numbers from 0 to (number of dofs on reference - 1) permuted so that edges are oriented towards the higher global vertex index.

Parameters
[in]topologyThe mesh topology
[in]dof_layoutThe layout of dofs on a each cell
Returns
The permutations

◆ create_coordinate_map() [1/2]

fem::CoordinateElement dolfinx::fem::create_coordinate_map ( const ufc_coordinate_mapping &  ufc_cmap)

Create a CoordinateElement from ufc.

Parameters
[in]ufc_cmapUFC coordinate mapping
Returns
A DOLFINX coordinate map

◆ create_coordinate_map() [2/2]

fem::CoordinateElement dolfinx::fem::create_coordinate_map ( ufc_coordinate_mapping *(*)()  fptr)

Create a CoordinateElement from ufc.

Parameters
[in]fptrFunction Pointer to a ufc_function_coordinate_map function
Returns
A DOLFINX coordinate map

◆ create_dofmap()

fem::DofMap dolfinx::fem::create_dofmap ( MPI_Comm  comm,
const ufc_dofmap &  dofmap,
mesh::Topology topology 
)

Create dof map on mesh from a ufc_dofmap.

Parameters
[in]commMPI communicator
[in]dofmapThe ufc_dofmap
[in]topologyThe mesh topology

◆ create_form() [1/2]

fem::Form dolfinx::fem::create_form ( const ufc_form &  ufc_form,
const std::vector< std::shared_ptr< const function::FunctionSpace >> &  spaces 
)

Create a Form from UFC input.

Parameters
[in]ufc_formThe UFC form
[in]spacesVector of function spaces

◆ create_form() [2/2]

std::shared_ptr< fem::Form > dolfinx::fem::create_form ( ufc_form *(*)()  fptr,
const std::vector< std::shared_ptr< const function::FunctionSpace >> &  spaces 
)

Create a form from a form_create function returning a pointer to a ufc_form, taking care of memory allocation.

Parameters
[in]fptrpointer to a function returning a pointer to ufc_form
[in]spacesfunction spaces
Returns
Form

◆ create_functionspace()

std::shared_ptr< function::FunctionSpace > dolfinx::fem::create_functionspace ( ufc_function_space *(*)(const char *)  fptr,
const std::string  function_name,
std::shared_ptr< mesh::Mesh mesh 
)

Create FunctionSpace from UFC.

Parameters
[in]fptrFunction Pointer to a ufc_function_space_create function
[in]function_nameName of a function whose function space to create. Function name is the name of Python variable for ufl.Coefficient, ufl.TrialFunction or ufl.TestFunction as defined in the UFL file.
[in]meshMesh
Returns
The created FunctionSpace

◆ create_matrix()

la::PETScMatrix dolfinx::fem::create_matrix ( const Form a)

Create a matrix.

Parameters
[in]aA bilinear form
Returns
A matrix. The matrix is not zeroed.

◆ create_sparsity_pattern()

la::SparsityPattern dolfinx::fem::create_sparsity_pattern ( const Form a)

Create a sparsity pattern for a given form. The pattern is not finalised, i.e. the caller is responsible for calling SparsityPattern::assemble.

Parameters
[in]aA bilinear form
Returns
The corresponding sparsity pattern

◆ get_global_offset()

std::int64_t dolfinx::fem::get_global_offset ( const std::vector< const common::IndexMap * > &  maps,
const int  field,
const std::int64_t  index 
)
Todo:
Update name an check efficiency

Get new global offset in 'spliced' indices

◆ locate_dofs_geometrical()

Eigen::Array< std::int32_t, Eigen::Dynamic, Eigen::Dynamic > dolfinx::fem::locate_dofs_geometrical ( const std::vector< std::reference_wrapper< function::FunctionSpace >> &  V,
const std::function< Eigen::Array< bool, Eigen::Dynamic, 1 >(const Eigen::Ref< const Eigen::Array< double, 3, Eigen::Dynamic, Eigen::RowMajor >> &)> &  marker 
)

Build an array of degree-of-freedom indices based on coordinates of the degree-of-freedom (geometric).

Finds degrees of freedom whose geometric coordinate is true for the provided marking function.

Attention
This function is slower than the topological version
Parameters
[in]VThe function (sub)space(s) on which degrees of freedom will be located. The spaces must share the same mesh and element type.
[in]markerFunction marking tabulated degrees of freedom
Returns
Array of local DOF indices in the spaces V[0] (and V[1] is two spaces are passed in). If two spaces are passed in, the (i, 0) entry is the DOF index in the space V[0] and (i, 1) is the correspinding DOF entry in the space V[1].

◆ locate_dofs_topological()

Eigen::Array< std::int32_t, Eigen::Dynamic, Eigen::Dynamic > dolfinx::fem::locate_dofs_topological ( const std::vector< std::reference_wrapper< function::FunctionSpace >> &  V,
const int  dim,
const Eigen::Ref< const Eigen::ArrayXi > &  entities,
bool  remote = true 
)

Build an array of degree-of-freedom indices that are associated with give mesh entities (topological)

Finds degrees-of-freedom which belong to provided mesh entities. Note that degrees-of-freedom for discontinuous elements are associated with the cell even if they may appear to be associated with a facet/edge/vertex.

Parameters
[in]VThe function (sub)space(s) on which degrees-of-freedom (DOFs) will be located. The spaces must share the same mesh and element type.
[in]dimTopological dimension of mesh entities on which degrees-of-freedom will be located
[in]entitiesIndices of mesh entities. All DOFs associated with the closure of these indices will be returned
[in]remoteTrue to return also "remotely located" degree-of-freedom indices. Remotely located degree-of-freedom indices are local/owned by the current process, but which the current process cannot identify because it does not recognize mesh entity as a marked. For example, a boundary condition dof at a vertex where this process does not have the associated boundary facet. This commonly occurs with partitioned meshes.
Returns
Array of local DOF indices in the spaces V[0] (and V[1] is two spaces are passed in). If two spaces are passed in, the (i, 0) entry is the DOF index in the space V[0] and (i, 1) is the correspinding DOF entry in the space V[1].