fe_base.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2000 - 2017 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/base/geometry_info.h>
#include <deal.II/base/point.h>
#include <deal.II/base/subscriptor.h>
#include <deal.II/base/table.h>
#include <deal.II/base/tensor.h>
#include <deal.II/base/vector_slice.h>

#include <deal.II/fe/fe_update_flags.h>

#include <deal.II/lac/block_indices.h>
#include <deal.II/lac/full_matrix.h>

#include <string>
#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