Reference documentation for deal.II version 9.3.3
MappingQEulerian< dim, VectorType, spacedim > Class Template Referenceabstract

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

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

## Classes

class  MappingQEulerianGeneric

## Public Member Functions

MappingQEulerian (const unsigned int degree, const DoFHandler< dim, spacedim > &euler_dof_handler, const VectorType &euler_vector, const unsigned int level=numbers::invalid_unsigned_int)

virtual boost::container::small_vector< Point< spacedim >, GeometryInfo< dim >::vertices_per_cell > get_vertices (const typename Triangulation< dim, spacedim >::cell_iterator &cell) const override

virtual std::unique_ptr< Mapping< dim, spacedim > > clone () const override

virtual bool preserves_vertex_locations () const override

virtual BoundingBox< spacedim > get_bounding_box (const typename Triangulation< dim, spacedim >::cell_iterator &cell) const override

unsigned int get_degree () const

virtual bool is_compatible_with (const ReferenceCell &reference_cell) const override

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

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

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

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

## Static Public Member Functions

static ::ExceptionBaseExcInactiveCell ()

Exceptions
static ::ExceptionBaseExcInvalidData ()

static ::ExceptionBaseExcTransformationFailed ()

static ::ExceptionBaseExcDistortedMappedCell (Point< spacedim > arg1, double arg2, int arg3)

## Protected Member Functions

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

Interface with FEValues
virtual UpdateFlags requires_update_flags (const UpdateFlags update_flags) const override

virtual std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > get_data (const UpdateFlags, const Quadrature< dim > &quadrature) const override

virtual std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > get_face_data (const UpdateFlags flags, const hp::QCollection< dim - 1 > &quadrature) const override

virtual std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > get_subface_data (const UpdateFlags flags, const Quadrature< dim - 1 > &quadrature) const override

virtual void fill_fe_face_values (const typename Triangulation< dim, spacedim >::cell_iterator &cell, const unsigned int face_no, const hp::QCollection< 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

Interface with FEValues
virtual std::unique_ptr< InternalDataBase > get_face_data (const UpdateFlags update_flags, const Quadrature< dim - 1 > &quadrature) const

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 hp::QCollection< dim - 1 > &quadrature, const typename Mapping< dim, spacedim >::InternalDataBase &internal_data, ::internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &output_data) const

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

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

## Protected Attributes

SmartPointer< const VectorType, MappingQEulerian< dim, VectorType, spacedim > > euler_vector

SmartPointer< const DoFHandler< dim, spacedim >, MappingQEulerian< dim, VectorType, spacedim > > euler_dof_handler

const unsigned int polynomial_degree

const bool use_mapping_q_on_all_cells

std::shared_ptr< const MappingQGeneric< dim, spacedim > > q1_mapping

std::shared_ptr< const MappingQGeneric< dim, spacedim > > qp_mapping

## Private Attributes

const unsigned int level

## Subscriptor functionality

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

std::atomic< unsigned intcounter

std::map< std::string, unsigned intcounter_map

std::vector< std::atomic< bool > * > validity_pointers

const std::type_info * object_info

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

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

static ::ExceptionBaseExcInUse (int arg1, std::string arg2, std::string arg3)

static ::ExceptionBaseExcNoSubscriber (std::string arg1, std::string arg2)

using map_value_type = decltype(counter_map)::value_type

using map_iterator = decltype(counter_map)::iterator

static std::mutex mutex

void check_no_subscribers () const noexcept

## Detailed Description

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
class MappingQEulerian< dim, VectorType, spacedim >

This class is an extension of the MappingQ1Eulerian class to higher order $$Q_p$$ mappings. It is useful when one wants to calculate shape function information on a domain that is deforming as the computation proceeds.

### Usage

The constructor of this class takes three arguments: the polynomial degree of the desired Qp mapping, a reference to the vector that defines the mapping from the initial configuration to the current configuration, and a reference to the DoFHandler. The most common case is to use the solution vector for the problem under consideration as the shift vector. The key requirement is that the number of components of the given vector field must be equal to (or possibly greater than) the number of space dimensions. If there are more components than space dimensions (for example, if one is working with a coupled problem where there are additional solution variables), the first dim components are assumed to represent the displacement field, and the remaining components are ignored. If this assumption does not hold one may need to set up a separate DoFHandler on the triangulation and associate the desired shift vector to it.

Typically, the DoFHandler operates on a finite element that is constructed as a system element (FESystem) from continuous FE_Q objects. An example is shown below:

FESystem<dim> fe(FE_Q<dim>(2), dim, FE_Q<dim>(1), 1);
dof_handler.distribute_dofs(fe);
Vector<double> displacement_field(dof_handler.n_dofs());
// ... compute displacement field somehow...
MappingQEulerian<dim> q2_mapping(2, dof_handler, displacement_field);
Definition: fe_q.h:549
Definition: vector.h:110
const ::parallel::distributed::Triangulation< dim, spacedim > * triangulation

In this example, our element consists of (dim+1) components. Only the first dim components will be used, however, to define the Q2 mapping. The remaining components are ignored.

Note that it is essential to call the distribute_dofs(...) function before constructing a mapping object.

Also note that since the vector of shift values and the dof handler are only associated to this object at construction time, you have to make sure that whenever you use this object, the given objects still represent valid data.

To enable the use of the MappingQEulerian class also in the context of parallel codes using the PETSc or Trilinos wrapper classes, the type of the vector can be specified as template parameter VectorType.

Definition at line 93 of file mapping_q_eulerian.h.

## ◆ MappingQEulerian()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
 MappingQEulerian< dim, VectorType, spacedim >::MappingQEulerian ( const unsigned int degree, const DoFHandler< dim, spacedim > & euler_dof_handler, const VectorType & euler_vector, const unsigned int level = numbers::invalid_unsigned_int )

Constructor.

Parameters
 [in] degree The polynomial degree of the desired $$Q_p$$ mapping. [in] euler_dof_handler A DoFHandler object that defines a finite element space. This space needs to have at least dim components and the first dim components of the space will be considered displacements relative to the original positions of the cells of the triangulation. [in] euler_vector A finite element function in the space defined by the second argument. The first dim components of this function will be interpreted as the displacement we use in defining the mapping, relative to the location of cells of the underlying triangulation. [in] level The multi-grid level at which the mapping will be used. It is mainly used to check if the size of the euler_vector is consistent with the euler_dof_handler .

## ◆ get_vertices()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
 virtual boost::container::small_vector< Point< spacedim >, GeometryInfo< dim >::vertices_per_cell > MappingQEulerian< dim, VectorType, spacedim >::get_vertices ( const typename Triangulation< dim, spacedim >::cell_iterator & cell ) const
overridevirtual

Return the mapped vertices of the cell. For the current class, this function does not use the support points from the geometry of the current cell but instead evaluates an externally given displacement field in addition to the geometry of the cell.

Reimplemented from Mapping< dim, spacedim >.

## ◆ clone()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
 virtual std::unique_ptr< Mapping< dim, spacedim > > MappingQEulerian< dim, VectorType, spacedim >::clone ( ) const
overridevirtual

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

Reimplemented from MappingQ< dim, dim >.

## ◆ preserves_vertex_locations()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
 virtual bool MappingQEulerian< dim, VectorType, spacedim >::preserves_vertex_locations ( ) const
overridevirtual

Always return false because MappingQEulerian does not in general preserve vertex locations (unless the translation vector happens to provide zero displacements at vertex locations).

Reimplemented from MappingQ< dim, dim >.

## ◆ get_bounding_box()

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
 virtual BoundingBox< spacedim > MappingQEulerian< dim, VectorType, spacedim >::get_bounding_box ( const typename Triangulation< dim, spacedim >::cell_iterator & cell ) const
overridevirtual

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.

For linear mappings, this function returns the bounding box containing all the vertices of the cell, as returned by the get_vertices() method. For higher order mappings defined through support points, the bounding box is only guaranteed to contain all the support points, and it is, in general, only an approximation of the true bounding box, which may be larger.

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

Reimplemented from MappingQ< dim, dim >.

## ◆ fill_fe_values() [1/2]

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
 virtual CellSimilarity::Similarity MappingQEulerian< dim, VectorType, 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
overrideprotectedvirtual

Compute mapping-related information for a cell. See the documentation of Mapping::fill_fe_values() for a discussion of purpose, arguments, and return value of this function.

This function overrides the function in the base class since we cannot use any cell similarity for this class.

Reimplemented from MappingQ< dim, dim >.

## ◆ get_degree()

 unsigned int MappingQ< dim, spacedim >::get_degree ( ) const
inherited

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

## ◆ is_compatible_with()

 virtual bool MappingQ< dim, spacedim >::is_compatible_with ( const ReferenceCell & reference_cell ) const
overridevirtualinherited

Returns if this instance of Mapping is compatible with the type of cell in reference_cell.

Implements Mapping< dim, spacedim >.

## ◆ transform_unit_to_real_cell()

 virtual Point< spacedim > MappingQ< dim, spacedim >::transform_unit_to_real_cell ( const typename Triangulation< dim, spacedim >::cell_iterator & cell, const Point< dim > & p ) const
overridevirtualinherited

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

Implements Mapping< dim, spacedim >.

## ◆ transform_real_to_unit_cell()

 virtual Point< dim > MappingQ< dim, spacedim >::transform_real_to_unit_cell ( const typename Triangulation< dim, spacedim >::cell_iterator & cell, const Point< spacedim > & p ) const
overridevirtualinherited

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

Uses Newton iteration and the transform_unit_to_real_cell function.

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 return reference coordinates lie inside of outside the reference cell (e.g., using GeometryInfo::is_inside_unit_cell) or whether the exception mentioned above has been thrown.

Implements Mapping< dim, spacedim >.

## ◆ transform() [1/5]

 virtual void MappingQ< dim, spacedim >::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
overridevirtualinherited

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] input An array (or part of an array) of input objects that should be mapped. [in] kind The kind of mapping to be applied. [in] internal A 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] output An 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 >.

## ◆ transform() [2/5]

 virtual void MappingQ< dim, spacedim >::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
overridevirtualinherited

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] input An array (or part of an array) of input objects that should be mapped. [in] kind The kind of mapping to be applied. [in] internal A 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] output An 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 >.

## ◆ transform() [3/5]

 virtual void MappingQ< dim, spacedim >::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
overridevirtualinherited

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] input An array (or part of an array) of input objects that should be mapped. [in] kind The kind of mapping to be applied. [in] internal A 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] output An 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 >.

## ◆ transform() [4/5]

 virtual void MappingQ< dim, spacedim >::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
overridevirtualinherited

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] input An array (or part of an array) of input objects that should be mapped. [in] kind The kind of mapping to be applied. [in] internal A 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] output An 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 >.

## ◆ transform() [5/5]

 virtual void MappingQ< dim, spacedim >::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
overridevirtualinherited

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] input An array (or part of an array) of input objects that should be mapped. [in] kind The kind of mapping to be applied. [in] internal A 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] output An array (or part of an array) into which the transformed objects should be placed.

Implements Mapping< dim, spacedim >.

## ◆ requires_update_flags()

 virtual UpdateFlags MappingQ< dim, spacedim >::requires_update_flags ( const UpdateFlags update_flags ) const
overrideprotectedvirtualinherited

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.

UpdateFlags

Implements Mapping< dim, spacedim >.

## ◆ get_data()

 virtual std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > MappingQ< dim, spacedim >::get_data ( const UpdateFlags, const Quadrature< dim > & quadrature ) const
overrideprotectedvirtualinherited

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_flags A 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. quadrature The 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 >.

## ◆ get_face_data() [1/2]

 virtual std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > MappingQ< dim, spacedim >::get_face_data ( const UpdateFlags flags, const hp::QCollection< dim - 1 > & quadrature ) const
overrideprotectedvirtualinherited

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_flags A 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. quadrature The 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.

Reimplemented from Mapping< dim, spacedim >.

## ◆ get_face_data() [2/2]

 virtual std::unique_ptr< InternalDataBase > Mapping< dim, spacedim >::get_face_data ( const UpdateFlags update_flags, const Quadrature< dim - 1 > & quadrature ) const
protectedvirtualinherited
Deprecated:
Use the version taking a hp::QCollection argument.

## ◆ get_subface_data()

 virtual std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > MappingQ< dim, spacedim >::get_subface_data ( const UpdateFlags flags, const Quadrature< dim - 1 > & quadrature ) const
overrideprotectedvirtualinherited

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_flags A 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. quadrature The 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 >.

## ◆ fill_fe_values() [2/2]

 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] cell The cell of the triangulation for which this function is to compute a mapping from the reference cell to. [in] cell_similarity Whether 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] quadrature A 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_data A 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_data A 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 >, and MappingQGeneric< dim, dim >.

## ◆ fill_fe_face_values() [1/3]

 virtual void MappingQ< dim, spacedim >::fill_fe_face_values ( const typename Triangulation< dim, spacedim >::cell_iterator & cell, const unsigned int face_no, const hp::QCollection< dim - 1 > & quadrature, const typename Mapping< dim, spacedim >::InternalDataBase & internal_data, internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > & output_data ) const
overrideprotectedvirtualinherited

## ◆ fill_fe_face_values() [2/3]

 virtual void Mapping< dim, spacedim >::fill_fe_face_values ( const typename Triangulation< dim, spacedim >::cell_iterator & cell, const unsigned int face_no, const hp::QCollection< dim - 1 > & quadrature, const typename Mapping< dim, spacedim >::InternalDataBase & internal_data, ::internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > & output_data ) const
protectedvirtualinherited

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] cell The cell of the triangulation for which this function is to compute a mapping from the reference cell to. [in] face_no The number of the face of the given cell for which information is requested. [in] quadrature A 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_data A 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_data A 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.

Reimplemented in MappingQGeneric< dim, spacedim >, and MappingQGeneric< dim, dim >.

## ◆ fill_fe_face_values() [3/3]

 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
protectedvirtualinherited
Deprecated:
Use the version taking a hp::QCollection argument.

## ◆ fill_fe_subface_values() [1/2]

 virtual void MappingQ< 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
overrideprotectedvirtualinherited

## ◆ fill_fe_subface_values() [2/2]

 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] cell The cell of the triangulation for which this function is to compute a mapping from the reference cell to. [in] face_no The number of the face of the given cell for which information is requested. [in] subface_no The number of the child of a face of the given cell for which information is requested. [in] quadrature A 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_data A 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_data A 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 >, and MappingQGeneric< dim, dim >.

## ◆ get_center()

 virtual 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] cell The cell for which you want to compute the center [in] map_center_of_reference_cell A 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.

## ◆ transform_points_real_to_unit_cell()

 virtual 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 >, and MappingQGeneric< dim, dim >.

## ◆ project_real_point_to_unit_point_on_face()

 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.

## ◆ ExcInvalidData()

 static ::ExceptionBase & Mapping< dim, spacedim >::ExcInvalidData ( )
staticinherited

Exception

## ◆ ExcTransformationFailed()

 static ::ExceptionBase & Mapping< dim, spacedim >::ExcTransformationFailed ( )
staticinherited

Computing the mapping between a real space point and a point in reference space failed, typically because the given point lies outside the cell where the inverse mapping is not unique.

Note
The message that will be printed by this exception reads:
"Computing the mapping between a real space point and a point in reference " "space failed, typically because the given point lies outside the cell " "where the inverse mapping is not unique."

## ◆ ExcDistortedMappedCell()

 static ::ExceptionBase & Mapping< dim, spacedim >::ExcDistortedMappedCell ( Point< spacedim > arg1, double arg2, int arg3 )
staticinherited

deal.II assumes the Jacobian determinant to be positive. When the cell geometry is distorted under the image of the mapping, the mapping becomes invalid and this exception is thrown.

Note
The message that will be printed by this exception reads:
<< "The image of the mapping applied to cell with center [" << arg1 << "] is distorted. The cell geometry or the " << "mapping are invalid, giving a non-positive volume " << "fraction of " << arg2 << " in quadrature point " << arg3 << "."

## ◆ euler_vector

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
 SmartPointer > MappingQEulerian< dim, VectorType, spacedim >::euler_vector
protected

Reference to the vector of shifts.

Definition at line 176 of file mapping_q_eulerian.h.

## ◆ euler_dof_handler

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
 SmartPointer, MappingQEulerian > MappingQEulerian< dim, VectorType, spacedim >::euler_dof_handler
protected

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

Definition at line 183 of file mapping_q_eulerian.h.

## ◆ level

template<int dim, typename VectorType = Vector<double>, int spacedim = dim>
 const unsigned int MappingQEulerian< dim, VectorType, spacedim >::level
private

Multigrid level at which the mapping is to be used.

Definition at line 190 of file mapping_q_eulerian.h.

## ◆ polynomial_degree

 const unsigned int MappingQ< dim, spacedim >::polynomial_degree
protectedinherited

The polynomial degree of the cells to be used on all cells at the boundary of the domain, or everywhere if so specified.

Definition at line 336 of file mapping_q.h.

## ◆ use_mapping_q_on_all_cells

 const bool MappingQ< dim, spacedim >::use_mapping_q_on_all_cells
protectedinherited

If this flag is set true then MappingQ is used on all cells, not only on boundary cells.

Definition at line 342 of file mapping_q.h.

## ◆ q1_mapping

 std::shared_ptr > MappingQ< dim, spacedim >::q1_mapping
protectedinherited

Pointer to a Q1 mapping. This mapping is used on interior cells unless use_mapping_q_on_all_cells was set in the call to the constructor. The mapping is also used on any cell in the transform_real_to_unit_cell() to compute a cheap initial guess for the position of the point before we employ the more expensive Newton iteration using the full mapping.

Note
MappingQEulerian resets this pointer to an object of type MappingQ1Eulerian to ensure that the Q1 mapping also knows about the proper shifts and transformations of the Eulerian displacements. This also means that we really need to store our own Q1 mapping here, rather than simply resorting to StaticMappingQ1::mapping.
If the polynomial degree used for the current object is one, then the qp_mapping and q1_mapping variables point to the same underlying object.

Definition at line 361 of file mapping_q.h.

## ◆ qp_mapping

 std::shared_ptr > MappingQ< dim, spacedim >::qp_mapping
protectedinherited

Pointer to a Q_p mapping. This mapping is used on boundary cells unless use_mapping_q_on_all_cells was set in the call to the constructor (in which case it is used for all cells).

Note
MappingQEulerian and MappingC1 reset this pointer to an object of their own implementation to ensure that the Q_p mapping also knows about the proper shifts and transformations of the Eulerian displacements (Eulerian case) and proper choice of support points (C1 case).
If the polynomial degree used for the current object is one, then the qp_mapping and q1_mapping variables point to the same underlying object.

Definition at line 377 of file mapping_q.h.

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