fe_base.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2000 - 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_base_h
#define dealii_fe_base_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.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
 
 
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;
 
  const unsigned int dofs_per_vertex;
 
  const unsigned int dofs_per_line;
 
  const unsigned int dofs_per_quad;
 
  const unsigned int dofs_per_hex;
 
  const unsigned int first_line_index;
 
  const unsigned int first_quad_index;
 
  const unsigned int first_hex_index;
 
  const unsigned int first_face_line_index;
 
  const unsigned int first_face_quad_index;
 
  const unsigned int dofs_per_face;
 
  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());
 
  unsigned int
  n_dofs_per_vertex() const;
 
  unsigned int
  n_dofs_per_line() const;
 
  unsigned int
  n_dofs_per_quad() const;
 
  unsigned int
  n_dofs_per_hex() const;
 
  unsigned int
  n_dofs_per_face() const;
 
  unsigned int
  n_dofs_per_cell() const;
 
  template <int structdim>
  unsigned int
  n_dofs_per_object() 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;
};
 
 
 
// --------- 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 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() const
{
  return dofs_per_quad;
}
 
 
 
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() const
{
  return dofs_per_face;
}
 
 
 
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
{
  switch (structdim)
    {
      case 0:
        return dofs_per_vertex;
      case 1:
        return dofs_per_line;
      case 2:
        return dofs_per_quad;
      case 3:
        return 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);
}
 
 
#endif // DOXYGEN
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif