fe_poly_face.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2009 - 2019 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_fe_poly_face_h
#define dealii_fe_poly_face_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/qprojector.h>
#include <deal.II/base/std_cxx14/memory.h>
 
#include <deal.II/fe/fe.h>
 
 
DEAL_II_NAMESPACE_OPEN
 
 
template <class PolynomialType,
          int dim      = PolynomialType::dimension + 1,
          int spacedim = dim>
class FE_PolyFace : public FiniteElement<dim, spacedim>
{
public:
  FE_PolyFace(const PolynomialType &        poly_space,
              const FiniteElementData<dim> &fe_data,
              const std::vector<bool> &     restriction_is_additive_flags);
 
  unsigned int
  get_degree() const;
 
  // for documentation, see the FiniteElement base class
  virtual UpdateFlags
  requires_update_flags(const UpdateFlags update_flags) const override;
 
protected:
  /*
   * NOTE: The following functions have their definitions inlined into the class
   * declaration because we otherwise run into a compiler error with MS Visual
   * Studio.
   */
 
 
  virtual std::unique_ptr<
    typename FiniteElement<dim, spacedim>::InternalDataBase>
  get_data(
    const UpdateFlags /*update_flags*/,
    const Mapping<dim, spacedim> & /*mapping*/,
    const Quadrature<dim> & /*quadrature*/,
    ::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
                                                                       spacedim>
      & /*output_data*/) const override
  {
    return std_cxx14::make_unique<InternalData>();
  }
 
  std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
  get_face_data(
    const UpdateFlags update_flags,
    const Mapping<dim, spacedim> & /*mapping*/,
    const Quadrature<dim - 1> &quadrature,
    ::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
                                                                       spacedim>
      & /*output_data*/) const override
  {
    // generate a new data object and
    // initialize some fields
    std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
          data_ptr   = std_cxx14::make_unique<InternalData>();
    auto &data       = dynamic_cast<InternalData &>(*data_ptr);
    data.update_each = requires_update_flags(update_flags);
 
    const unsigned int n_q_points = quadrature.size();
 
    // some scratch arrays
    std::vector<double>             values(0);
    std::vector<Tensor<1, dim - 1>> grads(0);
    std::vector<Tensor<2, dim - 1>> grad_grads(0);
    std::vector<Tensor<3, dim - 1>> empty_vector_of_3rd_order_tensors;
    std::vector<Tensor<4, dim - 1>> empty_vector_of_4th_order_tensors;
 
    // initialize fields only if really
    // necessary. otherwise, don't
    // allocate memory
    if (data.update_each & update_values)
      {
        values.resize(poly_space.n());
        data.shape_values.resize(poly_space.n(),
                                 std::vector<double>(n_q_points));
        for (unsigned int i = 0; i < n_q_points; ++i)
          {
            poly_space.evaluate(quadrature.point(i),
                                values,
                                grads,
                                grad_grads,
                                empty_vector_of_3rd_order_tensors,
                                empty_vector_of_4th_order_tensors);
 
            for (unsigned int k = 0; k < poly_space.n(); ++k)
              data.shape_values[k][i] = values[k];
          }
      }
    // No derivatives of this element
    // are implemented.
    if (data.update_each & update_gradients ||
        data.update_each & update_hessians)
      {
        Assert(false, ExcNotImplemented());
      }
 
    return data_ptr;
  }
 
  std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
  get_subface_data(
    const UpdateFlags             update_flags,
    const Mapping<dim, spacedim> &mapping,
    const Quadrature<dim - 1> &   quadrature,
    ::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
                                                                       spacedim>
      &output_data) const override
  {
    return get_face_data(update_flags,
                         mapping,
                         QProjector<dim - 1>::project_to_all_children(
                           quadrature),
                         output_data);
  }
 
  virtual void
  fill_fe_values(
    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
    const CellSimilarity::Similarity                            cell_similarity,
    const Quadrature<dim> &                                     quadrature,
    const Mapping<dim, spacedim> &                              mapping,
    const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
    const ::internal::FEValuesImplementation::MappingRelatedData<dim,
                                                                       spacedim>
      &                                                            mapping_data,
    const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
    ::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
                                                                       spacedim>
      &output_data) const override;
 
  virtual void
  fill_fe_face_values(
    const typename Triangulation<dim, spacedim>::cell_iterator &cell,
    const unsigned int                                          face_no,
    const Quadrature<dim - 1> &                                 quadrature,
    const Mapping<dim, spacedim> &                              mapping,
    const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
    const ::internal::FEValuesImplementation::MappingRelatedData<dim,
                                                                       spacedim>
      &                                                            mapping_data,
    const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
    ::internal::FEValuesImplementation::FiniteElementRelatedData<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                                          sub_no,
    const Quadrature<dim - 1> &                                 quadrature,
    const Mapping<dim, spacedim> &                              mapping,
    const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
    const ::internal::FEValuesImplementation::MappingRelatedData<dim,
                                                                       spacedim>
      &                                                            mapping_data,
    const typename FiniteElement<dim, spacedim>::InternalDataBase &fe_internal,
    ::internal::FEValuesImplementation::FiniteElementRelatedData<dim,
                                                                       spacedim>
      &output_data) const override;
 
  class InternalData : public FiniteElement<dim, spacedim>::InternalDataBase
  {
  public:
    std::vector<std::vector<double>> shape_values;
  };
 
  PolynomialType poly_space;
};
 
DEAL_II_NAMESPACE_CLOSE
 
#endif