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/dofs/dof_handler.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, class InputVector, int spacedim>
  void
  approximate_gradient(const Mapping<dim, spacedim> &   mapping,
                       const DoFHandler<dim, spacedim> &dof,
                       const InputVector &              solution,
                       Vector<float> &                  derivative_norm,
                       const unsigned int               component = 0);
 
  template <int dim, class InputVector, int spacedim>
  void
  approximate_gradient(const DoFHandler<dim, spacedim> &dof,
                       const InputVector &              solution,
                       Vector<float> &                  derivative_norm,
                       const unsigned int               component = 0);
 
  template <int dim, class InputVector, int spacedim>
  void
  approximate_second_derivative(const Mapping<dim, spacedim> &   mapping,
                                const DoFHandler<dim, spacedim> &dof,
                                const InputVector &              solution,
                                Vector<float> &    derivative_norm,
                                const unsigned int component = 0);
 
  template <int dim, class InputVector, int spacedim>
  void
  approximate_second_derivative(const DoFHandler<dim, spacedim> &dof,
                                const InputVector &              solution,
                                Vector<float> &    derivative_norm,
                                const unsigned int component = 0);
 
  template <int dim, int spacedim, class InputVector, int order>
  void
  approximate_derivative_tensor(
    const Mapping<dim, spacedim> &   mapping,
    const DoFHandler<dim, spacedim> &dof,
    const InputVector &              solution,
#ifndef _MSC_VER
    const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
#else
    const TriaActiveIterator<::DoFCellAccessor<dim, spacedim, false>>
      &cell,
#endif
    Tensor<order, dim> &derivative,
    const unsigned int  component = 0);
 
  template <int dim, int spacedim, class InputVector, int order>
  void
  approximate_derivative_tensor(
    const DoFHandler<dim, spacedim> &dof,
    const InputVector &              solution,
#ifndef _MSC_VER
    const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
#else
    const TriaActiveIterator<::DoFCellAccessor<dim, spacedim, false>>
      &cell,
#endif
    Tensor<order, dim> &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