Reference documentation for deal.II version Git ee8a81293c 2020-10-19 10:17:29 -0400
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Classes | Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes | Friends | List of all members
MappingFEField< dim, spacedim, VectorType, DoFHandlerType > Class Template Referenceabstract

#include <deal.II/fe/mapping_fe_field.h>

Inheritance diagram for MappingFEField< dim, spacedim, VectorType, DoFHandlerType >:
[legend]

Classes

class  InternalData
 

Public Member Functions

 MappingFEField (const DoFHandlerType &euler_dof_handler, const VectorType &euler_vector, const ComponentMask &mask=ComponentMask())
 
 MappingFEField (const DoFHandlerType &euler_dof_handler, const std::vector< VectorType > &euler_vector, const ComponentMask &mask=ComponentMask())
 
 MappingFEField (const DoFHandlerType &euler_dof_handler, const MGLevelObject< VectorType > &euler_vector, const ComponentMask &mask=ComponentMask())
 
 MappingFEField (const MappingFEField< dim, spacedim, VectorType, DoFHandlerType > &mapping)
 
virtual std::unique_ptr< Mapping< dim, spacedim > > clone () const override
 
virtual bool preserves_vertex_locations () const override
 
virtual std::array< Point< spacedim >, GeometryInfo< dim >::vertices_per_cell > get_vertices (const typename Triangulation< dim, spacedim >::cell_iterator &cell) const override
 
unsigned int get_degree () const
 
ComponentMask get_component_mask () const
 
virtual Point< spacedim > get_center (const typename Triangulation< dim, spacedim >::cell_iterator &cell, const bool map_center_of_reference_cell=true) const
 
virtual BoundingBox< spacedim > get_bounding_box (const typename Triangulation< dim, spacedim >::cell_iterator &cell) const
 
template<class Archive >
void serialize (Archive &ar, const unsigned int version)
 
Mapping points between reference and real cells
virtual Point< spacedim > transform_unit_to_real_cell (const typename Triangulation< dim, spacedim >::cell_iterator &cell, const Point< dim > &p) const override
 
virtual Point< dim > transform_real_to_unit_cell (const typename Triangulation< dim, spacedim >::cell_iterator &cell, const Point< spacedim > &p) const override
 
Functions to transform tensors from reference to real coordinates
virtual void transform (const ArrayView< const Tensor< 1, dim >> &input, const MappingKind kind, const typename Mapping< dim, spacedim >::InternalDataBase &internal, const ArrayView< Tensor< 1, spacedim >> &output) const override
 
virtual void transform (const ArrayView< const DerivativeForm< 1, dim, spacedim >> &input, const MappingKind kind, const typename Mapping< dim, spacedim >::InternalDataBase &internal, const ArrayView< Tensor< 2, spacedim >> &output) const override
 
virtual void transform (const ArrayView< const Tensor< 2, dim >> &input, const MappingKind kind, const typename Mapping< dim, spacedim >::InternalDataBase &internal, const ArrayView< Tensor< 2, spacedim >> &output) const override
 
virtual void transform (const ArrayView< const DerivativeForm< 2, dim, spacedim >> &input, const MappingKind kind, const typename Mapping< dim, spacedim >::InternalDataBase &internal, const ArrayView< Tensor< 3, spacedim >> &output) const override
 
virtual void transform (const ArrayView< const Tensor< 3, dim >> &input, const MappingKind kind, const typename Mapping< dim, spacedim >::InternalDataBase &internal, const ArrayView< Tensor< 3, spacedim >> &output) const override
 
Mapping points between reference and real cells
virtual void transform_points_real_to_unit_cell (const typename Triangulation< dim, spacedim >::cell_iterator &cell, const ArrayView< const Point< spacedim >> &real_points, const ArrayView< Point< dim >> &unit_points) const
 
Point< dim - 1 > project_real_point_to_unit_point_on_face (const typename Triangulation< dim, spacedim >::cell_iterator &cell, const unsigned int face_no, const Point< spacedim > &p) const
 
Subscriptor functionality

Classes derived from Subscriptor provide a facility to subscribe to this object. This is mostly used by the SmartPointer class.

void subscribe (std::atomic< bool > *const validity, const std::string &identifier="") const
 
void unsubscribe (std::atomic< bool > *const validity, const std::string &identifier="") const
 
unsigned int n_subscriptions () const
 
template<typename StreamType >
void list_subscribers (StreamType &stream) const
 
void list_subscribers () const
 

Static Public Member Functions

static ::ExceptionBaseExcInactiveCell ()
 
static ::ExceptionBaseExcInUse (int arg1, std::string arg2, std::string arg3)
 
static ::ExceptionBaseExcNoSubscriber (std::string arg1, std::string arg2)
 
Exceptions
static ::ExceptionBaseExcInvalidData ()
 
static ::ExceptionBaseExcTransformationFailed ()
 
static ::ExceptionBaseExcDistortedMappedCell (Point< spacedim > arg1, double arg2, int arg3)
 

Protected Member Functions

Interface with FEValues
virtual CellSimilarity::Similarity fill_fe_values (const typename Triangulation< dim, spacedim >::cell_iterator &cell, const CellSimilarity::Similarity cell_similarity, const Quadrature< dim > &quadrature, const typename Mapping< dim, spacedim >::InternalDataBase &internal_data, ::internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &output_data) const =0
 
virtual void fill_fe_face_values (const typename Triangulation< dim, spacedim >::cell_iterator &cell, const unsigned int face_no, const Quadrature< dim - 1 > &quadrature, const typename Mapping< dim, spacedim >::InternalDataBase &internal_data, ::internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &output_data) const =0
 
virtual void fill_fe_subface_values (const typename Triangulation< dim, spacedim >::cell_iterator &cell, const unsigned int face_no, const unsigned int subface_no, const Quadrature< dim - 1 > &quadrature, const typename Mapping< dim, spacedim >::InternalDataBase &internal_data, ::internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &output_data) const =0
 

Private Member Functions

Point< spacedim > do_transform_unit_to_real_cell (const InternalData &mdata) const
 
Point< dim > do_transform_real_to_unit_cell (const typename Triangulation< dim, spacedim >::cell_iterator &cell, const Point< spacedim > &p, const Point< dim > &initial_p_unit, InternalData &mdata) const
 
void update_internal_dofs (const typename Triangulation< dim, spacedim >::cell_iterator &cell, const typename MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::InternalData &data) const
 
virtual void compute_shapes_virtual (const std::vector< Point< dim >> &unit_points, typename MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::InternalData &data) const
 
void compute_data (const UpdateFlags update_flags, const Quadrature< dim > &q, const unsigned int n_original_q_points, InternalData &data) const
 
void compute_face_data (const UpdateFlags update_flags, const Quadrature< dim > &q, const unsigned int n_original_q_points, InternalData &data) const
 
Interface with FEValues
virtual UpdateFlags requires_update_flags (const UpdateFlags update_flags) const override
 
virtual std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBaseget_data (const UpdateFlags, const Quadrature< dim > &quadrature) const override
 
virtual std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBaseget_face_data (const UpdateFlags flags, const Quadrature< dim - 1 > &quadrature) const override
 
virtual std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBaseget_subface_data (const UpdateFlags flags, const Quadrature< dim - 1 > &quadrature) const override
 
virtual CellSimilarity::Similarity fill_fe_values (const typename Triangulation< dim, spacedim >::cell_iterator &cell, const CellSimilarity::Similarity cell_similarity, const Quadrature< dim > &quadrature, const typename Mapping< dim, spacedim >::InternalDataBase &internal_data, internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &output_data) const override
 
virtual void fill_fe_face_values (const typename Triangulation< dim, spacedim >::cell_iterator &cell, const unsigned int face_no, const Quadrature< dim - 1 > &quadrature, const typename Mapping< dim, spacedim >::InternalDataBase &internal_data, internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &output_data) const override
 
virtual void fill_fe_subface_values (const typename Triangulation< dim, spacedim >::cell_iterator &cell, const unsigned int face_no, const unsigned int subface_no, const Quadrature< dim - 1 > &quadrature, const typename Mapping< dim, spacedim >::InternalDataBase &internal_data, internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &output_data) const override
 

Private Attributes

const bool uses_level_dofs
 
std::vector< SmartPointer< const VectorType, MappingFEField< dim, spacedim, VectorType, DoFHandlerType > > > euler_vector
 
SmartPointer< const DoFHandlerType, MappingFEField< dim, spacedim, VectorType, DoFHandlerType > > euler_dof_handler
 
const ComponentMask fe_mask
 
std::vector< unsigned intfe_to_real
 
FEValues< dim, spacedim > fe_values
 
std::mutex fe_values_mutex
 

Friends

template<int , int , class , class >
class MappingFEField
 

Detailed Description

template<int dim, int spacedim = dim, typename VectorType = Vector<double>, typename DoFHandlerType = DoFHandler<dim, spacedim>>
class MappingFEField< dim, spacedim, VectorType, DoFHandlerType >

The MappingFEField is a generalization of the MappingQEulerian class, for arbitrary vector finite elements. The two main differences are that this class uses a vector of absolute positions instead of a vector of displacements, and it allows for arbitrary FiniteElement types, instead of only FE_Q.

This class effectively decouples the topology from the geometry, by relegating all geometrical information to some components of a FiniteElement vector field. The components that are used for the geometry can be arbitrarily selected at construction time.

The idea is to consider the Triangulation as a parameter configuration space, on which we construct an arbitrary geometrical mapping, using the instruments of the deal.II library: a vector of degrees of freedom, a DoFHandler associated to the geometry of the problem and a ComponentMask that tells us which components of the FiniteElement to use for the mapping.

Typically, the DoFHandler operates on a finite element that is constructed as a system element (FESystem()) from continuous FE_Q() (for iso-parametric discretizations) or FE_Bernstein() (for iso-geometric discretizations) objects. An example is shown below:

const FE_Q<dim,spacedim> feq(1);
const FESystem<dim,spacedim> fesystem(feq, spacedim);
DoFHandler<dim,spacedim> dhq(triangulation);
dhq.distribute_dofs(fesystem);
const ComponentMask mask(spacedim, true);
Vector<double> eulerq(dhq.n_dofs());
// Fills the euler vector with information from the Triangulation
MappingFEField<dim,spacedim> map(dhq, eulerq, mask);

Definition at line 81 of file mapping_fe_field.h.

Constructor & Destructor Documentation

◆ MappingFEField() [1/4]

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::MappingFEField ( const DoFHandlerType &  euler_dof_handler,
const VectorType euler_vector,
const ComponentMask mask = ComponentMask() 
)

Constructor. The first argument is a VectorType that specifies the transformation of the domain from the reference to the current configuration.

In general this class decouples geometry from topology, allowing users to define geometries which are only topologically equivalent to the underlying Triangulation, but which may otherwise be arbitrary. Differently from what happens in MappingQEulerian, the FiniteElement field which is passed to the constructor is interpreted as an absolute geometrical configuration, therefore one has to make sure that the euler_vector actually represents a valid geometry (i.e., one with no inverted cells, or with no zero-volume cells).

If the underlying FiniteElement is a system of FE_Q(), and euler_vector is initialized using VectorTools::get_position_vector(), then this class is in all respects identical to MappingQ().

The optional ComponentMask argument can be used to specify what components of the FiniteElement to use for the geometrical transformation. If no mask is specified at construction time, then a default one is used, which makes this class works in the same way of MappingQEulerian(), i.e., the first spacedim components of the FiniteElement are assumed to represent the geometry of the problem.

Notice that if a mask is specified, it has to match in size the underlying FiniteElement, and it has to have exactly spacedim non-zero elements, indicating the components (in order) of the FiniteElement which will be used for the geometry.

If an incompatible mask is passed, an exception is thrown.

Definition at line 214 of file mapping_fe_field.cc.

◆ MappingFEField() [2/4]

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::MappingFEField ( const DoFHandlerType &  euler_dof_handler,
const std::vector< VectorType > &  euler_vector,
const ComponentMask mask = ComponentMask() 
)

Constructor taking vectors on the multigrid levels rather than the active cells only. The vector of vectors is expected to have as many entries as there are global levels in the triangulation and provide valid data on each level, i.e., be of compatible length DoFHandler::n_dofs(level). A prerequisite of this constructor is that DoFHandler::distribute_mg_dofs() has been called. Apart from the level vectors, the same arguments as in the other constructor need to be provided.

Definition at line 243 of file mapping_fe_field.cc.

◆ MappingFEField() [3/4]

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::MappingFEField ( const DoFHandlerType &  euler_dof_handler,
const MGLevelObject< VectorType > &  euler_vector,
const ComponentMask mask = ComponentMask() 
)

Constructor with MGLevelObject instead of std::vector, otherwise the same as above. It is required that euler_vector.max_level()+1 equals the global number of levels in the triangulation. The minimum level may be zero or more — it only needs to be consistent between what is set here and later used for evaluation of the mapping.

Definition at line 282 of file mapping_fe_field.cc.

◆ MappingFEField() [4/4]

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::MappingFEField ( const MappingFEField< dim, spacedim, VectorType, DoFHandlerType > &  mapping)

Copy constructor.

Definition at line 323 of file mapping_fe_field.cc.

Member Function Documentation

◆ clone()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
std::unique_ptr< Mapping< dim, spacedim > > MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::clone ( ) const
overridevirtual

Return a pointer to a copy of the present object. The caller of this copy then assumes ownership of it.

Implements Mapping< dim, spacedim >.

Definition at line 2316 of file mapping_fe_field.cc.

◆ preserves_vertex_locations()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
bool MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::preserves_vertex_locations ( ) const
overridevirtual

See the documentation of Mapping::preserves_vertex_locations() for the purpose of this function. The implementation in this class always returns false.

Implements Mapping< dim, spacedim >.

Definition at line 352 of file mapping_fe_field.cc.

◆ get_vertices()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
std::array< Point< spacedim >, GeometryInfo< dim >::vertices_per_cell > MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::get_vertices ( const typename Triangulation< dim, spacedim >::cell_iterator &  cell) const
overridevirtual

Return the mapped vertices of a cell.

This mapping ignores the vertices of the Triangulation it is associated to, and constructs the position of the vertices according to the euler_vector that was passed at construction time.

Reimplemented from Mapping< dim, spacedim >.

Definition at line 361 of file mapping_fe_field.cc.

◆ transform_unit_to_real_cell()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
Point< spacedim > MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::transform_unit_to_real_cell ( const typename Triangulation< dim, spacedim >::cell_iterator &  cell,
const Point< dim > &  p 
) const
overridevirtual

Map the point p on the unit cell to the corresponding point on the real cell cell.

Parameters
cellIterator to the cell that will be used to define the mapping.
pLocation of a point on the reference cell.
Returns
The location of the reference point mapped to real space using the mapping defined by the class derived from the current one that implements the mapping, and the coordinates of the cell identified by the first argument.

Implements Mapping< dim, spacedim >.

Definition at line 2096 of file mapping_fe_field.cc.

◆ transform_real_to_unit_cell()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
Point< dim > MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::transform_real_to_unit_cell ( const typename Triangulation< dim, spacedim >::cell_iterator &  cell,
const Point< spacedim > &  p 
) const
overridevirtual

Map the point p on the real cell to the corresponding point on the unit cell, and return its coordinates. This function provides the inverse of the mapping provided by transform_unit_to_real_cell().

In the codimension one case, this function returns the normal projection of the real point p on the curve or surface identified by the cell.

Note
Polynomial mappings from the reference (unit) cell coordinates to the coordinate system of a real cell are not always invertible if the point for which the inverse mapping is to be computed lies outside the cell's boundaries. In such cases, the current function may fail to compute a point on the reference cell whose image under the mapping equals the given point p. If this is the case then this function throws an exception of type Mapping::ExcTransformationFailed . Whether the given point p lies outside the cell can therefore be determined by checking whether the returned reference coordinates lie inside or outside the reference cell (e.g., using GeometryInfo::is_inside_unit_cell()) or whether the exception mentioned above has been thrown.
Parameters
cellIterator to the cell that will be used to define the mapping.
pLocation of a point on the given cell.
Returns
The reference cell location of the point that when mapped to real space equals the coordinates given by the second argument. This mapping uses the mapping defined by the class derived from the current one that implements the mapping, and the coordinates of the cell identified by the first argument.

Implements Mapping< dim, spacedim >.

Definition at line 2139 of file mapping_fe_field.cc.

◆ transform() [1/5]

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
void MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::transform ( const ArrayView< const Tensor< 1, dim >> &  input,
const MappingKind  kind,
const typename Mapping< dim, spacedim >::InternalDataBase internal,
const ArrayView< Tensor< 1, spacedim >> &  output 
) const
overridevirtual

Transform a field of vectors or 1-differential forms according to the selected MappingKind.

Note
Normally, this function is called by a finite element, filling FEValues objects. For this finite element, there should be an alias MappingKind like mapping_bdm, mapping_nedelec, etc. This alias should be preferred to using the kinds below.

The mapping kinds currently implemented by derived classes are:

  • mapping_contravariant: maps a vector field on the reference cell to the physical cell through the Jacobian:

    \[ \mathbf u(\mathbf x) = J(\hat{\mathbf x})\hat{\mathbf u}(\hat{\mathbf x}). \]

    In physics, this is usually referred to as the contravariant transformation. Mathematically, it is the push forward of a vector field.

  • mapping_covariant: maps a field of one-forms on the reference cell to a field of one-forms on the physical cell. (Theoretically this would refer to a DerivativeForm<1,dim,1> but we canonically identify this type with a Tensor<1,dim>). Mathematically, it is the pull back of the differential form

    \[ \mathbf u(\mathbf x) = J(\hat{\mathbf x})(J(\hat{\mathbf x})^{T} J(\hat{\mathbf x}))^{-1}\hat{\mathbf u}(\hat{\mathbf x}). \]

    Gradients of scalar differentiable functions are transformed this way.

    In the case when dim=spacedim the previous formula reduces to

    \[ \mathbf u(\mathbf x) = J(\hat{\mathbf x})^{-T}\hat{\mathbf u}(\hat{\mathbf x}) \]

    because we assume that the mapping \(\mathbf F_K\) is always invertible, and consequently its Jacobian \(J\) is an invertible matrix.

  • mapping_piola: A field of dim-1-forms on the reference cell is also represented by a vector field, but again transforms differently, namely by the Piola transform

    \[ \mathbf u(\mathbf x) = \frac{1}{\text{det}\;J(\hat{\mathbf x})} J(\hat{\mathbf x}) \hat{\mathbf u}(\hat{\mathbf x}). \]

Parameters
[in]inputAn array (or part of an array) of input objects that should be mapped.
[in]kindThe kind of mapping to be applied.
[in]internalA pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to.
[out]outputAn array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.)

Implements Mapping< dim, spacedim >.

Definition at line 1975 of file mapping_fe_field.cc.

◆ transform() [2/5]

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
void MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::transform ( const ArrayView< const DerivativeForm< 1, dim, spacedim >> &  input,
const MappingKind  kind,
const typename Mapping< dim, spacedim >::InternalDataBase internal,
const ArrayView< Tensor< 2, spacedim >> &  output 
) const
overridevirtual

Transform a field of differential forms from the reference cell to the physical cell. It is useful to think of \(\mathbf{T} = \nabla \mathbf u\) and \(\hat{\mathbf T} = \hat \nabla \hat{\mathbf u}\), with \(\mathbf u\) a vector field. The mapping kinds currently implemented by derived classes are:

  • mapping_covariant: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form

    \[ \mathbf T(\mathbf x) = \hat{\mathbf T}(\hat{\mathbf x}) J(\hat{\mathbf x})(J(\hat{\mathbf x})^{T} J(\hat{\mathbf x}))^{-1}. \]

    Jacobians of spacedim-vector valued differentiable functions are transformed this way.

    In the case when dim=spacedim the previous formula reduces to

    \[ \mathbf T(\mathbf x) = \hat{\mathbf u}(\hat{\mathbf x}) J(\hat{\mathbf x})^{-1}. \]

Note
It would have been more reasonable to make this transform a template function with the rank in DerivativeForm<1, dim, rank>. Unfortunately C++ does not allow templatized virtual functions. This is why we identify DerivativeForm<1, dim, 1> with a Tensor<1,dim> when using mapping_covariant() in the function transform() above this one.
Parameters
[in]inputAn array (or part of an array) of input objects that should be mapped.
[in]kindThe kind of mapping to be applied.
[in]internalA pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to.
[out]outputAn array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.)

Implements Mapping< dim, spacedim >.

Definition at line 1994 of file mapping_fe_field.cc.

◆ transform() [3/5]

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
void MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::transform ( const ArrayView< const Tensor< 2, dim >> &  input,
const MappingKind  kind,
const typename Mapping< dim, spacedim >::InternalDataBase internal,
const ArrayView< Tensor< 2, spacedim >> &  output 
) const
overridevirtual

Transform a tensor field from the reference cell to the physical cell. These tensors are usually the Jacobians in the reference cell of vector fields that have been pulled back from the physical cell. The mapping kinds currently implemented by derived classes are:

  • mapping_contravariant_gradient: it assumes \(\mathbf u(\mathbf x) = J \hat{\mathbf u}\) so that

    \[ \mathbf T(\mathbf x) = J(\hat{\mathbf x}) \hat{\mathbf T}(\hat{\mathbf x}) J(\hat{\mathbf x})^{-1}. \]

  • mapping_covariant_gradient: it assumes \(\mathbf u(\mathbf x) = J^{-T} \hat{\mathbf u}\) so that

    \[ \mathbf T(\mathbf x) = J(\hat{\mathbf x})^{-T} \hat{\mathbf T}(\hat{\mathbf x}) J(\hat{\mathbf x})^{-1}. \]

  • mapping_piola_gradient: it assumes \(\mathbf u(\mathbf x) = \frac{1}{\text{det}\;J(\hat{\mathbf x})} J(\hat{\mathbf x}) \hat{\mathbf u}(\hat{\mathbf x})\) so that

    \[ \mathbf T(\mathbf x) = \frac{1}{\text{det}\;J(\hat{\mathbf x})} J(\hat{\mathbf x}) \hat{\mathbf T}(\hat{\mathbf x}) J(\hat{\mathbf x})^{-1}. \]

Todo:
The formulas for mapping_covariant_gradient, mapping_contravariant_gradient and mapping_piola_gradient are only true as stated for linear mappings. If, for example, the mapping is bilinear (or has a higher order polynomial degree) then there is a missing term associated with the derivative of \(J\).
Parameters
[in]inputAn array (or part of an array) of input objects that should be mapped.
[in]kindThe kind of mapping to be applied.
[in]internalA pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to.
[out]outputAn array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.)

Implements Mapping< dim, spacedim >.

Definition at line 2011 of file mapping_fe_field.cc.

◆ transform() [4/5]

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
void MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::transform ( const ArrayView< const DerivativeForm< 2, dim, spacedim >> &  input,
const MappingKind  kind,
const typename Mapping< dim, spacedim >::InternalDataBase internal,
const ArrayView< Tensor< 3, spacedim >> &  output 
) const
overridevirtual

Transform a tensor field from the reference cell to the physical cell. This tensors are most of times the hessians in the reference cell of vector fields that have been pulled back from the physical cell.

The mapping kinds currently implemented by derived classes are:

  • mapping_covariant_gradient: maps a field of forms on the reference cell to a field of forms on the physical cell. Mathematically, it is the pull back of the differential form

    \[ \mathbf T_{ijk}(\mathbf x) = \hat{\mathbf T}_{iJK}(\hat{\mathbf x}) J_{jJ}^{\dagger} J_{kK}^{\dagger}\]

    ,

    where

    \[ J^{\dagger} = J(\hat{\mathbf x})(J(\hat{\mathbf x})^{T} J(\hat{\mathbf x}))^{-1}. \]

Hessians of spacedim-vector valued differentiable functions are transformed this way (After subtraction of the product of the derivative with the Jacobian gradient).

In the case when dim=spacedim the previous formula reduces to

\[J^{\dagger} = J^{-1}\]

Parameters
[in]inputAn array (or part of an array) of input objects that should be mapped.
[in]kindThe kind of mapping to be applied.
[in]internalA pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to.
[out]outputAn array (or part of an array) into which the transformed objects should be placed. (Note that the array view is const, but the tensors it points to are not.)

Implements Mapping< dim, spacedim >.

Definition at line 2029 of file mapping_fe_field.cc.

◆ transform() [5/5]

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
void MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::transform ( const ArrayView< const Tensor< 3, dim >> &  input,
const MappingKind  kind,
const typename Mapping< dim, spacedim >::InternalDataBase internal,
const ArrayView< Tensor< 3, spacedim >> &  output 
) const
overridevirtual

Transform a field of 3-differential forms from the reference cell to the physical cell. It is useful to think of \(\mathbf{T}_{ijk} = D^2_{jk} \mathbf u_i\) and \(\mathbf{\hat T}_{IJK} = \hat D^2_{JK} \mathbf{\hat u}_I\), with \(\mathbf u_i\) a vector field.

The mapping kinds currently implemented by derived classes are:

  • mapping_contravariant_hessian: it assumes \(\mathbf u_i(\mathbf x) = J_{iI} \hat{\mathbf u}_I\) so that

    \[ \mathbf T_{ijk}(\mathbf x) = J_{iI}(\hat{\mathbf x}) \hat{\mathbf T}_{IJK}(\hat{\mathbf x}) J_{jJ}(\hat{\mathbf x})^{-1} J_{kK}(\hat{\mathbf x})^{-1}. \]

  • mapping_covariant_hessian: it assumes \(\mathbf u_i(\mathbf x) = J_{iI}^{-T} \hat{\mathbf u}_I\) so that

    \[ \mathbf T_{ijk}(\mathbf x) = J_iI(\hat{\mathbf x})^{-1} \hat{\mathbf T}_{IJK}(\hat{\mathbf x}) J_{jJ}(\hat{\mathbf x})^{-1} J_{kK}(\hat{\mathbf x})^{-1}. \]

  • mapping_piola_hessian: it assumes \(\mathbf u_i(\mathbf x) = \frac{1}{\text{det}\;J(\hat{\mathbf x})} J_{iI}(\hat{\mathbf x}) \hat{\mathbf u}(\hat{\mathbf x})\) so that

    \[ \mathbf T_{ijk}(\mathbf x) = \frac{1}{\text{det}\;J(\hat{\mathbf x})} J_{iI}(\hat{\mathbf x}) \hat{\mathbf T}_{IJK}(\hat{\mathbf x}) J_{jJ}(\hat{\mathbf x})^{-1} J_{kK}(\hat{\mathbf x})^{-1}. \]

Parameters
[in]inputAn array (or part of an array) of input objects that should be mapped.
[in]kindThe kind of mapping to be applied.
[in]internalA pointer to an object of type Mapping::InternalDataBase that contains information previously stored by the mapping. The object pointed to was created by the get_data(), get_face_data(), or get_subface_data() function, and will have been updated as part of a call to fill_fe_values(), fill_fe_face_values(), or fill_fe_subface_values() for the current cell, before calling the current function. In other words, this object also represents with respect to which cell the transformation should be applied to.
[out]outputAn array (or part of an array) into which the transformed objects should be placed.

Implements Mapping< dim, spacedim >.

Definition at line 2077 of file mapping_fe_field.cc.

◆ get_degree()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
unsigned int MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::get_degree ( ) const

Return the degree of the mapping, i.e. the value which was passed to the constructor.

Definition at line 2299 of file mapping_fe_field.cc.

◆ get_component_mask()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
ComponentMask MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::get_component_mask ( ) const

Return the ComponentMask of the mapping, i.e. which components to use for the mapping.

Definition at line 2307 of file mapping_fe_field.cc.

◆ requires_update_flags()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
UpdateFlags MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::requires_update_flags ( const UpdateFlags  update_flags) const
overrideprivatevirtual

Given a set of update flags, compute which other quantities also need to be computed in order to satisfy the request by the given flags. Then return the combination of the original set of flags and those just computed.

As an example, if update_flags contains update_JxW_values (i.e., the product of the determinant of the Jacobian and the weights provided by the quadrature formula), a mapping may require the computation of the full Jacobian matrix in order to compute its determinant. They would then return not just update_JxW_values, but also update_jacobians. (This is not how it is actually done internally in the derived classes that compute the JxW values – they set update_contravariant_transformation instead, from which the determinant can also be computed – but this does not take away from the instructiveness of the example.)

An extensive discussion of the interaction between this function and FEValues can be found in the How Mapping, FiniteElement, and FEValues work together documentation module.

See also
UpdateFlags

Implements Mapping< dim, spacedim >.

Definition at line 462 of file mapping_fe_field.cc.

◆ get_data()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::get_data ( const UpdateFlags  update_flags,
const Quadrature< dim > &  quadrature 
) const
overrideprivatevirtual

Create and return a pointer to an object into which mappings can store data that only needs to be computed once but that can then be used whenever the mapping is applied to a concrete cell (e.g., in the various transform() functions, as well as in the fill_fe_values(), fill_fe_face_values() and fill_fe_subface_values() that form the interface of mappings with the FEValues class).

Derived classes will return pointers to objects of a type derived from Mapping::InternalDataBase (see there for more information) and may pre- compute some information already (in accordance with what will be asked of the mapping in the future, as specified by the update flags) and for the given quadrature object. Subsequent calls to transform() or fill_fe_values() and friends will then receive back the object created here (with the same set of update flags and for the same quadrature object). Derived classes can therefore pre-compute some information in their get_data() function and store it in the internal data object.

The mapping classes do not keep track of the objects created by this function. Ownership will therefore rest with the caller.

An extensive discussion of the interaction between this function and FEValues can be found in the How Mapping, FiniteElement, and FEValues work together documentation module.

Parameters
update_flagsA set of flags that define what is expected of the mapping class in future calls to transform() or the fill_fe_values() group of functions. This set of flags may contain flags that mappings do not know how to deal with (e.g., for information that is in fact computed by the finite element classes, such as UpdateFlags::update_values). Derived classes will need to store these flags, or at least that subset of flags that will require the mapping to perform any actions in fill_fe_values(), in InternalDataBase::update_each.
quadratureThe quadrature object for which mapping information will have to be computed. This includes the locations and weights of quadrature points.
Returns
A pointer to a newly created object of type InternalDataBase (or a derived class). Ownership of this object passes to the calling function.
Note
C++ allows that virtual functions in derived classes may return pointers to objects not of type InternalDataBase but in fact pointers to objects of classes derived from InternalDataBase. (This feature is called "covariant return types".) This is useful in some contexts where the calling is within the derived class and will immediately make use of the returned object, knowing its real (derived) type.

Implements Mapping< dim, spacedim >.

Definition at line 608 of file mapping_fe_field.cc.

◆ get_face_data()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::get_face_data ( const UpdateFlags  update_flags,
const Quadrature< dim - 1 > &  quadrature 
) const
overrideprivatevirtual

Like get_data(), but in preparation for later calls to transform() or fill_fe_face_values() that will need information about mappings from the reference face to a face of a concrete cell.

Parameters
update_flagsA set of flags that define what is expected of the mapping class in future calls to transform() or the fill_fe_values() group of functions. This set of flags may contain flags that mappings do not know how to deal with (e.g., for information that is in fact computed by the finite element classes, such as UpdateFlags::update_values). Derived classes will need to store these flags, or at least that subset of flags that will require the mapping to perform any actions in fill_fe_values(), in InternalDataBase::update_each.
quadratureThe quadrature object for which mapping information will have to be computed. This includes the locations and weights of quadrature points.
Returns
A pointer to a newly created object of type InternalDataBase (or a derived class). Ownership of this object passes to the calling function.
Note
C++ allows that virtual functions in derived classes may return pointers to objects not of type InternalDataBase but in fact pointers to objects of classes derived from InternalDataBase. (This feature is called "covariant return types".) This is useful in some contexts where the calling is within the derived class and will immediately make use of the returned object, knowing its real (derived) type.

Implements Mapping< dim, spacedim >.

Definition at line 624 of file mapping_fe_field.cc.

◆ get_subface_data()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::get_subface_data ( const UpdateFlags  update_flags,
const Quadrature< dim - 1 > &  quadrature 
) const
overrideprivatevirtual

Like get_data() and get_face_data(), but in preparation for later calls to transform() or fill_fe_subface_values() that will need information about mappings from the reference face to a child of a face (i.e., subface) of a concrete cell.

Parameters
update_flagsA set of flags that define what is expected of the mapping class in future calls to transform() or the fill_fe_values() group of functions. This set of flags may contain flags that mappings do not know how to deal with (e.g., for information that is in fact computed by the finite element classes, such as UpdateFlags::update_values). Derived classes will need to store these flags, or at least that subset of flags that will require the mapping to perform any actions in fill_fe_values(), in InternalDataBase::update_each.
quadratureThe quadrature object for which mapping information will have to be computed. This includes the locations and weights of quadrature points.
Returns
A pointer to a newly created object of type InternalDataBase (or a derived class). Ownership of this object passes to the calling function.
Note
C++ allows that virtual functions in derived classes may return pointers to objects not of type InternalDataBase but in fact pointers to objects of classes derived from InternalDataBase. (This feature is called "covariant return types".) This is useful in some contexts where the calling is within the derived class and will immediately make use of the returned object, knowing its real (derived) type.

Implements Mapping< dim, spacedim >.

Definition at line 642 of file mapping_fe_field.cc.

◆ fill_fe_values() [1/2]

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
CellSimilarity::Similarity MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::fill_fe_values ( const typename Triangulation< dim, spacedim >::cell_iterator &  cell,
const CellSimilarity::Similarity  cell_similarity,
const Quadrature< dim > &  quadrature,
const typename Mapping< dim, spacedim >::InternalDataBase internal_data,
internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &  output_data 
) const
overrideprivatevirtual

Definition at line 1541 of file mapping_fe_field.cc.

◆ fill_fe_face_values() [1/2]

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
void MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::fill_fe_face_values ( const typename Triangulation< dim, spacedim >::cell_iterator &  cell,
const unsigned int  face_no,
const Quadrature< dim - 1 > &  quadrature,
const typename Mapping< dim, spacedim >::InternalDataBase internal_data,
internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &  output_data 
) const
overrideprivatevirtual

Definition at line 1748 of file mapping_fe_field.cc.

◆ fill_fe_subface_values() [1/2]

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
void MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::fill_fe_subface_values ( const typename Triangulation< dim, spacedim >::cell_iterator &  cell,
const unsigned int  face_no,
const unsigned int  subface_no,
const Quadrature< dim - 1 > &  quadrature,
const typename Mapping< dim, spacedim >::InternalDataBase internal_data,
internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &  output_data 
) const
overrideprivatevirtual

Definition at line 1789 of file mapping_fe_field.cc.

◆ do_transform_unit_to_real_cell()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
Point< spacedim > MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::do_transform_unit_to_real_cell ( const InternalData mdata) const
private

Transform a point p on the unit cell to the point p_real on the real cell cell and returns p_real.

This function is called by transform_unit_to_real_cell and multiple times (through the Newton iteration) by transform_real_to_unit_cell_internal.

Takes a reference to an InternalData that must already include the shape values at point p and the mapping support points of the cell.

This InternalData argument avoids multiple computations of the shape values at point p and especially multiple computations of the mapping support points.

Definition at line 2118 of file mapping_fe_field.cc.

◆ do_transform_real_to_unit_cell()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
Point< dim > MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::do_transform_real_to_unit_cell ( const typename Triangulation< dim, spacedim >::cell_iterator &  cell,
const Point< spacedim > &  p,
const Point< dim > &  initial_p_unit,
InternalData mdata 
) const
private

Transform the point p on the real cell to the corresponding point on the unit cell cell by a Newton iteration.

Takes a reference to an InternalData that is assumed to be previously created by the get_data function with UpdateFlags including update_transformation_values and update_transformation_gradients and a one point Quadrature that includes the given initial guess for the transformation initial_p_unit. Hence this function assumes that mdata already includes the transformation shape values and gradients computed at initial_p_unit.

mdata will be changed by this function.

Definition at line 2188 of file mapping_fe_field.cc.

◆ update_internal_dofs()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
void MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::update_internal_dofs ( const typename Triangulation< dim, spacedim >::cell_iterator &  cell,
const typename MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::InternalData data 
) const
private

Update internal degrees of freedom.

Definition at line 2325 of file mapping_fe_field.cc.

◆ compute_shapes_virtual()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
void MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::compute_shapes_virtual ( const std::vector< Point< dim >> &  unit_points,
typename MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::InternalData data 
) const
privatevirtual

See the documentation of the base class for detailed information.

Definition at line 423 of file mapping_fe_field.cc.

◆ compute_data()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
void MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::compute_data ( const UpdateFlags  update_flags,
const Quadrature< dim > &  q,
const unsigned int  n_original_q_points,
InternalData data 
) const
private

Definition at line 516 of file mapping_fe_field.cc.

◆ compute_face_data()

template<int dim, int spacedim, typename VectorType , typename DoFHandlerType >
void MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::compute_face_data ( const UpdateFlags  update_flags,
const Quadrature< dim > &  q,
const unsigned int  n_original_q_points,
InternalData data 
) const
private

Definition at line 567 of file mapping_fe_field.cc.

◆ get_center()

template<int dim, int spacedim>
Point< spacedim > Mapping< dim, spacedim >::get_center ( const typename Triangulation< dim, spacedim >::cell_iterator &  cell,
const bool  map_center_of_reference_cell = true 
) const
virtualinherited

Return the mapped center of a cell.

If you are using a (bi-,tri-)linear mapping that preserves vertex locations, this function simply returns the value also produced by cell->center(). However, there are also mappings that add displacements or choose completely different locations, e.g., MappingQEulerian, MappingQ1Eulerian, or MappingFEField, and mappings based on high order polynomials, for which the center may not coincide with the average of the vertex locations.

By default, this function returns the push forward of the center of the reference cell. If the parameter map_center_of_reference_cell is set to false, than the return value will be the average of the vertex locations, as returned by the get_vertices() method.

Parameters
[in]cellThe cell for which you want to compute the center
[in]map_center_of_reference_cellA flag that switches the algorithm for the computation of the cell center from transform_unit_to_real_cell() applied to the center of the reference cell to computing the vertex averages.

Definition at line 43 of file mapping.cc.

◆ get_bounding_box()

template<int dim, int spacedim>
BoundingBox< spacedim > Mapping< dim, spacedim >::get_bounding_box ( const typename Triangulation< dim, spacedim >::cell_iterator &  cell) const
virtualinherited

Return the bounding box of a mapped cell.

If you are using a (bi-,tri-)linear mapping that preserves vertex locations, this function simply returns the value also produced by cell->bounding_box(). However, there are also mappings that add displacements or choose completely different locations, e.g., MappingQEulerian, MappingQ1Eulerian, or MappingFEField.

This function returns the bounding box containing all the vertices of the cell, as returned by the get_vertices() method. Beware of the fact that for higher order mappings this bounding box is only an approximation of the true bounding box, since it does not take into account curved faces, and it may be smaller than the true bounding box.

Parameters
[in]cellThe cell for which you want to compute the bounding box

Definition at line 68 of file mapping.cc.

◆ transform_points_real_to_unit_cell()

template<int dim, int spacedim>
void Mapping< dim, spacedim >::transform_points_real_to_unit_cell ( const typename Triangulation< dim, spacedim >::cell_iterator &  cell,
const ArrayView< const Point< spacedim >> &  real_points,
const ArrayView< Point< dim >> &  unit_points 
) const
virtualinherited

Map multiple points from the real point locations to points in reference locations. The functionality is essentially the same as looping over all points and calling the Mapping::transform_real_to_unit_cell() function for each point individually, but it can be much faster for certain mappings that implement a more specialized version such as MappingQGeneric. The only difference in behavior is that this function will never throw an ExcTransformationFailed() exception. If the transformation fails for real_points[i], the returned unit_points[i] contains std::numeric_limits<double>::infinity() as the first entry.

Reimplemented in MappingQGeneric< dim, spacedim >.

Definition at line 81 of file mapping.cc.

◆ project_real_point_to_unit_point_on_face()

template<int dim, int spacedim>
Point< dim - 1 > Mapping< dim, spacedim >::project_real_point_to_unit_point_on_face ( const typename Triangulation< dim, spacedim >::cell_iterator &  cell,
const unsigned int  face_no,
const Point< spacedim > &  p 
) const
inherited

Transform the point p on the real cell to the corresponding point on the reference cell, and then project this point to a (dim-1)-dimensional point in the coordinate system of the face with the given face number face_no. Ideally the point p is near the face face_no, but any point in the cell can technically be projected.

This function does not make physical sense when dim=1, so it throws an exception in this case.

Definition at line 105 of file mapping.cc.

◆ fill_fe_values() [2/2]

template<int dim, int spacedim = dim>
virtual CellSimilarity::Similarity Mapping< dim, spacedim >::fill_fe_values ( const typename Triangulation< dim, spacedim >::cell_iterator &  cell,
const CellSimilarity::Similarity  cell_similarity,
const Quadrature< dim > &  quadrature,
const typename Mapping< dim, spacedim >::InternalDataBase internal_data,
::internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &  output_data 
) const
protectedpure virtualinherited

Compute information about the mapping from the reference cell to the real cell indicated by the first argument to this function. Derived classes will have to implement this function based on the kind of mapping they represent. It is called by FEValues::reinit().

Conceptually, this function's represents the application of the mapping \(\mathbf x=\mathbf F_K(\hat {\mathbf x})\) from reference coordinates \(\mathbf\in [0,1]^d\) to real space coordinates \(\mathbf x\) for a given cell \(K\). Its purpose is to compute the following kinds of data:

  • Data that results from the application of the mapping itself, e.g., computing the location \(\mathbf x_q = \mathbf F_K(\hat{\mathbf x}_q)\) of quadrature points on the real cell, and that is directly useful to users of FEValues, for example during assembly.
  • Data that is necessary for finite element implementations to compute their shape functions on the real cell. To this end, the FEValues::reinit() function calls FiniteElement::fill_fe_values() after the current function, and the output of this function serves as input to FiniteElement::fill_fe_values(). Examples of information that needs to be computed here for use by the finite element classes is the Jacobian of the mapping, \(\hat\nabla \mathbf F_K(\hat{\mathbf x})\) or its inverse, for example to transform the gradients of shape functions on the reference cell to the gradients of shape functions on the real cell.

The information computed by this function is used to fill the various member variables of the output argument of this function. Which of the member variables of that structure should be filled is determined by the update flags stored in the Mapping::InternalDataBase object passed to this function.

An extensive discussion of the interaction between this function and FEValues can be found in the How Mapping, FiniteElement, and FEValues work together documentation module.

Parameters
[in]cellThe cell of the triangulation for which this function is to compute a mapping from the reference cell to.
[in]cell_similarityWhether or not the cell given as first argument is simply a translation, rotation, etc of the cell for which this function was called the most recent time. This information is computed simply by matching the vertices (as stored by the Triangulation) between the previous and the current cell. The value passed here may be modified by implementations of this function and should then be returned (see the discussion of the return value of this function).
[in]quadratureA reference to the quadrature formula in use for the current evaluation. This quadrature object is the same as the one used when creating the internal_data object. The object is used both to map the location of quadrature points, as well as to compute the JxW values for each quadrature point (which involves the quadrature weights).
[in]internal_dataA reference to an object previously created by get_data() and that may be used to store information the mapping can compute once on the reference cell. See the documentation of the Mapping::InternalDataBase class for an extensive description of the purpose of these objects.
[out]output_dataA reference to an object whose member variables should be computed. Not all of the members of this argument need to be filled; which ones need to be filled is determined by the update flags stored inside the internal_data object.
Returns
An updated value of the cell_similarity argument to this function. The returned value will be used for the corresponding argument when FEValues::reinit() calls FiniteElement::fill_fe_values(). In most cases, derived classes will simply want to return the value passed for cell_similarity. However, implementations of this function may downgrade the level of cell similarity. This is, for example, the case for classes that take not only into account the locations of the vertices of a cell (as reported by the Triangulation), but also other information specific to the mapping. The purpose is that FEValues::reinit() can compute whether a cell is similar to the previous one only based on the cell's vertices, whereas the mapping may also consider displacement fields (e.g., in the MappingQ1Eulerian and MappingFEField classes). In such cases, the mapping may conclude that the previously computed cell similarity is too optimistic, and invalidate it for subsequent use in FiniteElement::fill_fe_values() by returning a less optimistic cell similarity value.
Note
FEValues ensures that this function is always called with the same pair of internal_data and output_data objects. In other words, if an implementation of this function knows that it has written a piece of data into the output argument in a previous call, then there is no need to copy it there again in a later call if the implementation knows that this is the same value.

Implemented in MappingQGeneric< dim, spacedim >, MappingFE< dim, spacedim >, and MappingManifold< dim, spacedim >.

◆ fill_fe_face_values() [2/2]

template<int dim, int spacedim = dim>
virtual void Mapping< dim, spacedim >::fill_fe_face_values ( const typename Triangulation< dim, spacedim >::cell_iterator &  cell,
const unsigned int  face_no,
const Quadrature< dim - 1 > &  quadrature,
const typename Mapping< dim, spacedim >::InternalDataBase internal_data,
::internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &  output_data 
) const
protectedpure virtualinherited

This function is the equivalent to Mapping::fill_fe_values(), but for faces of cells. See there for an extensive discussion of its purpose. It is called by FEFaceValues::reinit().

Parameters
[in]cellThe cell of the triangulation for which this function is to compute a mapping from the reference cell to.
[in]face_noThe number of the face of the given cell for which information is requested.
[in]quadratureA reference to the quadrature formula in use for the current evaluation. This quadrature object is the same as the one used when creating the internal_data object. The object is used both to map the location of quadrature points, as well as to compute the JxW values for each quadrature point (which involves the quadrature weights).
[in]internal_dataA reference to an object previously created by get_data() and that may be used to store information the mapping can compute once on the reference cell. See the documentation of the Mapping::InternalDataBase class for an extensive description of the purpose of these objects.
[out]output_dataA reference to an object whose member variables should be computed. Not all of the members of this argument need to be filled; which ones need to be filled is determined by the update flags stored inside the internal_data object.

Implemented in MappingQGeneric< dim, spacedim >, MappingFE< dim, spacedim >, and MappingManifold< dim, spacedim >.

◆ fill_fe_subface_values() [2/2]

template<int dim, int spacedim = dim>
virtual void Mapping< dim, spacedim >::fill_fe_subface_values ( const typename Triangulation< dim, spacedim >::cell_iterator &  cell,
const unsigned int  face_no,
const unsigned int  subface_no,
const Quadrature< dim - 1 > &  quadrature,
const typename Mapping< dim, spacedim >::InternalDataBase internal_data,
::internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &  output_data 
) const
protectedpure virtualinherited

This function is the equivalent to Mapping::fill_fe_values(), but for subfaces (i.e., children of faces) of cells. See there for an extensive discussion of its purpose. It is called by FESubfaceValues::reinit().

Parameters
[in]cellThe cell of the triangulation for which this function is to compute a mapping from the reference cell to.
[in]face_noThe number of the face of the given cell for which information is requested.
[in]subface_noThe number of the child of a face of the given cell for which information is requested.
[in]quadratureA reference to the quadrature formula in use for the current evaluation. This quadrature object is the same as the one used when creating the internal_data object. The object is used both to map the location of quadrature points, as well as to compute the JxW values for each quadrature point (which involves the quadrature weights).
[in]internal_dataA reference to an object previously created by get_data() and that may be used to store information the mapping can compute once on the reference cell. See the documentation of the Mapping::InternalDataBase class for an extensive description of the purpose of these objects.
[out]output_dataA reference to an object whose member variables should be computed. Not all of the members of this argument need to be filled; which ones need to be filled is determined by the update flags stored inside the internal_data object.

Implemented in MappingQGeneric< dim, spacedim >, MappingFE< dim, spacedim >, and MappingManifold< dim, spacedim >.

◆ subscribe()

void Subscriptor::subscribe ( std::atomic< bool > *const  validity,
const std::string &  identifier = "" 
) const
inherited

Subscribes a user of the object by storing the pointer validity. The subscriber may be identified by text supplied as identifier.

Definition at line 136 of file subscriptor.cc.

◆ unsubscribe()

void Subscriptor::unsubscribe ( std::atomic< bool > *const  validity,
const std::string &  identifier = "" 
) const
inherited

Unsubscribes a user from the object.

Note
The identifier and the validity pointer must be the same as the one supplied to subscribe().

Definition at line 156 of file subscriptor.cc.

◆ n_subscriptions()

unsigned int Subscriptor::n_subscriptions ( ) const
inlineinherited

Return the present number of subscriptions to this object. This allows to use this class for reference counted lifetime determination where the last one to unsubscribe also deletes the object.

Definition at line 300 of file subscriptor.h.

◆ list_subscribers() [1/2]

template<typename StreamType >
void Subscriptor::list_subscribers ( StreamType &  stream) const
inlineinherited

List the subscribers to the input stream.

Definition at line 317 of file subscriptor.h.

◆ list_subscribers() [2/2]

void Subscriptor::list_subscribers ( ) const
inherited

List the subscribers to deallog.

Definition at line 204 of file subscriptor.cc.

◆ serialize()

template<class Archive >
void Subscriptor::serialize ( Archive &  ar,
const unsigned int  version 
)
inlineinherited

Read or write the data of this object to or from a stream for the purpose of serialization.

This function does not actually serialize any of the member variables of this class. The reason is that what this class stores is only who subscribes to this object, but who does so at the time of storing the contents of this object does not necessarily have anything to do with who subscribes to the object when it is restored. Consequently, we do not want to overwrite the subscribers at the time of restoring, and then there is no reason to write the subscribers out in the first place.

Definition at line 309 of file subscriptor.h.

Friends And Related Function Documentation

◆ MappingFEField

template<int dim, int spacedim = dim, typename VectorType = Vector<double>, typename DoFHandlerType = DoFHandler<dim, spacedim>>
template<int , int , class , class >
friend class MappingFEField
friend

Definition at line 652 of file mapping_fe_field.h.

Member Data Documentation

◆ uses_level_dofs

template<int dim, int spacedim = dim, typename VectorType = Vector<double>, typename DoFHandlerType = DoFHandler<dim, spacedim>>
const bool MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::uses_level_dofs
private

Specifies whether we access unknowns on the active dofs (with a single Euler vector) or on the level dofs (via a vector of Euler vectors).

Definition at line 534 of file mapping_fe_field.h.

◆ euler_vector

template<int dim, int spacedim = dim, typename VectorType = Vector<double>, typename DoFHandlerType = DoFHandler<dim, spacedim>>
std::vector< SmartPointer<const VectorType, MappingFEField<dim, spacedim, VectorType, DoFHandlerType> > > MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::euler_vector
private

Reference to the vector of shifts.

Definition at line 542 of file mapping_fe_field.h.

◆ euler_dof_handler

template<int dim, int spacedim = dim, typename VectorType = Vector<double>, typename DoFHandlerType = DoFHandler<dim, spacedim>>
SmartPointer<const DoFHandlerType, MappingFEField<dim, spacedim, VectorType, DoFHandlerType> > MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::euler_dof_handler
private

Pointer to the DoFHandler to which the mapping vector is associated.

Definition at line 549 of file mapping_fe_field.h.

◆ fe_mask

template<int dim, int spacedim = dim, typename VectorType = Vector<double>, typename DoFHandlerType = DoFHandler<dim, spacedim>>
const ComponentMask MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::fe_mask
private

Definition at line 613 of file mapping_fe_field.h.

◆ fe_to_real

template<int dim, int spacedim = dim, typename VectorType = Vector<double>, typename DoFHandlerType = DoFHandler<dim, spacedim>>
std::vector<unsigned int> MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::fe_to_real
private

Mapping between indices in the FE space and the real space. This vector contains one index for each component of the finite element space. If the index is one for which the ComponentMask which is used to construct this element is false, then numbers::invalid_unsigned_int is returned, otherwise the component in real space is returned. For example, if we construct the mapping using ComponentMask(spacedim, true), then this vector contains {0,1,2} in spacedim = 3.

Definition at line 624 of file mapping_fe_field.h.

◆ fe_values

template<int dim, int spacedim = dim, typename VectorType = Vector<double>, typename DoFHandlerType = DoFHandler<dim, spacedim>>
FEValues<dim, spacedim> MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::fe_values
mutableprivate

FEValues object used to query the given finite element field at the support points in the reference configuration.

Definition at line 630 of file mapping_fe_field.h.

◆ fe_values_mutex

template<int dim, int spacedim = dim, typename VectorType = Vector<double>, typename DoFHandlerType = DoFHandler<dim, spacedim>>
std::mutex MappingFEField< dim, spacedim, VectorType, DoFHandlerType >::fe_values_mutex
mutableprivate

A variable to guard access to the fe_values variable.

Definition at line 635 of file mapping_fe_field.h.


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