derivative_approximation.h

// ---------------------------------------------------------------------
//
// 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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#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/lac/vector.h>
#include <deal.II/grid/filtered_iterator.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,
                    "We have 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.");
}



DEAL_II_NAMESPACE_CLOSE

#endif