fe_base.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2000 - 2021 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_base_h
#define dealii_fe_base_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
 
#include <deal.II/grid/reference_cell.h>
 
#include <deal.II/lac/block_indices.h>
 
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
namespace FiniteElementDomination
{
  enum Domination
  {
    this_element_dominates,
    other_element_dominates,
    neither_element_dominates,
    either_element_can_dominate,
    no_requirements
  };
 
 
  inline Domination operator&(const Domination d1, const Domination d2);
} // namespace FiniteElementDomination
 
namespace internal
{
  struct GenericDoFsPerObject
  {
    std::vector<std::vector<unsigned int>> dofs_per_object_exclusive;
 
    std::vector<std::vector<unsigned int>> dofs_per_object_inclusive;
 
    std::vector<std::vector<unsigned int>> object_index;
 
    std::vector<std::vector<unsigned int>> first_object_index_on_face;
  };
} // namespace internal
 
template <int dim>
class FiniteElementData
{
public:
  enum Conformity
  {
    unknown = 0x00,
 
    L2 = 0x01,
 
    Hcurl = 0x02,
 
    Hdiv = 0x04,
 
    H1 = Hcurl | Hdiv,
 
    H2 = 0x0e
  };
 
  static const unsigned int dimension = dim;
 
private:
  const ReferenceCell reference_cell_kind;
 
  const unsigned int number_unique_quads;
 
  const unsigned int number_unique_faces;
 
public:
  const unsigned int dofs_per_vertex;
 
  const unsigned int dofs_per_line;
 
private:
  const std::vector<unsigned int> n_dofs_on_quad;
 
public:
  const unsigned int dofs_per_quad;
 
private:
  const unsigned int dofs_per_quad_max;
 
public:
  const unsigned int dofs_per_hex;
 
  const unsigned int first_line_index;
 
private:
  const std::vector<unsigned int> first_index_of_quads;
 
public:
  const unsigned int first_quad_index;
 
  const unsigned int first_hex_index;
 
private:
  const std::vector<unsigned int> first_line_index_of_faces;
 
public:
  const unsigned int first_face_line_index;
 
private:
  const std::vector<unsigned int> first_quad_index_of_faces;
 
public:
  const unsigned int first_face_quad_index;
 
private:
  const std::vector<unsigned int> n_dofs_on_face;
 
public:
  const unsigned int dofs_per_face;
 
private:
  const unsigned int dofs_per_face_max;
 
public:
  const unsigned int dofs_per_cell;
 
  const unsigned int components;
 
  const unsigned int degree;
 
  const Conformity conforming_space;
 
  const BlockIndices block_indices_data;
 
  FiniteElementData(const std::vector<unsigned int> &dofs_per_object,
                    const unsigned int               n_components,
                    const unsigned int               degree,
                    const Conformity                 conformity = unknown,
                    const BlockIndices &block_indices = BlockIndices());
 
  FiniteElementData(const std::vector<unsigned int> &dofs_per_object,
                    const ReferenceCell              reference_cell,
                    const unsigned int               n_components,
                    const unsigned int               degree,
                    const Conformity                 conformity = unknown,
                    const BlockIndices &block_indices = BlockIndices());
 
  FiniteElementData(const internal::GenericDoFsPerObject &data,
                    const ReferenceCell                   reference_cell,
                    const unsigned int                    n_components,
                    const unsigned int                    degree,
                    const Conformity                      conformity = unknown,
                    const BlockIndices &block_indices = BlockIndices());
 
  ReferenceCell
  reference_cell() const;
 
  unsigned int
  n_unique_quads() const;
 
  unsigned int
  n_unique_faces() const;
 
  unsigned int
  n_dofs_per_vertex() const;
 
  unsigned int
  n_dofs_per_line() const;
 
  unsigned int
  n_dofs_per_quad(unsigned int face_no = 0) const;
 
  unsigned int
  max_dofs_per_quad() const;
 
  unsigned int
  n_dofs_per_hex() const;
 
  unsigned int
  n_dofs_per_face(unsigned int face_no = 0, unsigned int child = 0) const;
 
  unsigned int
  max_dofs_per_face() const;
 
  unsigned int
  n_dofs_per_cell() const;
 
  template <int structdim>
  unsigned int
  n_dofs_per_object(const unsigned int i = 0) const;
 
  unsigned int
  n_components() const;
 
  unsigned int
  n_blocks() const;
 
  const BlockIndices &
  block_indices() const;
 
  unsigned int
  tensor_degree() const;
 
  bool
  conforms(const Conformity) const;
 
  bool
  operator==(const FiniteElementData &) const;
 
  unsigned int
  get_first_line_index() const;
 
  unsigned int
  get_first_quad_index(const unsigned int quad_no = 0) const;
 
  unsigned int
  get_first_hex_index() const;
 
  unsigned int
  get_first_face_line_index(const unsigned int face_no = 0) const;
 
  unsigned int
  get_first_face_quad_index(const unsigned int face_no = 0) const;
};
 
namespace internal
{
  internal::GenericDoFsPerObject
  expand(const unsigned int               dim,
         const std::vector<unsigned int> &dofs_per_object,
         const ::ReferenceCell      reference_cell);
} // namespace internal
 
 
 
// --------- inline and template functions ---------------
 
 
#ifndef DOXYGEN
 
namespace FiniteElementDomination
{
  inline Domination operator&(const Domination d1, const Domination d2)
  {
    // go through the entire list of possibilities. note that if we were into
    // speed, obfuscation and cared enough, we could implement this operator
    // by doing a bitwise & (and) if we gave these values to the enum values:
    // neither_element_dominates=0, this_element_dominates=1,
    // other_element_dominates=2, either_element_can_dominate=3
    // =this_element_dominates|other_element_dominates
    switch (d1)
      {
        case this_element_dominates:
          if ((d2 == this_element_dominates) ||
              (d2 == either_element_can_dominate) || (d2 == no_requirements))
            return this_element_dominates;
          else
            return neither_element_dominates;
 
        case other_element_dominates:
          if ((d2 == other_element_dominates) ||
              (d2 == either_element_can_dominate) || (d2 == no_requirements))
            return other_element_dominates;
          else
            return neither_element_dominates;
 
        case neither_element_dominates:
          return neither_element_dominates;
 
        case either_element_can_dominate:
          if (d2 == no_requirements)
            return either_element_can_dominate;
          else
            return d2;
 
        case no_requirements:
          return d2;
 
        default:
          // shouldn't get here
          Assert(false, ExcInternalError());
      }
 
    return neither_element_dominates;
  }
} // namespace FiniteElementDomination
 
 
template <int dim>
inline ReferenceCell
FiniteElementData<dim>::reference_cell() const
{
  return reference_cell_kind;
}
 
 
 
template <int dim>
inline unsigned int
FiniteElementData<dim>::n_unique_quads() const
{
  return number_unique_quads;
}
 
 
 
template <int dim>
inline unsigned int
FiniteElementData<dim>::n_unique_faces() const
{
  return number_unique_faces;
}
 
 
 
template <int dim>
inline unsigned int
FiniteElementData<dim>::n_dofs_per_vertex() const
{
  return dofs_per_vertex;
}
 
 
 
template <int dim>
inline unsigned int
FiniteElementData<dim>::n_dofs_per_line() const
{
  return dofs_per_line;
}
 
 
 
template <int dim>
inline unsigned int
FiniteElementData<dim>::n_dofs_per_quad(unsigned int face_no) const
{
  return n_dofs_on_quad[n_dofs_on_quad.size() == 1 ? 0 : face_no];
}
 
 
 
template <int dim>
inline unsigned int
FiniteElementData<dim>::max_dofs_per_quad() const
{
  return dofs_per_quad_max;
}
 
 
 
template <int dim>
inline unsigned int
FiniteElementData<dim>::n_dofs_per_hex() const
{
  return dofs_per_hex;
}
 
 
 
template <int dim>
inline unsigned int
FiniteElementData<dim>::n_dofs_per_face(unsigned int face_no,
                                        unsigned int child_no) const
{
  (void)child_no;
 
  return n_dofs_on_face[n_dofs_on_face.size() == 1 ? 0 : face_no];
}
 
 
 
template <int dim>
inline unsigned int
FiniteElementData<dim>::max_dofs_per_face() const
{
  return dofs_per_face_max;
}
 
 
 
template <int dim>
inline unsigned int
FiniteElementData<dim>::n_dofs_per_cell() const
{
  return dofs_per_cell;
}
 
 
 
template <int dim>
template <int structdim>
inline unsigned int
FiniteElementData<dim>::n_dofs_per_object(const unsigned int i) const
{
  switch (structdim)
    {
      case 0:
        return n_dofs_per_vertex();
      case 1:
        return n_dofs_per_line();
      case 2:
        return n_dofs_per_quad((structdim == 2 && dim == 3) ? i : 0);
      case 3:
        return n_dofs_per_hex();
      default:
        Assert(false, ExcInternalError());
    }
  return numbers::invalid_unsigned_int;
}
 
 
 
template <int dim>
inline unsigned int
FiniteElementData<dim>::n_components() const
{
  return components;
}
 
 
 
template <int dim>
inline const BlockIndices &
FiniteElementData<dim>::block_indices() const
{
  return block_indices_data;
}
 
 
 
template <int dim>
inline unsigned int
FiniteElementData<dim>::n_blocks() const
{
  return block_indices_data.size();
}
 
 
 
template <int dim>
inline unsigned int
FiniteElementData<dim>::tensor_degree() const
{
  return degree;
}
 
 
template <int dim>
inline bool
FiniteElementData<dim>::conforms(const Conformity space) const
{
  return ((space & conforming_space) == space);
}
 
 
 
template <int dim>
unsigned int
FiniteElementData<dim>::get_first_line_index() const
{
  return first_line_index;
}
 
template <int dim>
unsigned int
FiniteElementData<dim>::get_first_quad_index(const unsigned int quad_no) const
{
  if (first_index_of_quads.size() == 1)
    return first_index_of_quads[0] + quad_no * n_dofs_per_quad(0);
  else
    return first_index_of_quads[quad_no];
}
 
template <int dim>
unsigned int
FiniteElementData<dim>::get_first_hex_index() const
{
  return first_hex_index;
}
 
template <int dim>
unsigned int
FiniteElementData<dim>::get_first_face_line_index(
  const unsigned int face_no) const
{
  return first_line_index_of_faces[first_line_index_of_faces.size() == 1 ?
                                     0 :
                                     face_no];
}
 
template <int dim>
unsigned int
FiniteElementData<dim>::get_first_face_quad_index(
  const unsigned int face_no) const
{
  return first_quad_index_of_faces[first_quad_index_of_faces.size() == 1 ?
                                     0 :
                                     face_no];
}
 
 
#endif // DOXYGEN
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif