derivative_approximation.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2000 - 2020 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_derivative_approximation_h
#define dealii_derivative_approximation_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/synchronous_iterator.h>
 
#include <deal.II/fe/fe_update_flags.h>
#include <deal.II/fe/mapping.h>
 
#include <deal.II/grid/filtered_iterator.h>
 
#include <deal.II/lac/vector.h>
#ifdef _MSC_VER
#  include <deal.II/dofs/dof_accessor.h>
#endif
#include <utility>
 
DEAL_II_NAMESPACE_OPEN
 
namespace DerivativeApproximation
{
  template <int dim,
            template <int, int> class DoFHandlerType,
            class InputVector,
            int spacedim>
  void
  approximate_gradient(const Mapping<dim, spacedim> &       mapping,
                       const DoFHandlerType<dim, spacedim> &dof,
                       const InputVector &                  solution,
                       Vector<float> &                      derivative_norm,
                       const unsigned int                   component = 0);
 
  template <int dim,
            template <int, int> class DoFHandlerType,
            class InputVector,
            int spacedim>
  void
  approximate_gradient(const DoFHandlerType<dim, spacedim> &dof,
                       const InputVector &                  solution,
                       Vector<float> &                      derivative_norm,
                       const unsigned int                   component = 0);
 
  template <int dim,
            template <int, int> class DoFHandlerType,
            class InputVector,
            int spacedim>
  void
  approximate_second_derivative(const Mapping<dim, spacedim> &       mapping,
                                const DoFHandlerType<dim, spacedim> &dof,
                                const InputVector &                  solution,
                                Vector<float> &    derivative_norm,
                                const unsigned int component = 0);
 
  template <int dim,
            template <int, int> class DoFHandlerType,
            class InputVector,
            int spacedim>
  void
  approximate_second_derivative(const DoFHandlerType<dim, spacedim> &dof,
                                const InputVector &                  solution,
                                Vector<float> &    derivative_norm,
                                const unsigned int component = 0);
 
  template <typename DoFHandlerType, class InputVector, int order>
  void
  approximate_derivative_tensor(
    const Mapping<DoFHandlerType::dimension, DoFHandlerType::space_dimension>
      &                   mapping,
    const DoFHandlerType &dof,
    const InputVector &   solution,
#ifndef _MSC_VER
    const typename DoFHandlerType::active_cell_iterator &cell,
#else
    const TriaActiveIterator<::DoFCellAccessor<DoFHandlerType, false>>
      &cell,
#endif
    Tensor<order, DoFHandlerType::dimension> &derivative,
    const unsigned int                        component = 0);
 
  template <typename DoFHandlerType, class InputVector, int order>
  void
  approximate_derivative_tensor(
    const DoFHandlerType &dof,
    const InputVector &   solution,
#ifndef _MSC_VER
    const typename DoFHandlerType::active_cell_iterator &cell,
#else
    const TriaActiveIterator<::DoFCellAccessor<DoFHandlerType, false>>
      &cell,
#endif
    Tensor<order, DoFHandlerType::dimension> &derivative,
    const unsigned int                        component = 0);
 
  template <int dim, int order>
  double
  derivative_norm(const Tensor<order, dim> &derivative);
 
  DeclException2(ExcVectorLengthVsNActiveCells,
                 int,
                 int,
                 << "The output vector needs to have a size equal "
                    "to the number of active cells of your triangulation "
                    "but has length "
                 << arg1 << "There are " << arg2
                 << " active cells in your triangulation.");
  DeclExceptionMsg(ExcInsufficientDirections,
                   "While computing a finite difference approximation to "
                   "derivatives, the algorithm encountered a cell on which "
                   "the number of linearly "
                   "independent directions that span the matrix Y (discussed "
                   "in the documentation of the DerivativeApproximation "
                   "class) is not equal to dim. The matrix Y then is "
                   "rank deficient and can not be inverted. A common reason "
                   "why this might be happening is if a cell has neither "
                   "left/right (or up/down, or front/back) neighbors, for "
                   "example because the mesh is too coarse.");
} // namespace DerivativeApproximation
 
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif