function_lib.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1999 - 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_function_lib_h
#define dealii_function_lib_h


#include <deal.II/base/config.h>
#include <deal.II/base/function.h>
#include <deal.II/base/point.h>
#include <deal.II/base/table.h>

#include <array>

DEAL_II_NAMESPACE_OPEN

namespace Functions
{


  template <int dim>
  class SquareFunction : public Function<dim>
  {
  public:
    virtual double value (const Point<dim>   &p,
                          const unsigned int  component = 0) const;
    virtual void vector_value (const Point<dim>   &p,
                               Vector<double>     &values) const;
    virtual void value_list (const std::vector<Point<dim> > &points,
                             std::vector<double>            &values,
                             const unsigned int              component = 0) const;
    virtual Tensor<1,dim> gradient (const Point<dim>   &p,
                                    const unsigned int  component = 0) const;
    virtual void vector_gradient (const Point<dim>   &p,
                                  std::vector<Tensor<1,dim> >    &gradient) const;
    virtual void gradient_list (const std::vector<Point<dim> > &points,
                                std::vector<Tensor<1,dim> >    &gradients,
                                const unsigned int              component = 0) const;
    virtual double laplacian (const Point<dim>   &p,
                              const unsigned int  component = 0) const;
    virtual void laplacian_list (const std::vector<Point<dim> > &points,
                                 std::vector<double>            &values,
                                 const unsigned int              component = 0) const;
  };



  template <int dim>
  class Q1WedgeFunction : public Function<dim>
  {
  public:
    virtual double value (const Point<dim>   &p,
                          const unsigned int  component = 0) const;

    virtual void value_list (const std::vector<Point<dim> > &points,
                             std::vector<double>            &values,
                             const unsigned int              component = 0) const;

    virtual void vector_value_list (const std::vector<Point<dim> > &points,
                                    std::vector<Vector<double> > &values) const;

    virtual Tensor<1,dim> gradient (const Point<dim>   &p,
                                    const unsigned int       component = 0) const;

    virtual void gradient_list (const std::vector<Point<dim> > &points,
                                std::vector<Tensor<1,dim> >    &gradients,
                                const unsigned int              component = 0) const;

    virtual void vector_gradient_list (const std::vector<Point<dim> > &,
                                       std::vector<std::vector<Tensor<1,dim> > > &) const;

    virtual double laplacian (const Point<dim>   &p,
                              const unsigned int  component = 0) const;

    virtual void laplacian_list (const std::vector<Point<dim> > &points,
                                 std::vector<double>            &values,
                                 const unsigned int              component = 0) const;
  };



  template <int dim>
  class PillowFunction : public Function<dim>
  {
  public:
    PillowFunction (const double offset=0.);

    virtual double value (const Point<dim>   &p,
                          const unsigned int  component = 0) const;

    virtual void value_list (const std::vector<Point<dim> > &points,
                             std::vector<double>            &values,
                             const unsigned int              component = 0) const;

    virtual Tensor<1,dim> gradient (const Point<dim>   &p,
                                    const unsigned int  component = 0) const;

    virtual void gradient_list (const std::vector<Point<dim> > &points,
                                std::vector<Tensor<1,dim> >    &gradients,
                                const unsigned int              component = 0) const;

    virtual double laplacian (const Point<dim>   &p,
                              const unsigned int  component = 0) const;

    virtual void laplacian_list (const std::vector<Point<dim> > &points,
                                 std::vector<double>            &values,
                                 const unsigned int              component = 0) const;
  private:
    const double offset;
  };



  template <int dim>
  class CosineFunction : public Function<dim>
  {
  public:
    CosineFunction (const unsigned int n_components = 1);

    virtual double value (const Point<dim>   &p,
                          const unsigned int  component = 0) const;

    virtual void value_list (const std::vector<Point<dim> > &points,
                             std::vector<double>            &values,
                             const unsigned int              component = 0) const;

    virtual void vector_value_list (const std::vector<Point<dim> > &points,
                                    std::vector<Vector<double> > &values) const;

    virtual Tensor<1,dim> gradient (const Point<dim>   &p,
                                    const unsigned int  component = 0) const;

    virtual void gradient_list (const std::vector<Point<dim> > &points,
                                std::vector<Tensor<1,dim> >    &gradients,
                                const unsigned int              component = 0) const;

    virtual double laplacian (const Point<dim>   &p,
                              const unsigned int  component = 0) const;

    virtual void laplacian_list (const std::vector<Point<dim> > &points,
                                 std::vector<double>            &values,
                                 const unsigned int              component = 0) const;

    virtual SymmetricTensor<2,dim> hessian (const Point<dim>   &p,
                                            const unsigned int  component = 0) const;

    virtual void hessian_list (const std::vector<Point<dim> > &points,
                               std::vector<SymmetricTensor<2,dim> >    &hessians,
                               const unsigned int              component = 0) const;
  };



  template <int dim>
  class CosineGradFunction : public Function<dim>
  {
  public:
    CosineGradFunction ();

    virtual double value (const Point<dim>   &p,
                          const unsigned int  component) const;
    virtual void vector_value (const Point<dim>   &p,
                               Vector<double>     &values) const;
    virtual void value_list (const std::vector<Point<dim> > &points,
                             std::vector<double>            &values,
                             const unsigned int              component) const;

    virtual void vector_value_list (const std::vector<Point<dim> > &points,
                                    std::vector<Vector<double> > &values) const;

    virtual Tensor<1,dim> gradient (const Point<dim>   &p,
                                    const unsigned int  component) const;

    virtual void gradient_list (const std::vector<Point<dim> > &points,
                                std::vector<Tensor<1,dim> >    &gradients,
                                const unsigned int              component) const;

    virtual void vector_gradient_list (const std::vector<Point<dim> >            &points,
                                       std::vector<std::vector<Tensor<1,dim> > > &gradients) const;

    virtual double laplacian (const Point<dim>   &p,
                              const unsigned int  component) const;
  };



  template <int dim>
  class ExpFunction : public Function<dim>
  {
  public:
    virtual double value (const Point<dim>   &p,
                          const unsigned int  component = 0) const;

    virtual void value_list (const std::vector<Point<dim> > &points,
                             std::vector<double>            &values,
                             const unsigned int              component = 0) const;

    virtual Tensor<1,dim> gradient (const Point<dim>   &p,
                                    const unsigned int  component = 0) const;

    virtual void gradient_list (const std::vector<Point<dim> > &points,
                                std::vector<Tensor<1,dim> >    &gradients,
                                const unsigned int              component = 0) const;

    virtual double laplacian (const Point<dim>   &p,
                              const unsigned int  component = 0) const;

    virtual void laplacian_list (const std::vector<Point<dim> > &points,
                                 std::vector<double>            &values,
                                 const unsigned int              component = 0) const;
  };



  class LSingularityFunction : public Function<2>
  {
  public:
    virtual double value (const Point<2>   &p,
                          const unsigned int  component = 0) const;

    virtual void value_list (const std::vector<Point<2> > &points,
                             std::vector<double>            &values,
                             const unsigned int              component = 0) const;

    virtual void vector_value_list (const std::vector<Point<2> > &points,
                                    std::vector<Vector<double> > &values) const;

    virtual Tensor<1,2> gradient (const Point<2>     &p,
                                  const unsigned int  component = 0) const;

    virtual void gradient_list (const std::vector<Point<2> > &points,
                                std::vector<Tensor<1,2> >    &gradients,
                                const unsigned int            component = 0) const;

    virtual void vector_gradient_list (const std::vector<Point<2> > &,
                                       std::vector<std::vector<Tensor<1,2> > > &) const;

    virtual double laplacian (const Point<2>   &p,
                              const unsigned int  component = 0) const;

    virtual void laplacian_list (const std::vector<Point<2> > &points,
                                 std::vector<double>          &values,
                                 const unsigned int            component = 0) const;
  };



  class LSingularityGradFunction : public Function<2>
  {
  public:
    LSingularityGradFunction ();
    virtual double value (const Point<2>   &p,
                          const unsigned int  component) const;

    virtual void value_list (const std::vector<Point<2> > &points,
                             std::vector<double>            &values,
                             const unsigned int              component) const;

    virtual void vector_value_list (const std::vector<Point<2> > &points,
                                    std::vector<Vector<double> > &values) const;

    virtual Tensor<1,2> gradient (const Point<2>     &p,
                                  const unsigned int  component) const;

    virtual void gradient_list (const std::vector<Point<2> > &points,
                                std::vector<Tensor<1,2> >    &gradients,
                                const unsigned int            component) const;

    virtual void vector_gradient_list (const std::vector<Point<2> > &,
                                       std::vector<std::vector<Tensor<1,2> > > &) const;

    virtual double laplacian (const Point<2>   &p,
                              const unsigned int  component) const;

    virtual void laplacian_list (const std::vector<Point<2> > &points,
                                 std::vector<double>          &values,
                                 const unsigned int            component) const;
  };



  template <int dim>
  class SlitSingularityFunction : public Function<dim>
  {
  public:
    virtual double value (const Point<dim>   &p,
                          const unsigned int  component = 0) const;

    virtual void value_list (const std::vector<Point<dim> > &points,
                             std::vector<double>            &values,
                             const unsigned int              component = 0) const;

    virtual void vector_value_list (const std::vector<Point<dim> > &points,
                                    std::vector<Vector<double> > &values) const;

    virtual Tensor<1,dim> gradient (const Point<dim>   &p,
                                    const unsigned int  component = 0) const;

    virtual void gradient_list (const std::vector<Point<dim> > &points,
                                std::vector<Tensor<1,dim> >    &gradients,
                                const unsigned int            component = 0) const;

    virtual void vector_gradient_list (const std::vector<Point<dim> > &,
                                       std::vector<std::vector<Tensor<1,dim> > > &) const;

    virtual double laplacian (const Point<dim>   &p,
                              const unsigned int  component = 0) const;

    virtual void laplacian_list (const std::vector<Point<dim> > &points,
                                 std::vector<double>          &values,
                                 const unsigned int            component = 0) const;
  };


  class SlitHyperSingularityFunction : public Function<2>
  {
  public:
    virtual double value (const Point<2>   &p,
                          const unsigned int  component = 0) const;

    virtual void value_list (const std::vector<Point<2> > &points,
                             std::vector<double>            &values,
                             const unsigned int              component = 0) const;

    virtual void vector_value_list (const std::vector<Point<2> > &points,
                                    std::vector<Vector<double> > &values) const;

    virtual Tensor<1,2> gradient (const Point<2>   &p,
                                  const unsigned int  component = 0) const;

    virtual void gradient_list (const std::vector<Point<2> > &points,
                                std::vector<Tensor<1,2> >    &gradients,
                                const unsigned int            component = 0) const;

    virtual void vector_gradient_list (const std::vector<Point<2> > &,
                                       std::vector<std::vector<Tensor<1,2> > > &) const;

    virtual double laplacian (const Point<2>   &p,
                              const unsigned int  component = 0) const;

    virtual void laplacian_list (const std::vector<Point<2> > &points,
                                 std::vector<double>          &values,
                                 const unsigned int            component = 0) const;
  };



  template <int dim>
  class JumpFunction : public Function<dim>
  {
  public:
    JumpFunction (const Point<dim> &direction,
                  const double      steepness);

    virtual double value (const Point<dim>   &p,
                          const unsigned int  component = 0) const;

    virtual void value_list (const std::vector<Point<dim> > &points,
                             std::vector<double>            &values,
                             const unsigned int              component = 0) const;

    virtual Tensor<1,dim> gradient (const Point<dim>   &p,
                                    const unsigned int  component = 0) const;

    virtual void gradient_list (const std::vector<Point<dim> > &points,
                                std::vector<Tensor<1,dim> >    &gradients,
                                const unsigned int              component = 0) const;

    virtual double laplacian (const Point<dim>   &p,
                              const unsigned int  component = 0) const;

    virtual void laplacian_list (const std::vector<Point<dim> > &points,
                                 std::vector<double>            &values,
                                 const unsigned int              component = 0) const;

    std::size_t memory_consumption () const;

  protected:
    const Point<dim> direction;

    const double steepness;

    double angle;

    double sine;

    double cosine;
  };



  template <int dim>
  class FourierCosineFunction : public Function<dim>
  {
  public:
    FourierCosineFunction (const Tensor<1,dim> &fourier_coefficients);

    virtual double value (const Point<dim>   &p,
                          const unsigned int  component = 0) const;

    virtual Tensor<1,dim> gradient (const Point<dim>   &p,
                                    const unsigned int  component = 0) const;

    virtual double laplacian (const Point<dim>   &p,
                              const unsigned int  component = 0) const;
  private:
    const Tensor<1,dim> fourier_coefficients;
  };



  template <int dim>
  class FourierSineFunction : public Function<dim>
  {
  public:
    FourierSineFunction (const Tensor<1,dim> &fourier_coefficients);

    virtual double value (const Point<dim>   &p,
                          const unsigned int  component = 0) const;

    virtual Tensor<1,dim> gradient (const Point<dim>   &p,
                                    const unsigned int  component = 0) const;

    virtual double laplacian (const Point<dim>   &p,
                              const unsigned int  component = 0) const;
  private:
    const Tensor<1,dim> fourier_coefficients;
  };


  template <int dim>
  class FourierSineSum : public Function<dim>
  {
  public:
    FourierSineSum (const std::vector<Point<dim> > &fourier_coefficients,
                    const std::vector<double>      &weights);

    virtual double value (const Point<dim>   &p,
                          const unsigned int  component = 0) const;

    virtual Tensor<1,dim> gradient (const Point<dim>   &p,
                                    const unsigned int  component = 0) const;

    virtual double laplacian (const Point<dim>   &p,
                              const unsigned int  component = 0) const;
  private:
    const std::vector<Point<dim> > fourier_coefficients;
    const std::vector<double>      weights;
  };



  template <int dim>
  class FourierCosineSum : public Function<dim>
  {
  public:
    FourierCosineSum (const std::vector<Point<dim> > &fourier_coefficients,
                      const std::vector<double>      &weights);

    virtual double value (const Point<dim>   &p,
                          const unsigned int  component = 0) const;

    virtual Tensor<1,dim> gradient (const Point<dim>   &p,
                                    const unsigned int  component = 0) const;

    virtual double laplacian (const Point<dim>   &p,
                              const unsigned int  component = 0) const;

  private:
    const std::vector<Point<dim> > fourier_coefficients;
    const std::vector<double>      weights;
  };


  template <int dim>
  class CutOffFunctionBase : public Function<dim>
  {
  public:
    static const unsigned int no_component = numbers::invalid_unsigned_int;

    CutOffFunctionBase (const double radius = 1.,
                        const Point<dim> = Point<dim>(),
                        const unsigned int n_components = 1,
                        const unsigned int select = CutOffFunctionBase<dim>::no_component);

    void new_center (const Point<dim> &p);

    void new_radius (const double r);

  protected:
    Point<dim> center;

    double radius;

    const unsigned int selected;
  };



  template <int dim>
  class CutOffFunctionLinfty : public CutOffFunctionBase<dim>
  {
  public:
    CutOffFunctionLinfty (const double radius = 1.,
                          const Point<dim> = Point<dim>(),
                          const unsigned int n_components = 1,
                          const unsigned int select = CutOffFunctionBase<dim>::no_component);

    virtual double value (const Point<dim>   &p,
                          const unsigned int  component = 0) const;

    virtual void value_list (const std::vector<Point<dim> > &points,
                             std::vector<double>            &values,
                             const unsigned int              component = 0) const;

    virtual void vector_value_list (const std::vector<Point<dim> > &points,
                                    std::vector<Vector<double> >           &values) const;
  };


  template <int dim>
  class CutOffFunctionW1 : public CutOffFunctionBase<dim>
  {
  public:
    CutOffFunctionW1 (const double radius = 1.,
                      const Point<dim> = Point<dim>(),
                      const unsigned int n_components = 1,
                      const unsigned int select = CutOffFunctionBase<dim>::no_component);

    virtual double value (const Point<dim>   &p,
                          const unsigned int  component = 0) const;

    virtual void value_list (const std::vector<Point<dim> > &points,
                             std::vector<double>            &values,
                             const unsigned int              component = 0) const;

    virtual void vector_value_list (const std::vector<Point<dim> > &points,
                                    std::vector<Vector<double> >           &values) const;
  };


  template <int dim>
  class CutOffFunctionCinfty : public CutOffFunctionBase<dim>
  {
  public:
    CutOffFunctionCinfty (const double radius = 1.,
                          const Point<dim> = Point<dim>(),
                          const unsigned int n_components = 1,
                          const unsigned int select = CutOffFunctionBase<dim>::no_component);

    virtual double value (const Point<dim>   &p,
                          const unsigned int  component = 0) const;

    virtual void value_list (const std::vector<Point<dim> > &points,
                             std::vector<double>            &values,
                             const unsigned int              component = 0) const;

    virtual void vector_value_list (const std::vector<Point<dim> > &points,
                                    std::vector<Vector<double> >           &values) const;

    virtual Tensor<1,dim> gradient (const Point<dim>   &p,
                                    const unsigned int  component = 0) const;
  };



  template <int dim>
  class Monomial : public Function<dim>
  {
  public:
    Monomial (const Tensor<1,dim> &exponents,
              const unsigned int n_components = 1);

    virtual double value (const Point<dim>   &p,
                          const unsigned int  component = 0) const;

    virtual void vector_value (const Point<dim>   &p,
                               Vector<double>     &values) const;

    virtual void value_list (const std::vector<Point<dim> > &points,
                             std::vector<double>            &values,
                             const unsigned int              component = 0) const;

    virtual Tensor<1,dim> gradient (const Point<dim>   &p,
                                    const unsigned int  component = 0) const;

  private:
    const Tensor<1,dim> exponents;
  };



  template <int dim>
  class InterpolatedTensorProductGridData : public Function<dim>
  {
  public:
    InterpolatedTensorProductGridData (const std::array<std::vector<double>,dim> &coordinate_values,
                                       const Table<dim,double>                   &data_values);

    virtual
    double
    value (const Point<dim> &p,
           const unsigned int component = 0) const;

    virtual
    Tensor<1, dim>
    gradient (const Point<dim>    &p,
              const unsigned int component = 0) const;

  protected:
    TableIndices<dim> table_index_of_point (const Point<dim> &p) const;

    const std::array<std::vector<double>,dim> coordinate_values;

    const Table<dim,double>                     data_values;
  };


  template <int dim>
  class InterpolatedUniformGridData : public Function<dim>
  {
  public:
    InterpolatedUniformGridData (const std::array<std::pair<double,double>,dim> &interval_endpoints,
                                 const std::array<unsigned int,dim>             &n_subintervals,
                                 const Table<dim,double>                        &data_values);

    virtual
    double
    value (const Point<dim> &p,
           const unsigned int component = 0) const;

  private:
    const std::array<std::pair<double,double>,dim> interval_endpoints;

    const std::array<unsigned int,dim>             n_subintervals;

    const Table<dim,double>                     data_values;
  };


  template <int dim>
  class Polynomial : public Function<dim>
  {
  public:
    Polynomial (const Table<2,double>     &exponents,
                const std::vector<double> &coefficients);

    virtual double value (const Point<dim> &p,
                          const unsigned int component = 0) const;


    virtual void value_list (const std::vector<Point<dim> > &points,
                             std::vector<double>      &values,
                             const unsigned int       component = 0) const;

    virtual Tensor<1,dim> gradient (const Point<dim> &p,
                                    const unsigned int component = 0) const;

  private:

    const Table<2,double> exponents;

    const std::vector<double> coefficients;
  };



}
DEAL_II_NAMESPACE_CLOSE

#endif