fe_base.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2000 - 2016 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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#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/subscriptor.h>
#include <deal.II/base/point.h>
#include <deal.II/base/tensor.h>
#include <deal.II/base/table.h>
#include <deal.II/base/vector_slice.h>
#include <deal.II/base/geometry_info.h>
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/block_indices.h>
#include <deal.II/fe/fe_update_flags.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);
}


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;
  }
}


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