fe_update_flags.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 2020 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_update_flags_h
#define dealii_fe_update_flags_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/derivative_form.h>
#include <deal.II/base/point.h>
#include <deal.II/base/table.h>
#include <deal.II/base/tensor.h>
 
#include <vector>
 
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declaration
#ifndef DOXYGEN
template <int, int>
class FiniteElement;
#endif
 
 
enum UpdateFlags
{
  update_default = 0,
 
  update_values = 0x0001,
 
  update_gradients = 0x0002,
 
  update_hessians = 0x0004,
 
  update_3rd_derivatives = 0x0008,
 
  update_boundary_forms = 0x0010,
 
  update_quadrature_points = 0x0020,
 
  update_JxW_values = 0x0040,
 
  update_normal_vectors = 0x0080,
 
  update_jacobians = 0x0100,
 
  update_jacobian_grads = 0x0200,
 
  update_inverse_jacobians = 0x0400,
 
  update_covariant_transformation = 0x0800,
 
  update_contravariant_transformation = 0x1000,
 
  update_transformation_values = 0x2000,
 
  update_transformation_gradients = 0x4000,
 
  update_volume_elements = 0x10000,
  update_jacobian_pushed_forward_grads = 0x100000,
  update_jacobian_2nd_derivatives = 0x200000,
  update_jacobian_pushed_forward_2nd_derivatives = 0x400000,
  update_jacobian_3rd_derivatives = 0x800000,
  update_jacobian_pushed_forward_3rd_derivatives = 0x1000000,
 
  update_piola = update_volume_elements | update_contravariant_transformation,
  update_mapping =
    // Direct data
  update_quadrature_points | update_JxW_values | update_jacobians |
  update_jacobian_grads | update_jacobian_pushed_forward_grads |
  update_jacobian_2nd_derivatives |
  update_jacobian_pushed_forward_2nd_derivatives |
  update_jacobian_3rd_derivatives |
  update_jacobian_pushed_forward_3rd_derivatives | update_inverse_jacobians |
  update_boundary_forms | update_normal_vectors |
  // Transformation dependence
  update_covariant_transformation | update_contravariant_transformation |
  update_transformation_values | update_transformation_gradients |
  // Volume data
  update_volume_elements
};
 
 
template <class StreamType>
inline StreamType &
operator<<(StreamType &s, const UpdateFlags u)
{
  s << " UpdateFlags|";
  if (u & update_values)
    s << "values|";
  if (u & update_gradients)
    s << "gradients|";
  if (u & update_hessians)
    s << "hessians|";
  if (u & update_3rd_derivatives)
    s << "3rd_derivatives|";
  if (u & update_quadrature_points)
    s << "quadrature_points|";
  if (u & update_JxW_values)
    s << "JxW_values|";
  if (u & update_normal_vectors)
    s << "normal_vectors|";
  if (u & update_jacobians)
    s << "jacobians|";
  if (u & update_inverse_jacobians)
    s << "inverse_jacobians|";
  if (u & update_jacobian_grads)
    s << "jacobian_grads|";
  if (u & update_covariant_transformation)
    s << "covariant_transformation|";
  if (u & update_contravariant_transformation)
    s << "contravariant_transformation|";
  if (u & update_transformation_values)
    s << "transformation_values|";
  if (u & update_transformation_gradients)
    s << "transformation_gradients|";
  if (u & update_jacobian_pushed_forward_grads)
    s << "jacobian_pushed_forward_grads|";
  if (u & update_jacobian_2nd_derivatives)
    s << "jacobian_2nd_derivatives|";
  if (u & update_jacobian_pushed_forward_2nd_derivatives)
    s << "jacobian_pushed_forward_2nd_derivatives|";
  if (u & update_jacobian_3rd_derivatives)
    s << "jacobian_3rd_derivatives|";
  if (u & update_jacobian_pushed_forward_3rd_derivatives)
    s << "jacobian_pushed_forward_3rd_derivatives|";
 
  // TODO: check that 'u' really only has the flags set that are handled above
  return s;
}
 
 
inline UpdateFlags
operator|(const UpdateFlags f1, const UpdateFlags f2)
{
  return static_cast<UpdateFlags>(static_cast<unsigned int>(f1) |
                                  static_cast<unsigned int>(f2));
}
 
 
 
inline UpdateFlags &
operator|=(UpdateFlags &f1, const UpdateFlags f2)
{
  f1 = f1 | f2;
  return f1;
}
 
 
inline UpdateFlags operator&(const UpdateFlags f1, const UpdateFlags f2)
{
  return static_cast<UpdateFlags>(static_cast<unsigned int>(f1) &
                                  static_cast<unsigned int>(f2));
}
 
 
inline UpdateFlags &
operator&=(UpdateFlags &f1, const UpdateFlags f2)
{
  f1 = f1 & f2;
  return f1;
}
 
 
 
namespace CellSimilarity
{
  enum Similarity
  {
    none,
    translation,
    inverted_translation,
    invalid_next_cell
  };
}
 
 
namespace internal
{
  namespace FEValuesImplementation
  {
    template <int dim, int spacedim = dim>
    class MappingRelatedData
    {
    public:
      void
      initialize(const unsigned int n_quadrature_points,
                 const UpdateFlags  flags);
 
      std::size_t
      memory_consumption() const;
 
      std::vector<double> JxW_values;
 
      std::vector<DerivativeForm<1, dim, spacedim>> jacobians;
 
      std::vector<DerivativeForm<2, dim, spacedim>> jacobian_grads;
 
      std::vector<DerivativeForm<1, spacedim, dim>> inverse_jacobians;
 
      std::vector<Tensor<3, spacedim>> jacobian_pushed_forward_grads;
 
      std::vector<DerivativeForm<3, dim, spacedim>> jacobian_2nd_derivatives;
 
      std::vector<Tensor<4, spacedim>> jacobian_pushed_forward_2nd_derivatives;
 
      std::vector<DerivativeForm<4, dim, spacedim>> jacobian_3rd_derivatives;
 
      std::vector<Tensor<5, spacedim>> jacobian_pushed_forward_3rd_derivatives;
 
      std::vector<Point<spacedim>> quadrature_points;
 
      std::vector<Tensor<1, spacedim>> normal_vectors;
 
      std::vector<Tensor<1, spacedim>> boundary_forms;
    };
 
 
    template <int dim, int spacedim = dim>
    class FiniteElementRelatedData
    {
    public:
      void
      initialize(const unsigned int                  n_quadrature_points,
                 const FiniteElement<dim, spacedim> &fe,
                 const UpdateFlags                   flags);
 
      std::size_t
      memory_consumption() const;
 
      using ShapeVector = ::Table<2, double>;
 
      using GradientVector = ::Table<2, Tensor<1, spacedim>>;
 
      using HessianVector = ::Table<2, Tensor<2, spacedim>>;
 
      using ThirdDerivativeVector = ::Table<2, Tensor<3, spacedim>>;
 
      ShapeVector shape_values;
 
      GradientVector shape_gradients;
 
      HessianVector shape_hessians;
 
      ThirdDerivativeVector shape_3rd_derivatives;
 
      std::vector<unsigned int> shape_function_to_row_table;
    };
  } // namespace FEValuesImplementation
} // namespace internal
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif