fe_update_flags.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 2018 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

template <int, int>
class FiniteElement;



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_face_normal_vectors = update_normal_vectors,
  update_cell_normal_vectors = update_normal_vectors,

  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_q_points = update_quadrature_points,
  update_second_derivatives = update_hessians,

  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