Local-to-global Degree of Freedom table. More...

Inheritance diagram for Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >:

Collaboration diagram for Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >:

Public Types
typedef std::unordered_map< int, std::vector< global_dof_fromface_type > >	Container_fromface

typedef fe_type::continuity_type	continuity_type

typedef reference_convex_type::super	convex_type

typedef dof_marker_type::value_type	dof2marker

typedef dof_element_type::const_iterator	dof_const_iterator

typedef std::map< size_type, std::list< local_dof_type > >	dof_element_type
	Type that hold the map between a global dof and the elements.

using	dof_from_edge_type = DofFromEdge< doftable_type, fe_type >

typedef dof_element_type::iterator	dof_iterator

typedef dof_map_type::const_iterator	dof_map_const_iterator

typedef dof_map_type::iterator	dof_map_iterator

typedef std::unordered_map< dof_type, size_type >	dof_map_type

typedef boost::bimap< size_type, boost::bimaps::multiset_of< size_type > >	dof_marker_type

typedef std::vector< dof_point_type >::const_iterator	dof_periodic_points_const_iterator

typedef std::vector< dof_point_type >::iterator	dof_periodic_points_iterator

typedef std::vector< dof_point_type >	dof_periodic_points_type

typedef boost::tuple< node_type, size_type, uint16_type >	dof_point_type

typedef std::unordered_map< size_type, dof_point_type >::const_iterator	dof_points_const_iterator

typedef std::unordered_map< size_type, dof_point_type >::iterator	dof_points_iterator

typedef std::unordered_map< size_type, dof_point_type >	dof_points_type

typedef std::map< size_type, std::set< size_type > >	dof_procset_type

typedef dof_table::value_type	dof_relation

typedef boost::bimap< bimaps::set_of< localdof_type >, bimaps::multiset_of< globaldof_type > >	dof_table

typedef std::tuple< uint16_type, size_type >	dof_type

using	doftable_type = self_type

typedef element_type::edge_permutation_type	edge_permutation_type

typedef mesh_type::edge_type	edge_type

typedef mesh_type::element_const_iterator	element_const_iterator

typedef boost::tuple< element_type const , face_type const >	element_face_pair_type

typedef mesh_type::element_type	element_type

typedef std::vector< global_dof_fromface_type >::const_iterator	face_local_dof_const_iterator

typedef element_type::face_permutation_type	face_permutation_type

typedef ublas::vector< bool >	face_sign_info_type
	This type is useful to construct the sign map in the modal case.

typedef mesh_type::face_type	face_type

typedef std::shared_ptr< FEType >	fe_ptrtype

typedef FEType	fe_type

typedef dof_table::right_const_iterator	global_dof_const_iterator

using	global_dof_from_entity_type = EntityDof< size_type >

typedef FaceDof< size_type >	global_dof_fromface_type
	A global dof from face is defined by -its index in the global table -its sign -bool : periodicity -local number in the element.

typedef dof_table::right_iterator	global_dof_iterator

typedef Dof< size_type >	global_dof_type
	A global dof is defined by its index in the global table and by its sign.

using	globaldof_type = global_dof_type

typedef mesh_type::gm_ptrtype	gm_ptrtype

typedef mesh_type::gm_type	gm_type

typedef std::map< int, global_dof_type >	indices_per_element_type

typedef std::list< local_dof_type >::const_iterator	ldof_const_iterator

typedef dof_table::left_const_iterator	local_dof_const_iterator

typedef dof_table::left_iterator	local_dof_iterator

typedef LocalDofSet< nDofComponents(), size_type >	local_dof_set_type

typedef boost::tuple< size_type, uint16_type, uint16_type, uint16_type >	local_dof_type
	Tuple that holds a size_type `elt` 1 uint16_type `l` and 1 uint16_type ent `elt` shall be an element index `l` shall be the local index of the dof in the element `ent` shall be the entity the dof belongs to (0: vertex, 1: edge, 2: face, 3: volume)

typedef LocalDof< nDofComponents(), size_type >	localdof_type
	Type for the localToGlobal table.

typedef Eigen::Matrix< int, Eigen::Dynamic, 1 >	localglobal_indices_type

typedef fe_type::matrix_type	matrix_type

using	mesh_marker_type = typename element_type::marker_type

typedef super::mesh_support_base_ptrtype	mesh_support_base_ptrtype

typedef std::shared_ptr< mesh_support_type >	mesh_support_ptrtype

typedef MeshSupport< mesh_type >	mesh_support_type

typedef MeshType	mesh_type
	mesh type

typedef fe_type::SSpace::type	mortar_fe_type

typedef MortarType	mortar_type

typedef node< value_type >::type	node_type

typedef std::multimap< size_type, periodic_dof_type >	periodic_dof_map_type

typedef boost::tuple< size_type, uint16_type, uint16_type, size_type, uint16_type >	periodic_dof_type

typedef periodic_element_list_type::const_iterator	periodic_element_list_const_iterator

typedef periodic_element_list_type::iterator	periodic_element_list_iterator

typedef std::list< element_face_pair_type >	periodic_element_list_type

typedef PeriodicityType	periodicity_type

typedef ublas::vector< uint16_type >	permutation_vector_type
	Type for the permutations to be done in the faces.

using	pidtodofid_type = std::pair< std::unordered_map< size_type, size_type >, std::unordered_map< size_type, size_type > >
	point id to dof id relation type

typedef fe_type::points_type	points_type

typedef std::tuple< uint16_type &, size_type & >	ref_shift_type

typedef fe_type::reference_convex_type	reference_convex_type

using	self_type = DofTable< MeshType, FEType, PeriodicityType, MortarType >

using	size_type = typename mesh_type::size_type

typedef fe_type::value_type	value_type

using	vector_indices_type = std::unordered_map< size_type, localglobal_indices_type, std::hash< size_type >, std::equal_to< size_type >, Eigen::aligned_allocator< std::pair< const size_type, localglobal_indices_type > > >

Public Types inherited from Feel::DofTableBase< MeshType::size_type >
typedef FaceDof< size_type >	global_dof_fromface_type

typedef Dof< size_type >	global_dof_type

typedef std::shared_ptr< MeshSupportBase >	mesh_support_base_ptrtype

using	size_type = MeshType::size_type

Public Member Functions
periodic_element_list_const_iterator	beginPeriodicElements () const

void	build (mesh_type &M)
	build the dof map

void	build (mesh_type *M)
	build the dof map

void	build (std::shared_ptr< mesh_type > &M)
	build the dof map

void	clearMapGDof ()
	clear the dictionary

size_type	dofIndex (size_type dof) const
	insted of creating the dof indices on the fly, get them from a vector. More...

const dof_point_type &	dofPoint (size_type i) const

dof_points_iterator	dofPointBegin ()

dof_points_const_iterator	dofPointBegin () const

dof_points_iterator	dofPointEnd ()

dof_points_const_iterator	dofPointEnd () const

dof_points_type const &	dofPoints () const

	DofTable (const DofTable &dof2)
	copy constructor More...

	DofTable (fe_ptrtype const &_fe, periodicity_type const &periodicity, WorldComm const &_worldComm)
	The minimal constructor. More...

	DofTable (mesh_type &mesh, fe_ptrtype const &_fe, periodicity_type const &periodicity, WorldComm const &_worldComm)
	Constructor accepting a mesh as parameter. More...

	DofTable (WorldComm const &_worldComm)

DofTableExtendedType	dofTableExtended () const noexcept

void	dump () const

std::vector< global_dof_from_entity_type >	edgeLocalDof (size_type elid, uint16_type edge_id) const

periodic_element_list_const_iterator	endPeriodicElements () const

std::pair< face_local_dof_const_iterator, face_local_dof_const_iterator >	faceLocalDof (size_type ElId) const

global_dof_fromface_type const &	faceLocalToGlobal (const size_type ElId, const uint16_type localNode, const uint16_type c=0) const override

fe_type const &	fe () const

std::vector< size_type >	getIndices (size_type id_el) const

std::vector< size_type >	getIndices (size_type id_el, mpl::size_t< MESH_ELEMENTS >) const

std::vector< size_type >	getIndices (size_type id_el, mpl::size_t< MESH_FACES >) const

std::vector< size_type >	getIndicesOnGlobalCluster (size_type id_el) const

void	getIndicesSet (size_type id_el, std::vector< size_type > &ind) const

bool	getIndicesSetOnGlobalCluster (size_type id_el, std::vector< size_type > &ind) const

size_type	getIndicesSize (int eid, mpl::false_) const

size_type	getIndicesSize (int eid, mpl::true_) const

size_type	getIndicesSize (int eid=0) const

std::pair< global_dof_const_iterator, global_dof_const_iterator >	globalDof () const

std::pair< global_dof_const_iterator, global_dof_const_iterator >	globalDof (size_type GlobalDofId) const

std::set< globaldof_type >	globalNeighbors (size_type GlobalDofId, bool add_self=true) const
	get the neighbor dofs

localdof_type const &	globalToLocal (size_type dof) const

bool	hasDofTableExtended () const

bool	hasMeshSupport () const

indices_per_element_type	indices (size_type id_el) const

DofTableInfos	infos () const override

void	initDofMap (mesh_type &M)
	Initialize the dof map table.

bool	insertDof (size_type ie, uint16_type l_dof, uint16_type lc, dof_type &&gDof, rank_type processor, size_type &pDof, int32_type sign=1, bool is_dof_periodic=false, size_type shift=0, mesh_marker_type const &marker=mesh_marker_type{})
	The dof are ordered such that they are contiguous per element and components. More...

bool	isElementDone (size_type elt, int c=0) const

std::pair< local_dof_const_iterator, local_dof_const_iterator >	localDof () const

template<typename MeshEntityType > requires std::is_same_v<MeshEntityType,typename mesh_type::element_type>
auto	localDof (MeshEntityType const &elt) const

template<typename MeshEntityType > requires std::is_same_v<MeshEntityType,typename mesh_type::face_type> && (mesh_type::nDim > 0)
auto	localDof (MeshEntityType const &face) const

std::pair< local_dof_const_iterator, local_dof_const_iterator >	localDof (size_type ElId) const

uint16_type	localDofId (uint16_type const lid, uint16_type const c=0) const

template<typename Elem >
uint16_type	localDofInElement (Elem const &El, const uint16_type localNode, const uint16_type c=0) const

local_dof_set_type const &	localDofSet (size_type eid) const

template<typename ElemTest , typename ElemTrial >
std::vector< uint16_type > const &	localIndices (ElemTest const &eltTest, ElemTrial const &eltTrial) const

template<typename ElemTest , typename ElemTrial >
std::vector< uint16_type > const &	localIndices (ElemTest const &eltTest, ElemTrial const &eltTrial, mpl::false_) const

template<typename ElemTest , typename ElemTrial >
std::vector< uint16_type > const &	localIndices (ElemTest const &eltTest, ElemTrial const &eltTrial, mpl::true_) const

global_dof_type const &	localToGlobal (const size_type ElId, const uint16_type localNode, const uint16_type c=0) const override

template<typename Elem >
mpl::if_< mpl::equal_to< mpl::int_< Elem::nDim >, mpl::int_< nDim > >, global_dof_type, global_dof_fromface_type >::type	localToGlobal (Elem const &El, const uint16_type localNode, const uint16_type c=0) const
	local to global mapping

size_type	localToGlobalId (const size_type ElId, const uint16_type id) const

vector_indices_type const &	localToGlobalIndices () const

localglobal_indices_type const &	localToGlobalIndices (size_type ElId) const

localglobal_indices_type	localToGlobalIndices (size_type ElId, std::vector< size_type > const &basisToContainerGlobalProcess) const

global_dof_type	localToGlobalOnCluster (const size_type ElId, const uint16_type localNode, const uint16_type c=0) const

localglobal_indices_type const &	localToGlobalSigns (size_type ElId) const

dof_map_type &	mapGDof ()

dof_map_type const &	mapGDof () const

dof_marker_type::right_range_type	markerToDof (boost::any const &marker)

dof_marker_type::right_range_type	markerToDofGreaterThan (boost::any const &marker)

dof_marker_type::right_range_type	markerToDofLessThan (boost::any const &marker)

mesh_type *	mesh ()

mesh_type *	mesh () const

mesh_support_ptrtype	meshSupport () const

mesh_support_base_ptrtype	meshSupportBase () const override

uint16_type	nDofPerFaceOnBoundary () const

size_type	nGhostDofAddedInExtendedDofTable () const

constexpr size_type	nLocalDof (bool per_component=false) const

constexpr size_type	nLocalDofOnFace (bool per_component=false) const

constexpr size_type	nRealLocalDof (bool per_component=false) const

size_type	numElements () const
	Number of elements in mesh.

uint16_type	numLocalEdges () const
	Number of local edges (in an element)

uint16_type	numLocalFaces () const
	Number of local faces (in an element)

uint16_type	numLocalVertices () const
	Number of local vertices (in an element)

std::pair< std::unordered_map< size_type, size_type >, std::unordered_map< size_type, size_type > >	pointIdToDofRelation (std::string fname="", bool dof2pid=true, bool pid2dof=true) const
	build point id to dof id relationship if `dof2pid` is true then generate dof to point id relation, if `pid2dof` is true then generate point id to dof relation,

void	printDofMarker (std::string const &filename)

void	rebuildDofPoints (mesh_type &M)
	rebuild dof points

void	setDofTableExtended (DofTableExtendedType b)

void	setMapGDof (dof_map_type const &mapdof)
	set the dictionary for the dictionary of the global dof

void	setMeshSupport (mesh_support_ptrtype const &meshSupport)
	set a mesh support where the doftable is built

void	showMe () const
	show some information about the dof instance

Public Member Functions inherited from Feel::DofTableBase< MeshType::size_type >
	DofTableBase (DofTableBase &&)=default

	DofTableBase (DofTableBase const &)=default

	DofTableBase (WorldComm const &_worldComm)

	DofTableBase (worldcomm_ptr_t &_worldComm)

virtual global_dof_fromface_type const &	faceLocalToGlobal (const size_type ElId, const uint16_type localNode, const uint16_type c=0) const=0

virtual DofTableInfos	infos () const=0

virtual global_dof_type const &	localToGlobal (const size_type ElId, const uint16_type localNode, const uint16_type c=0) const=0

virtual mesh_support_base_ptrtype	meshSupportBase () const=0

DofTableBase &	operator= (DofTableBase &&)=default

DofTableBase &	operator= (DofTableBase const &)=default

Static Public Member Functions
static constexpr uint16_type	nDofComponents ()

Static Public Attributes
static const bool	is_continuous = fe_type::isContinuous

static const bool	is_discontinuous_locally = fe_type::continuity_type::is_discontinuous_locally

static const bool	is_discontinuous_totally = fe_type::continuity_type::is_discontinuous_totally

static const bool	is_hcurl_conforming = Feel::is_hcurl_conforming<fe_type>::value

static const bool	is_hdiv_conforming = Feel::is_hdiv_conforming<fe_type>::value

static const bool	is_modal = FEType::is_modal

static const bool	is_mortar = mortar_type::is_mortar

static const bool	is_p0_continuous = ( ( nOrder == 0 ) && is_continuous )

static const bool	is_periodic = periodicity_type::is_periodic

static const bool	is_product = FEType::is_product

static const bool	is_scalar = FEType::is_scalar

static const bool	is_tensor2 = FEType::is_tensor2

static const bool	is_tensor2symm = FEType::is_tensor2 && is_symm_v<FEType>

static const bool	is_vectorial = FEType::is_vectorial

static const uint16_type	nComponents = fe_type::nComponents

static const uint16_type	nComponents1 = fe_type::nComponents1

static const uint16_type	nComponents2 = fe_type::nComponents2

static const uint16_type	nDim = mesh_type::nDim

static const uint16_type	nDofPerEdge = fe_type::nDofPerEdge

static const uint16_type	nDofPerElement = mpl::if_<mpl::bool_<is_product>, mpl::int_<FEType::nLocalDof*nComponents>, mpl::int_<FEType::nLocalDof> >::type::value

static const uint16_type	nOrder = fe_type::nOrder

static const uint16_type	nRealComponents = is_tensor2symm?(fe_type::nComponents1*(fe_type::nComponents1+1)/2):fe_type::nComponents

static const uint16_type	nRealDim = mesh_type::nRealDim

static const uint16_type	Shape = mesh_type::Shape

Friends
template<typename , typename >
class	DofFromBoundary

template<typename , typename >
class	DofFromEdge

template<typename , typename >
class	DofFromElement

template<typename , typename , typename >
class	DofFromMortar

template<typename , typename >
class	DofFromPeriodic

struct	element_access

struct	face_access

Detailed Description

template<typename MeshType, typename FEType, typename PeriodicityType, typename MortarType>
class Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >

Local-to-global Degree of Freedom table.

Author: Christophe Prud'homme; Goncalo Pena

Constructor & Destructor Documentation

◆ DofTable() [1/3]

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::DofTable	(	fe_ptrtype const &	_fe,
		periodicity_type const &	periodicity,
		WorldComm const &	_worldComm
	)

The minimal constructor.

Parameters

_fe	reference element

◆ DofTable() [2/3]

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::DofTable ( const DofTable< MeshType, FEType, PeriodicityType, MortarType > & dof2 )

copy constructor

Parameters

dof2	a dof object instance

◆ DofTable() [3/3]

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::DofTable	(	mesh_type &	mesh,
		fe_ptrtype const &	_fe,
		periodicity_type const &	periodicity,
		WorldComm const &	_worldComm
	)

Constructor accepting a mesh as parameter.

Parameters

mesh	a RegionMesh3D
_fe	reference element

Member Function Documentation

◆ dofIndex()

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

size_type Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::dofIndex ( size_type dof ) const

insted of creating the dof indices on the fly, get them from a vector.

The situation typically arises when we want to have dof correspondence between two spaces

See also: OperatorLagrangeP1

Returns: the dof index

◆ dofPoint()

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

const dof_point_type & Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::dofPoint ( size_type i ) const

Returns: the coordinates of the nodal dofs associated with the element el

◆ dofPointBegin() [1/2]

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

dof_points_iterator Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::dofPointBegin ( )

Returns: an iterator at the beginning of dof points

◆ dofPointBegin() [2/2]

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

dof_points_const_iterator Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::dofPointBegin ( ) const

Returns: an iterator at the beginning of dof points

◆ dofPointEnd() [1/2]

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

dof_points_iterator Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::dofPointEnd ( )

Returns: an iterator at the end of dof points

◆ dofPointEnd() [2/2]

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

dof_points_const_iterator Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::dofPointEnd ( ) const

Returns: an iterator at the end of dof points

◆ dofPoints()

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

dof_points_type const & Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::dofPoints ( ) const

Returns: the dof points data structure it allows for example to do:
for( auto const& pt: dofPoints())

{

// do something on pt

}

Feel::DofTable::dofPoints
dof_points_type const & dofPoints() const
Definition: doftable.hpp:577

◆ globalToLocal()

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

localdof_type const & Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::globalToLocal ( size_type dof ) const

Returns: the specified entries of the globalToLocal table

Parameters

DofId the Dof ID

Returns: the element id and local dof id

◆ hasMeshSupport()

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

bool Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::hasMeshSupport ( ) const

Returns: true if a mesh support object is defined

◆ infos()

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

DofTableInfos Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::infos ( ) const

overridevirtual

Implements Feel::DofTableBase< MeshType::size_type >.

◆ insertDof()

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

bool Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::insertDof	(	size_type	ie,
		uint16_type	l_dof,
		uint16_type	lc,
		dof_type &&	gDof,
		rank_type	processor,
		size_type &	pDof,
		int32_type	sign = `1`,
		bool	is_dof_periodic = `false`,
		size_type	shift = `0`,
		mesh_marker_type const &	marker = `mesh_marker_type{}`
	)

The dof are ordered such that they are contiguous per element and components.

This way an extraction of the dof indices in one element allows to extract a view of the corresponding coefficient in a given basis which is then very helpful for interpolation for example.

Parameters

ie	index of the element
lc_dof	index of the dof in the element
lc	local index of the entity associated with the dof in the element
gDof	global dof index
pDof	dof index in the processor

Returns: the index of the next free dof in the processor

◆ isElementDone()

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

bool Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::isElementDone	(	size_type	elt,
		int	c = `0`
	)		const

Parameters

elt	id the of element
c	component of the dof

Returns: true if element dof have all been computed, false otherwise

◆ localToGlobalId()

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

size_type Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::localToGlobalId	(	const size_type	ElId,
		const uint16_type	id
	)		const

Returns: the specified entries of the localToGlobal table

Parameters

ElId	the element ID
localNode	the local DOF numbering (starting from 1)
c	the component index, default is 0-th component

Returns: the global numbering of a DOF, given an element and the local numbering

◆ localToGlobalIndices() [1/3]

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

vector_indices_type const & Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::localToGlobalIndices ( ) const

Returns: the local to global indices

◆ localToGlobalIndices() [2/3]

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

localglobal_indices_type const & Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::localToGlobalIndices ( size_type ElId ) const

Returns: the local to global indices

◆ localToGlobalIndices() [3/3]

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

localglobal_indices_type Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::localToGlobalIndices	(	size_type	ElId,
		std::vector< size_type > const &	basisToContainerGlobalProcess
	)		const

Returns: the local to global indices

◆ localToGlobalSigns()

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

localglobal_indices_type const & Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::localToGlobalSigns ( size_type ElId ) const

Returns: the signs of the global dof (=1 in nodal case, +-1 in modal case)

◆ mapGDof() [1/2]

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

dof_map_type & Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::mapGDof ( )

Returns: the dictionary for the global dof

◆ mapGDof() [2/2]

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

dof_map_type const & Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::mapGDof ( ) const

Returns: the dictionary for the global dof

◆ meshSupport()

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

mesh_support_ptrtype Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::meshSupport ( ) const

Returns: mesh support

◆ meshSupportBase()

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

mesh_support_base_ptrtype Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::meshSupportBase ( ) const

overridevirtual

Implements Feel::DofTableBase< MeshType::size_type >.

◆ nDofPerFaceOnBoundary()

template<typename MeshType , typename FEType , typename PeriodicityType , typename MortarType >

uint16_type Feel::DofTable< MeshType, FEType, PeriodicityType, MortarType >::nDofPerFaceOnBoundary ( ) const

Returns: the number of dof for faces on the boundary

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ DofTable() [1/3]

◆ DofTable() [2/3]

◆ DofTable() [3/3]

Member Function Documentation

◆ dofIndex()

◆ dofPoint()

◆ dofPointBegin() [1/2]

◆ dofPointBegin() [2/2]

◆ dofPointEnd() [1/2]

◆ dofPointEnd() [2/2]

◆ dofPoints()

◆ globalToLocal()

◆ hasMeshSupport()

◆ infos()

◆ insertDof()

◆ isElementDone()

◆ localToGlobalId()

◆ localToGlobalIndices() [1/3]

◆ localToGlobalIndices() [2/3]

◆ localToGlobalIndices() [3/3]

◆ localToGlobalSigns()

◆ mapGDof() [1/2]

◆ mapGDof() [2/2]

◆ meshSupport()

◆ meshSupportBase()

◆ nDofPerFaceOnBoundary()