--- /dev/null
+Changed: mapping.h referred to different kinds of mappings in an enum
+MappingType; however, since it's an enum, MappingType is a misleading name.
+All instances of MappingType and mapping_type have been changed to
+MappingKind and mapping_kind, respectively. The documentation has been
+updated in order to reflect these changes as well.
+<br>
+(Graham Harper, 2019/08/06)
* the node functionals of the element applied to the given function.
*
* @note It is safe to call this function for (transformed) values on the
- * real cell only for elements with trivial MappingType. For all other
+ * real cell only for elements with trivial MappingKind. For all other
* elements (for example for H(curl), or H(div) conforming elements)
* vector values have to be transformed to the reference cell first.
*
/**
* Constructor for the vector element of degree @p p.
*/
- FE_DGVector(const unsigned int p, MappingType m);
+ FE_DGVector(const unsigned int p, MappingKind m);
/**
* Return a string that uniquely identifies a finite element. This class
template <class PolynomialType, int dim, int spacedim>
FE_DGVector<PolynomialType, dim, spacedim>::FE_DGVector(const unsigned int deg,
- MappingType map)
+ MappingKind map)
: FE_PolyTensor<PolynomialType, dim, spacedim>(
deg,
FiniteElementData<dim>(get_dpo_vector(deg),
std::vector<ComponentMask>(PolynomialType::compute_n_pols(deg),
ComponentMask(dim, true)))
{
- this->mapping_type = {map};
+ this->mapping_kind = {map};
const unsigned int polynomial_degree = this->tensor_degree();
QGauss<dim> quadrature(polynomial_degree + 1);
/**
* Given <tt>flags</tt>, determines the values which must be computed only
- * for the reference cell. Make sure, that #mapping_type is set by the
+ * for the reference cell. Make sure, that #mapping_kind is set by the
* derived class, such that this function can operate correctly.
*/
UpdateFlags
/**
* Given <tt>flags</tt>, determines the values which must be computed in
- * each cell cell. Make sure, that #mapping_type is set by the derived
+ * each cell cell. Make sure, that #mapping_kind is set by the derived
* class, such that this function can operate correctly.
*/
UpdateFlags
protected:
/**
- * The mapping type to be used to map shape functions from the reference
+ * The mapping kind to be used to map shape functions from the reference
* cell to the mesh cell.
*/
- MappingType mapping_type;
+ MappingKind mapping_kind;
virtual std::unique_ptr<
typename dealii::FiniteElement<dim, spacedim>::InternalDataBase>
*
* Similarly, in many cases, node functionals depend on the shape of the mesh
* cell, since they evaluate normal or tangential components on the faces. In
- * order to allow for a set of transformations, the variable #mapping_type has
+ * order to allow for a set of transformations, the variable #mapping_kind has
* been introduced. It should needs be set in the constructor of a derived
* class.
*
*
* In most cases, vector valued basis functions must be transformed when
* mapped from the reference cell to the actual grid cell. These
- * transformations can be selected from the set MappingType and stored in
- * #mapping_type. Therefore, each constructor should contain a line like:
+ * transformations can be selected from the set MappingKind and stored in
+ * #mapping_kind. Therefore, each constructor should contain a line like:
* @code
- * this->mapping_type = {mapping_none};
+ * this->mapping_kind = {mapping_none};
* @endcode
* (in case no mapping is required) or using whatever value among
- * the ones defined in MappingType is appropriate for the element you
+ * the ones defined in MappingKind is appropriate for the element you
* are implementing. If each shape function may be mapped by different
- * mappings, then @p mapping_type may be a vector with the same number
+ * mappings, then @p mapping_kind may be a vector with the same number
* of elements as there are shape functions.
*
* @see PolynomialsBDM, PolynomialsRaviartThomas
* the finite element dofs per cell, then each shape function will be mapped
* according to the corresponding entry in the vector.
*/
- std::vector<MappingType> mapping_type;
+ std::vector<MappingKind> mapping_kind;
/**
* Returns a boolean that is true when the finite element uses a single
* mapping and false when the finite element uses multiple mappings.
*/
bool
- single_mapping_type() const;
+ single_mapping_kind() const;
/**
- * Returns MappingType @p i for the finite element.
+ * Returns MappingKind @p i for the finite element.
*/
- MappingType
- get_mapping_type(const unsigned int i) const;
+ MappingKind
+ get_mapping_kind(const unsigned int i) const;
/* NOTE: The following function has its definition inlined into the class
declaration because we otherwise run into a compiler error with MS Visual
// allocate memory
const bool update_transformed_shape_values =
- std::any_of(this->mapping_type.begin(),
- this->mapping_type.end(),
- [](const MappingType t) { return t != mapping_none; });
+ std::any_of(this->mapping_kind.begin(),
+ this->mapping_kind.end(),
+ [](const MappingKind t) { return t != mapping_none; });
const bool update_transformed_shape_grads =
- std::any_of(this->mapping_type.begin(),
- this->mapping_type.end(),
- [](const MappingType t) {
+ std::any_of(this->mapping_kind.begin(),
+ this->mapping_kind.end(),
+ [](const MappingKind t) {
return (t == mapping_raviart_thomas || t == mapping_piola ||
t == mapping_nedelec || t == mapping_contravariant);
});
/**
- * The transformation type used for the Mapping::transform() functions.
+ * The transformation kind used for the Mapping::transform() functions.
*
* Special finite elements may need special Mapping from the reference cell to
* the actual mesh cell. In order to be most flexible, this enum provides an
*
* @ingroup mapping
*/
-enum MappingType
+enum MappingKind
{
/**
* No mapping, i.e., shape functions are not mapped from a reference cell
* The mapping used for Nedelec elements.
*
* Curl-conforming elements are mapped as covariant vectors. Nevertheless,
- * we introduce a separate mapping type, such that we can use the same flag
+ * we introduce a separate mapping kind, such that we can use the same flag
* for the vector and its gradient (see Mapping::transform() for details).
*/
mapping_nedelec = 0x0200,
* The differential forms <b>A</b> and <b>B</b> are determined by the kind of
* object being transformed. These transformations are performed through the
* transform() functions, and the type of object being transformed is
- * specified by their MappingType argument. See the documentation there for
+ * specified by their MappingKind argument. See the documentation there for
* possible choices.
*
* <h4>Derivatives of the mapping</h4>
/**
* Transform a field of vectors or 1-differential forms according to the
- * selected MappingType.
+ * selected MappingKind.
*
* @note Normally, this function is called by a finite element, filling
* FEValues objects. For this finite element, there should be an alias
- * MappingType like @p mapping_bdm, @p mapping_nedelec, etc. This alias
- * should be preferred to using the types below.
+ * MappingKind like @p mapping_bdm, @p mapping_nedelec, etc. This alias
+ * should be preferred to using the kinds below.
*
- * The mapping types currently implemented by derived classes are:
+ * The mapping kinds currently implemented by derived classes are:
* <ul>
* <li> @p mapping_contravariant: maps a vector field on the reference cell
* to the physical cell through the Jacobian:
*
* @param[in] input An array (or part of an array) of input objects that
* should be mapped.
- * @param[in] type The kind of mapping to be applied.
+ * @param[in] kind The kind of mapping to be applied.
* @param[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(),
*/
virtual void
transform(const ArrayView<const Tensor<1, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<1, spacedim>> &output) const = 0;
* 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 types currently implemented by derived classes
+ * vector field. The mapping kinds currently implemented by derived classes
* are:
* <ul>
* <li> @p mapping_covariant: maps a field of forms on the reference cell to
*
* @param[in] input An array (or part of an array) of input objects that
* should be mapped.
- * @param[in] type The kind of mapping to be applied.
+ * @param[in] kind The kind of mapping to be applied.
* @param[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(),
*/
virtual void
transform(const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const = 0;
* 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
- * types currently implemented by derived classes are:
+ * kinds currently implemented by derived classes are:
* <ul>
* <li> @p mapping_contravariant_gradient: it assumes $\mathbf u(\mathbf x)
* = J \hat{\mathbf u}$ so that
*
* @param[in] input An array (or part of an array) of input objects that
* should be mapped.
- * @param[in] type The kind of mapping to be applied.
+ * @param[in] kind The kind of mapping to be applied.
* @param[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(),
*/
virtual void
transform(const ArrayView<const Tensor<2, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const = 0;
* 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 types currently implemented by derived classes are:
+ * The mapping kinds currently implemented by derived classes are:
* <ul>
* <li> @p mapping_covariant_gradient: maps a field of forms on the
* reference cell to a field of forms on the physical cell. Mathematically,
*
* @param[in] input An array (or part of an array) of input objects that
* should be mapped.
- * @param[in] type The kind of mapping to be applied.
+ * @param[in] kind The kind of mapping to be applied.
* @param[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(),
*/
virtual void
transform(const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const = 0;
* \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 types currently implemented by derived classes are:
+ * The mapping kinds currently implemented by derived classes are:
* <ul>
* <li> @p mapping_contravariant_hessian: it assumes $\mathbf u_i(\mathbf x)
* = J_{iI} \hat{\mathbf u}_I$ so that
*
* @param[in] input An array (or part of an array) of input objects that
* should be mapped.
- * @param[in] type The kind of mapping to be applied.
+ * @param[in] kind The kind of mapping to be applied.
* @param[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(),
*/
virtual void
transform(const ArrayView<const Tensor<3, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const = 0;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const Tensor<1, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<1, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const Tensor<2, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const Tensor<3, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const Tensor<1, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<1, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const Tensor<2, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const Tensor<3, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const Tensor<1, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<1, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const Tensor<2, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const Tensor<3, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const Tensor<1, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<1, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const Tensor<2, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const Tensor<3, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const Tensor<1, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<1, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const Tensor<2, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<2, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const override;
// for documentation, see the Mapping base class
virtual void
transform(const ArrayView<const Tensor<3, dim>> & input,
- const MappingType type,
+ const MappingKind kind,
const typename Mapping<dim, spacedim>::InternalDataBase &internal,
const ArrayView<Tensor<3, spacedim>> &output) const override;
// FIXME: This should be refactored into the mapping (i.e.
// implement the inverse function of Mapping<dim, spacedim>::transform).
// Further, the finite element should make the information about
- // the correct mapping directly accessible (i.e. which MappingType
+ // the correct mapping directly accessible (i.e. which MappingKind
// should be used). Using fe.conforming_space might be a bit of a
// problem because we only support doing nothing, Hcurl, and Hdiv
// conforming mappings.
Assert(dim >= 2, ExcImpossibleInDim(dim));
const unsigned int n_dofs = this->dofs_per_cell;
- this->mapping_type = {mapping_raviart_thomas};
+ this->mapping_kind = {mapping_raviart_thomas};
// First, initialize the
// generalized support points and
// quadrature weights, since they
const unsigned int n_dofs = this->dofs_per_cell;
- this->mapping_type = {mapping_bdm};
+ this->mapping_kind = {mapping_bdm};
// These must be done first, since
// they change the evaluation of
// basis functions
// const unsigned int n_dofs = this->dofs_per_cell;
- this->mapping_type = {mapping_none};
+ this->mapping_kind = {mapping_none};
// These must be done first, since
// they change the evaluation of
// basis functions
const unsigned int n_dofs = this->dofs_per_cell;
- this->mapping_type = {mapping_nedelec};
+ this->mapping_kind = {mapping_nedelec};
// First, initialize the
// generalized support points and
// quadrature weights, since they
{
Assert(dim >= 2, ExcImpossibleInDim(dim));
- this->mapping_type = mapping_nedelec;
+ this->mapping_kind = mapping_nedelec;
// Set up the table converting components to base components. Since we have
// only one base element, everything remains zero except the component in the
// base, which is the component itself.
UpdateFlags
FE_NedelecSZ<dim, spacedim>::update_once(const UpdateFlags flags) const
{
- const bool values_once = (mapping_type == mapping_none);
+ const bool values_once = (mapping_kind == mapping_none);
UpdateFlags out = update_default;
if (values_once && (flags & update_values))
void
get_face_sign_change_rt(const dealii::Triangulation<1>::cell_iterator &,
const FiniteElement<1, spacedim> &,
- const std::vector<MappingType> &,
+ const std::vector<MappingKind> &,
std::vector<double> &)
{
// nothing to do in 1d
get_face_sign_change_rt(
const dealii::Triangulation<2>::cell_iterator &cell,
const FiniteElement<2, 2> & fe,
- const std::vector<MappingType> & mapping_type,
+ const std::vector<MappingKind> & mapping_kind,
std::vector<double> & face_sign)
{
const unsigned int dim = 2;
Assert(f * fe.dofs_per_face + j < face_sign.size(),
ExcInternalError());
- Assert(mapping_type.size() == 1 ||
- cell_j < mapping_type.size(),
+ Assert(mapping_kind.size() == 1 ||
+ cell_j < mapping_kind.size(),
ExcInternalError());
// TODO: This is probably only going to work for those
// elements for which all dofs are face dofs
- if ((mapping_type.size() > 1 ?
- mapping_type[cell_j] :
- mapping_type[0]) == mapping_raviart_thomas)
+ if ((mapping_kind.size() > 1 ?
+ mapping_kind[cell_j] :
+ mapping_kind[0]) == mapping_raviart_thomas)
face_sign[f * fe.dofs_per_face + j] = -1.0;
}
}
get_face_sign_change_rt(
const dealii::Triangulation<3>::cell_iterator & /*cell*/,
const FiniteElement<3, spacedim> & /*fe*/,
- const std::vector<MappingType> & /*mapping_type*/,
+ const std::vector<MappingKind> & /*mapping_kind*/,
std::vector<double> & /*face_sign*/)
{
// TODO: think about what it would take here
get_face_sign_change_nedelec(
const dealii::Triangulation<1>::cell_iterator & /*cell*/,
const FiniteElement<1, spacedim> & /*fe*/,
- const std::vector<MappingType> & /*mapping_type*/,
+ const std::vector<MappingKind> & /*mapping_kind*/,
std::vector<double> & /*face_sign*/)
{
// nothing to do in 1d
get_face_sign_change_nedelec(
const dealii::Triangulation<2>::cell_iterator & /*cell*/,
const FiniteElement<2, spacedim> & /*fe*/,
- const std::vector<MappingType> & /*mapping_type*/,
+ const std::vector<MappingKind> & /*mapping_kind*/,
std::vector<double> & /*face_sign*/)
{
// TODO: think about what it would take here
get_face_sign_change_nedelec(
const dealii::Triangulation<3>::cell_iterator &cell,
const FiniteElement<3, spacedim> & /*fe*/,
- const std::vector<MappingType> &mapping_type,
+ const std::vector<MappingKind> &mapping_kind,
std::vector<double> & face_sign)
{
const unsigned int dim = 3;
// which all dofs are face dofs
for (unsigned int l = 0; l < GeometryInfo<dim>::lines_per_cell; ++l)
if (!(cell->line_orientation(l)) &&
- mapping_type[0] == mapping_nedelec)
+ mapping_kind[0] == mapping_nedelec)
face_sign[l] = -1.0;
}
} // namespace
: FiniteElement<dim, spacedim>(fe_data,
restriction_is_additive_flags,
nonzero_components)
- , mapping_type({MappingType::mapping_none})
+ , mapping_kind({MappingKind::mapping_none})
, poly_space(PolynomialType(degree))
{
cached_point(0) = -1;
template <class PolynomialType, int dim, int spacedim>
bool
-FE_PolyTensor<PolynomialType, dim, spacedim>::single_mapping_type() const
+FE_PolyTensor<PolynomialType, dim, spacedim>::single_mapping_kind() const
{
- return mapping_type.size() == 1;
+ return mapping_kind.size() == 1;
}
template <class PolynomialType, int dim, int spacedim>
-MappingType
-FE_PolyTensor<PolynomialType, dim, spacedim>::get_mapping_type(
+MappingKind
+FE_PolyTensor<PolynomialType, dim, spacedim>::get_mapping_kind(
const unsigned int i) const
{
- if (single_mapping_type())
- return mapping_type[0];
+ if (single_mapping_kind())
+ return mapping_kind[0];
- Assert(i < mapping_type.size(), ExcIndexRange(i, 0, mapping_type.size()));
- return mapping_type[i];
+ Assert(i < mapping_kind.size(), ExcIndexRange(i, 0, mapping_kind.size()));
+ return mapping_kind[i];
}
internal::FE_PolyTensor::get_face_sign_change_rt(cell,
*this,
- this->mapping_type,
+ this->mapping_kind,
fe_data.sign_change);
internal::FE_PolyTensor::get_face_sign_change_nedelec(cell,
*this,
- this->mapping_type,
+ this->mapping_kind,
fe_data.sign_change);
for (unsigned int i = 0; i < this->dofs_per_cell; ++i)
{
- const MappingType mapping_type = get_mapping_type(i);
+ const MappingKind mapping_kind = get_mapping_kind(i);
const unsigned int first =
output_data.shape_function_to_row_table[i * this->n_components() +
// and derivatives because of possible sign changes
if (fe_data.update_each & update_values &&
((cell_similarity != CellSimilarity::translation) ||
- ((mapping_type == mapping_piola) ||
- (mapping_type == mapping_raviart_thomas) ||
- (mapping_type == mapping_nedelec))))
+ ((mapping_kind == mapping_piola) ||
+ (mapping_kind == mapping_raviart_thomas) ||
+ (mapping_kind == mapping_nedelec))))
{
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_none:
{
case mapping_contravariant:
{
mapping.transform(make_array_view(fe_data.shape_values, i),
- mapping_type,
+ mapping_kind,
mapping_internal,
make_array_view(
fe_data.transformed_shape_values));
// update gradients. apply the same logic as above
if (fe_data.update_each & update_gradients &&
((cell_similarity != CellSimilarity::translation) ||
- ((mapping_type == mapping_piola) ||
- (mapping_type == mapping_raviart_thomas) ||
- (mapping_type == mapping_nedelec))))
+ ((mapping_kind == mapping_piola) ||
+ (mapping_kind == mapping_raviart_thomas) ||
+ (mapping_kind == mapping_nedelec))))
{
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_none:
{
// update hessians. apply the same logic as above
if (fe_data.update_each & update_hessians &&
((cell_similarity != CellSimilarity::translation) ||
- ((mapping_type == mapping_piola) ||
- (mapping_type == mapping_raviart_thomas) ||
- (mapping_type == mapping_nedelec))))
+ ((mapping_kind == mapping_piola) ||
+ (mapping_kind == mapping_raviart_thomas) ||
+ (mapping_kind == mapping_nedelec))))
{
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_none:
{
// third derivatives are not implemented
if (fe_data.update_each & update_3rd_derivatives &&
((cell_similarity != CellSimilarity::translation) ||
- ((mapping_type == mapping_piola) ||
- (mapping_type == mapping_raviart_thomas) ||
- (mapping_type == mapping_nedelec))))
+ ((mapping_kind == mapping_piola) ||
+ (mapping_kind == mapping_raviart_thomas) ||
+ (mapping_kind == mapping_nedelec))))
{
Assert(false, ExcNotImplemented())
}
internal::FE_PolyTensor::get_face_sign_change_rt(cell,
*this,
- this->mapping_type,
+ this->mapping_kind,
fe_data.sign_change);
internal::FE_PolyTensor::get_face_sign_change_nedelec(cell,
*this,
- this->mapping_type,
+ this->mapping_kind,
fe_data.sign_change);
for (unsigned int i = 0; i < this->dofs_per_cell; ++i)
{
- const MappingType mapping_type = get_mapping_type(i);
+ const MappingKind mapping_kind = get_mapping_kind(i);
const unsigned int first =
output_data.shape_function_to_row_table[i * this->n_components() +
if (fe_data.update_each & update_values)
{
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_none:
{
i,
offset,
n_q_points),
- mapping_type,
+ mapping_kind,
mapping_internal,
transformed_shape_values);
if (fe_data.update_each & update_gradients)
{
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_none:
{
if (fe_data.update_each & update_hessians)
{
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_none:
{
n_q_points,
cell->subface_case(face_no));
- // Assert(mapping_type == independent
- // || ( mapping_type == independent_on_cartesian
+ // Assert(mapping_kind == independent
+ // || ( mapping_kind == independent_on_cartesian
// && dynamic_cast<const MappingCartesian<dim>*>(&mapping) != 0),
// ExcNotImplemented());
// TODO: Size assertions
internal::FE_PolyTensor::get_face_sign_change_rt(cell,
*this,
- this->mapping_type,
+ this->mapping_kind,
fe_data.sign_change);
internal::FE_PolyTensor::get_face_sign_change_nedelec(cell,
*this,
- this->mapping_type,
+ this->mapping_kind,
fe_data.sign_change);
for (unsigned int i = 0; i < this->dofs_per_cell; ++i)
{
- const MappingType mapping_type = get_mapping_type(i);
+ const MappingKind mapping_kind = get_mapping_kind(i);
const unsigned int first =
output_data.shape_function_to_row_table[i * this->n_components() +
if (fe_data.update_each & update_values)
{
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_none:
{
i,
offset,
n_q_points),
- mapping_type,
+ mapping_kind,
mapping_internal,
transformed_shape_values);
make_array_view(fe_data.transformed_shape_grads,
offset,
n_q_points);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_none:
{
if (fe_data.update_each & update_hessians)
{
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_none:
{
for (unsigned int i = 0; i < this->dofs_per_cell; ++i)
{
- const MappingType mapping_type = get_mapping_type(i);
+ const MappingKind mapping_kind = get_mapping_kind(i);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_none:
{
Assert(dim >= 2, ExcImpossibleInDim(dim));
const unsigned int n_dofs = this->dofs_per_cell;
- this->mapping_type = {mapping_raviart_thomas};
+ this->mapping_kind = {mapping_raviart_thomas};
// First, initialize the
// generalized support points and
// quadrature weights, since they
Assert(dim >= 2, ExcImpossibleInDim(dim));
const unsigned int n_dofs = this->dofs_per_cell;
- this->mapping_type = {mapping_raviart_thomas};
+ this->mapping_kind = {mapping_raviart_thomas};
// First, initialize the
// generalized support points and
// quadrature weights, since they
"Lowest order RT_Bubbles element is degree 1, but you requested for degree 0"));
const unsigned int n_dofs = this->dofs_per_cell;
- this->mapping_type = {mapping_raviart_thomas};
+ this->mapping_kind = {mapping_raviart_thomas};
// Initialize support points and quadrature weights
initialize_support_points(deg);
// Compute the inverse node matrix to get
void
MappingCartesian<dim, spacedim>::transform(
const ArrayView<const Tensor<1, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<1, spacedim>> & output) const
{
ExcInternalError());
const InternalData &data = static_cast<const InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_covariant:
{
void
MappingCartesian<dim, spacedim>::transform(
const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<2, spacedim>> & output) const
{
ExcInternalError());
const InternalData &data = static_cast<const InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_covariant:
{
void
MappingCartesian<dim, spacedim>::transform(
const ArrayView<const Tensor<2, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<2, spacedim>> & output) const
{
ExcInternalError());
const InternalData &data = static_cast<const InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_covariant:
{
void
MappingCartesian<dim, spacedim>::transform(
const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<3, spacedim>> & output) const
{
ExcInternalError());
const InternalData &data = static_cast<const InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_covariant_gradient:
{
void
MappingCartesian<dim, spacedim>::transform(
const ArrayView<const Tensor<3, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<3, spacedim>> & output) const
{
ExcInternalError());
const InternalData &data = static_cast<const InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_contravariant_hessian:
{
void
transform_fields(
const ArrayView<const Tensor<rank, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<rank, spacedim>> & output)
{
MappingFEField<dim, spacedim, VectorType, DoFHandlerType>::
InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_contravariant:
{
void
transform_differential_forms(
const ArrayView<const DerivativeForm<rank, dim, spacedim>> &input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<rank + 1, spacedim>> & output)
{
MappingFEField<dim, spacedim, VectorType, DoFHandlerType>::
InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_covariant:
{
void
MappingFEField<dim, spacedim, VectorType, DoFHandlerType>::transform(
const ArrayView<const Tensor<1, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<1, spacedim>> & output) const
{
internal::MappingFEFieldImplementation::
transform_fields<dim, spacedim, 1, VectorType, DoFHandlerType>(input,
- mapping_type,
+ mapping_kind,
mapping_data,
output);
}
void
MappingFEField<dim, spacedim, VectorType, DoFHandlerType>::transform(
const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<2, spacedim>> & output) const
{
internal::MappingFEFieldImplementation::
transform_differential_forms<dim, spacedim, 1, VectorType, DoFHandlerType>(
- input, mapping_type, mapping_data, output);
+ input, mapping_kind, mapping_data, output);
}
void
MappingFEField<dim, spacedim, VectorType, DoFHandlerType>::transform(
const ArrayView<const Tensor<2, dim>> &input,
- const MappingType,
+ const MappingKind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<2, spacedim>> & output) const
{
void
MappingFEField<dim, spacedim, VectorType, DoFHandlerType>::transform(
const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<3, spacedim>> & output) const
{
ExcInternalError());
const InternalData &data = static_cast<const InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_covariant_gradient:
{
void
MappingFEField<dim, spacedim, VectorType, DoFHandlerType>::transform(
const ArrayView<const Tensor<3, dim>> &input,
- const MappingType /*mapping_type*/,
+ const MappingKind /*mapping_kind*/,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<3, spacedim>> & output) const
{
void
transform_fields(
const ArrayView<const Tensor<rank, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<rank, spacedim>> & output)
{
static_cast<const typename dealii::MappingManifold<dim, spacedim>::
InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_contravariant:
{
void
transform_gradients(
const ArrayView<const Tensor<rank, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<rank, spacedim>> & output)
{
static_cast<const typename dealii::MappingManifold<dim, spacedim>::
InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_contravariant_gradient:
{
void
transform_hessians(
const ArrayView<const Tensor<3, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<3, spacedim>> & output)
{
static_cast<const typename dealii::MappingManifold<dim, spacedim>::
InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_contravariant_hessian:
{
void
transform_differential_forms(
const ArrayView<const DerivativeForm<rank, dim, spacedim>> &input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<rank + 1, spacedim>> & output)
{
static_cast<const typename dealii::MappingManifold<dim, spacedim>::
InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_covariant:
{
void
MappingManifold<dim, spacedim>::transform(
const ArrayView<const Tensor<1, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<1, spacedim>> & output) const
{
internal::MappingManifoldImplementation::transform_fields(input,
- mapping_type,
+ mapping_kind,
mapping_data,
output);
}
void
MappingManifold<dim, spacedim>::transform(
const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<2, spacedim>> & output) const
{
internal::MappingManifoldImplementation::transform_differential_forms(
- input, mapping_type, mapping_data, output);
+ input, mapping_kind, mapping_data, output);
}
void
MappingManifold<dim, spacedim>::transform(
const ArrayView<const Tensor<2, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<2, spacedim>> & output) const
{
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_contravariant:
internal::MappingManifoldImplementation::transform_fields(input,
- mapping_type,
+ mapping_kind,
mapping_data,
output);
return;
case mapping_contravariant_gradient:
case mapping_covariant_gradient:
internal::MappingManifoldImplementation::transform_gradients(
- input, mapping_type, mapping_data, output);
+ input, mapping_kind, mapping_data, output);
return;
default:
Assert(false, ExcNotImplemented());
void
MappingManifold<dim, spacedim>::transform(
const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<3, spacedim>> & output) const
{
ExcInternalError());
const InternalData &data = static_cast<const InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_covariant_gradient:
{
void
MappingManifold<dim, spacedim>::transform(
const ArrayView<const Tensor<3, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<3, spacedim>> & output) const
{
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_piola_hessian:
case mapping_contravariant_hessian:
case mapping_covariant_hessian:
internal::MappingManifoldImplementation::transform_hessians(
- input, mapping_type, mapping_data, output);
+ input, mapping_kind, mapping_data, output);
return;
default:
Assert(false, ExcNotImplemented());
void
MappingQ<dim, spacedim>::transform(
const ArrayView<const Tensor<1, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<1, spacedim>> & output) const
{
// check whether we should in fact work on the Q1 portion of it
if (data->use_mapping_q1_on_current_cell)
- q1_mapping->transform(input, mapping_type, *data->mapping_q1_data, output);
+ q1_mapping->transform(input, mapping_kind, *data->mapping_q1_data, output);
else
// otherwise use the full mapping
- qp_mapping->transform(input, mapping_type, *data->mapping_qp_data, output);
+ qp_mapping->transform(input, mapping_kind, *data->mapping_qp_data, output);
}
void
MappingQ<dim, spacedim>::transform(
const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<2, spacedim>> & output) const
{
// check whether we should in fact work on the Q1 portion of it
if (data->use_mapping_q1_on_current_cell)
- q1_mapping->transform(input, mapping_type, *data->mapping_q1_data, output);
+ q1_mapping->transform(input, mapping_kind, *data->mapping_q1_data, output);
else
// otherwise use the full mapping
- qp_mapping->transform(input, mapping_type, *data->mapping_qp_data, output);
+ qp_mapping->transform(input, mapping_kind, *data->mapping_qp_data, output);
}
void
MappingQ<dim, spacedim>::transform(
const ArrayView<const Tensor<2, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<2, spacedim>> & output) const
{
// check whether we should in fact work on the Q1 portion of it
if (data->use_mapping_q1_on_current_cell)
- q1_mapping->transform(input, mapping_type, *data->mapping_q1_data, output);
+ q1_mapping->transform(input, mapping_kind, *data->mapping_q1_data, output);
else
// otherwise use the full mapping
- qp_mapping->transform(input, mapping_type, *data->mapping_qp_data, output);
+ qp_mapping->transform(input, mapping_kind, *data->mapping_qp_data, output);
}
void
MappingQ<dim, spacedim>::transform(
const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<3, spacedim>> & output) const
{
// check whether we should in fact work on the Q1 portion of it
if (data->use_mapping_q1_on_current_cell)
- q1_mapping->transform(input, mapping_type, *data->mapping_q1_data, output);
+ q1_mapping->transform(input, mapping_kind, *data->mapping_q1_data, output);
else
// otherwise use the full mapping
- qp_mapping->transform(input, mapping_type, *data->mapping_qp_data, output);
+ qp_mapping->transform(input, mapping_kind, *data->mapping_qp_data, output);
}
void
MappingQ<dim, spacedim>::transform(
const ArrayView<const Tensor<3, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<3, spacedim>> & output) const
{
// check whether we should in fact work on the Q1 portion of it
if (data->use_mapping_q1_on_current_cell)
- q1_mapping->transform(input, mapping_type, *data->mapping_q1_data, output);
+ q1_mapping->transform(input, mapping_kind, *data->mapping_q1_data, output);
else
// otherwise use the full mapping
- qp_mapping->transform(input, mapping_type, *data->mapping_qp_data, output);
+ qp_mapping->transform(input, mapping_kind, *data->mapping_qp_data, output);
}
void
transform_fields(
const ArrayView<const Tensor<rank, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<rank, spacedim>> & output)
{
static_cast<const typename dealii::MappingQGeneric<dim, spacedim>::
InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_contravariant:
{
void
transform_gradients(
const ArrayView<const Tensor<rank, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<rank, spacedim>> & output)
{
static_cast<const typename dealii::MappingQGeneric<dim, spacedim>::
InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_contravariant_gradient:
{
void
transform_hessians(
const ArrayView<const Tensor<3, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<3, spacedim>> & output)
{
static_cast<const typename dealii::MappingQGeneric<dim, spacedim>::
InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_contravariant_hessian:
{
void
transform_differential_forms(
const ArrayView<const DerivativeForm<rank, dim, spacedim>> &input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<rank + 1, spacedim>> & output)
{
static_cast<const typename dealii::MappingQGeneric<dim, spacedim>::
InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_covariant:
{
void
MappingQGeneric<dim, spacedim>::transform(
const ArrayView<const Tensor<1, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<1, spacedim>> & output) const
{
internal::MappingQGenericImplementation::transform_fields(input,
- mapping_type,
+ mapping_kind,
mapping_data,
output);
}
void
MappingQGeneric<dim, spacedim>::transform(
const ArrayView<const DerivativeForm<1, dim, spacedim>> &input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<2, spacedim>> & output) const
{
internal::MappingQGenericImplementation::transform_differential_forms(
- input, mapping_type, mapping_data, output);
+ input, mapping_kind, mapping_data, output);
}
void
MappingQGeneric<dim, spacedim>::transform(
const ArrayView<const Tensor<2, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<2, spacedim>> & output) const
{
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_contravariant:
internal::MappingQGenericImplementation::transform_fields(input,
- mapping_type,
+ mapping_kind,
mapping_data,
output);
return;
case mapping_contravariant_gradient:
case mapping_covariant_gradient:
internal::MappingQGenericImplementation::transform_gradients(
- input, mapping_type, mapping_data, output);
+ input, mapping_kind, mapping_data, output);
return;
default:
Assert(false, ExcNotImplemented());
void
MappingQGeneric<dim, spacedim>::transform(
const ArrayView<const DerivativeForm<2, dim, spacedim>> &input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<3, spacedim>> & output) const
{
ExcInternalError());
const InternalData &data = static_cast<const InternalData &>(mapping_data);
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_covariant_gradient:
{
void
MappingQGeneric<dim, spacedim>::transform(
const ArrayView<const Tensor<3, dim>> & input,
- const MappingType mapping_type,
+ const MappingKind mapping_kind,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<3, spacedim>> & output) const
{
- switch (mapping_type)
+ switch (mapping_kind)
{
case mapping_piola_hessian:
case mapping_contravariant_hessian:
case mapping_covariant_hessian:
internal::MappingQGenericImplementation::transform_hessians(
- input, mapping_type, mapping_data, output);
+ input, mapping_kind, mapping_data, output);
return;
default:
Assert(false, ExcNotImplemented());
projects / dealii.git / commitdiff