basicfunctions.hh

#ifndef __DUNE_ACFEM_BASICFUNCTIONS_HH__
#define __DUNE_ACFEM_BASICFUNCTIONS_HH__
 
#include <dune/fem/function/localfunction/mutable.hh>
#include <dune/fem/function/localfunction/const.hh>
 
#include "../functions/gridfunctionexpression.hh"
#include "../functions/boundaryfunctionexpression.hh"
 
#include "../functions/constantfunction.hh"
#include "../functions/coordinatefunctions.hh"
#include "../functions/divergencefunction.hh"
#include "../functions/gradientfunction.hh"
#include "../functions/piecewisefunction.hh"
#include "../functions/righthandsidefunction.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class GridPart>
    static inline
    auto identityGridFunction(const GridPart& gridPart)
      -> decltype(wrapToGridFunction(std::declval<std::string>(),
                                     std::declval<IdentityFunction<typename GridPart::ctype,
                                                                   GridPart::dimensionworld> >(),
                                     gridPart,
                                     1))
    {
      typedef IdentityFunction<typename GridPart::ctype, GridPart::dimensionworld> FunctionType;
 
      return wrapToGridFunction("x -> x", FunctionType(), gridPart, 1);
    }
 
    template<unsigned N>
    struct X
      : public std::integral_constant<unsigned, N>
    {};
 
    template<class GridPart, unsigned N>
    static inline
    auto coordinateGridFunction(const GridPart& gridPart, const std::integral_constant<unsigned, N>& dummy)
      -> decltype(wrapToGridFunction(std::declval<std::string>(),
                                     std::declval<CoordinateFunction<typename GridPart::ctype,
                                                                     GridPart::dimensionworld, N> >(),
                                     gridPart,
                                     1))
    {
      typedef CoordinateFunction<typename GridPart::ctype, GridPart::dimensionworld, N> FunctionType;
 
      // could use stringstream here.
      return wrapToGridFunction("(x -> x_" + std::to_string(N) + ")", FunctionType(), gridPart, 1);
    }
 
    template<class GridPart, unsigned N>
    static inline
    ConstantGridFunction<Fem::FunctionSpace<typename GridPart::ctype,
                                            typename GridPart::ctype,
                                            GridPart::dimensionworld,
                                            GridPart::dimensionworld>,
                         GridPart>
    coordinateVectorFunction(const GridPart& gridPart, const std::integral_constant<unsigned, N>& dummy)
    {
      const int dimWorld = GridPart::dimensionworld;
      typedef typename GridPart::ctype FieldType;
      typedef Fem::FunctionSpace<FieldType, FieldType, dimWorld, dimWorld> FunctionSpaceType;
      typedef ConstantGridFunction<FunctionSpaceType, GridPart> FunctionType;
      typename FunctionSpaceType::RangeType e_N;
 
      e_N = 0.;
      e_N[N] = 1.0;
 
      return FunctionType(e_N, gridPart);
    }
 
    template<class GridFunction>
    LocalFunctionWrapper<LocalDivergenceAdapter<GridFunction>, typename GridFunction::GridPartType>
    divergence(const Fem::Function<typename GridFunction::FunctionSpaceType, GridFunction>& f_, const std::string& name = "")
    {
      typedef LocalDivergenceAdapter<GridFunction> LocalFunctionType;
      typedef LocalFunctionWrapper<LocalFunctionType, typename GridFunction::GridPartType> GridFunctionType;
 
      const GridFunction& f(static_cast<const GridFunction&>(f_));
      LocalFunctionType div(f, name);
 
      return GridFunctionType(div.name(), div, f.space().gridPart(), f.space().order() - 1);
    }
 
    template<class GridFunction>
    LocalFunctionWrapper<LocalGradientAdapter<GridFunction>, typename GridFunction::GridPartType>
    gradient(const Fem::Function<typename GridFunction::FunctionSpaceType, GridFunction>& f_, const std::string& name = "")
    {
      typedef LocalGradientAdapter<GridFunction> LocalFunctionType;
      typedef LocalFunctionWrapper<LocalFunctionType, typename GridFunction::GridPartType> GridFunctionType;
 
      const GridFunction& f(static_cast<const GridFunction&>(f_));
      LocalFunctionType div(f, name);
 
      return GridFunctionType(div.name(), div, f.space().gridPart(), f.space().order() - 1);
    }
 
    template<class CharacteristicFunction, class GridFunction0, class GridFunction1>
    LocalFunctionWrapper<LocalPiecewiseAdapter<CharacteristicFunction, GridFunction0, GridFunction1>, typename GridFunction0::GridPartType>
    piecewise(const Fem::Function<typename CharacteristicFunction::FunctionSpaceType, CharacteristicFunction>& characteristic,
              const Fem::Function<typename GridFunction0::FunctionSpaceType, GridFunction0>& function0,
              const Fem::Function<typename GridFunction1::FunctionSpaceType, GridFunction1>& function1,
              const std::string& name = "")
    {
      typedef LocalPiecewiseAdapter<CharacteristicFunction, GridFunction0, GridFunction1> LocalFunctionType;
      typedef LocalFunctionWrapper<LocalFunctionType, typename GridFunction0::GridPartType> GridFunctionType;
 
      const auto& realFunction0 = static_cast<const GridFunction0&>(function0);
      const auto& realFunction1 = static_cast<const GridFunction1&>(function1);
      const auto& gridPart = realFunction0.space().gridPart();
 
      const auto& c = static_cast<const CharacteristicFunction&>(characteristic);
 
      LocalFunctionType pw(c, function0, function1, name);
 
      return GridFunctionType(pw.name(), pw, gridPart, std::max(realFunction0.space().order(), realFunction1.space().order()));
    }
 
 
    template<class CharacteristicFunction, class GridFunction1>
    LocalFunctionWrapper<LocalPiecewiseAdapter<CharacteristicFunction, ConstantGridFunction<typename GridFunction1::FunctionSpaceType, typename GridFunction1::GridPartType>, GridFunction1>, typename GridFunction1::GridPartType>
    piecewise(const Fem::Function<typename CharacteristicFunction::FunctionSpaceType, CharacteristicFunction>& characteristic,
              const typename GridFunction1::FunctionSpaceType::RangeType value0,
              const Fem::Function<typename GridFunction1::FunctionSpaceType, GridFunction1>& function1,
              const std::string& name = "")
    {
      typedef ConstantGridFunction<typename GridFunction1::FunctionSpaceType, typename GridFunction1::GridPartType> GridFunction0;
      typedef LocalPiecewiseAdapter<CharacteristicFunction, GridFunction0, GridFunction1> LocalFunctionType;
      typedef LocalFunctionWrapper<LocalFunctionType, typename GridFunction0::GridPartType> GridFunctionType;
 
      const auto& realFunction1 = static_cast<const GridFunction1&>(function1);
      const auto& gridPart = realFunction1.space().gridPart();
 
      const GridFunction0 realFunction0(value0, gridPart);
 
      const auto& c = static_cast<const CharacteristicFunction&>(characteristic);
 
      LocalFunctionType pw(c, realFunction0, function1, name);
 
      return GridFunctionType(pw.name(), pw, gridPart, std::max(realFunction0.space().order(), realFunction1.space().order()));
    }
 
    template<class CharacteristicFunction, class GridFunction0>
    LocalFunctionWrapper<LocalPiecewiseAdapter<CharacteristicFunction, GridFunction0, ConstantGridFunction<typename GridFunction0::FunctionSpaceType, typename GridFunction0::GridPartType> >, typename GridFunction0::GridPartType>
    piecewise(const Fem::Function<typename CharacteristicFunction::FunctionSpaceType, CharacteristicFunction>& characteristic,
              const Fem::Function<typename GridFunction0::FunctionSpaceType, GridFunction0>& function0,
              const typename GridFunction0::FunctionSpaceType::RangeType value1,
              const std::string& name = "")
    {
      typedef ConstantGridFunction<typename GridFunction0::FunctionSpaceType, typename GridFunction0::GridPartType> GridFunction1;
      typedef LocalPiecewiseAdapter<CharacteristicFunction, GridFunction0, GridFunction1> LocalFunctionType;
      typedef LocalFunctionWrapper<LocalFunctionType, typename GridFunction0::GridPartType> GridFunctionType;
 
      const auto& realFunction0 = static_cast<const GridFunction0&>(function0);
      const auto& gridPart = realFunction0.space().gridPart();
      const GridFunction1  realFunction1(value1, gridPart);
 
      const auto& c = static_cast<const CharacteristicFunction&>(characteristic);
 
      LocalFunctionType pw(c, function0, realFunction1, name);
 
      return GridFunctionType(pw.name(), pw, gridPart, std::max(realFunction0.space().order(), realFunction1.space().order()));
    }
    template<class CharacteristicFunction, class FunctionSpaceType>
    LocalFunctionWrapper<LocalPiecewiseAdapter<CharacteristicFunction, ConstantGridFunction<FunctionSpaceType, typename CharacteristicFunction::GridPartType>, ConstantGridFunction<FunctionSpaceType, typename CharacteristicFunction::GridPartType> >, typename CharacteristicFunction::GridPartType>
    piecewise(const Fem::Function<typename CharacteristicFunction::FunctionSpaceType, CharacteristicFunction>& characteristic,
              const typename FunctionSpaceType::RangeType value0,
              const typename FunctionSpaceType::RangeType value1,
              const std::string& name = "")
    {
      typedef ConstantGridFunction<FunctionSpaceType, typename CharacteristicFunction::GridPartType> GridFunction0;
      typedef ConstantGridFunction<FunctionSpaceType, typename CharacteristicFunction::GridPartType> GridFunction1;
      typedef LocalPiecewiseAdapter<CharacteristicFunction, GridFunction0, GridFunction1> LocalFunctionType;
      typedef LocalFunctionWrapper<LocalFunctionType, typename GridFunction0::GridPartType> GridFunctionType;
 
      const auto& c = static_cast<const CharacteristicFunction&>(characteristic);
 
      const auto& gridPart = c.space().gridPart();
      const GridFunction0  realFunction0(value0, gridPart);
      const GridFunction1  realFunction1(value1, gridPart);
 
      LocalFunctionType pw(c, realFunction0, realFunction1, name);
 
      return GridFunctionType(pw.name(), pw, gridPart, std::max(realFunction0.space().order(), realFunction1.space().order()));
    }
 
    template<class Traits>
    typename Fem::ConstLocalFunction<typename Traits::DiscreteFunctionType>
    localFunction(const Fem::DiscreteFunctionInterface<Traits>& f_)
    {
      typedef typename Traits::DiscreteFunctionType DiscreteFunctionType;
      const auto& f = static_cast<const DiscreteFunctionType&>(f_);
 
      return Fem::ConstLocalFunction<DiscreteFunctionType>(f);
    }
 
    template<class Traits>
    typename Fem::MutableLocalFunction<typename Traits::DiscreteFunctionType>
    localFunction(Fem::DiscreteFunctionInterface<Traits>& f_)
    {
      typedef typename Traits::DiscreteFunctionType DiscreteFunctionType;
      auto& f = static_cast<DiscreteFunctionType&>(f_);
 
      return Fem::MutableLocalFunction<DiscreteFunctionType>(f);
    }
 
#if 0
    // Does not make sense without special "const" object.
    template<class GridFunction>
    const typename GridFunction::LocalFunctionType
    localFunction(const Fem::Function<typename GridFunction::FunctionSpaceType, GridFunction>& f_)
    {
      typedef typename GridFunction::LocalFunctionType LocalFunctionType;
      const auto& f = asImp(f_);
 
      return LocalFunctionType(f);
    }
#endif
 
    template<class GridFunction>
    typename GridFunction::LocalFunctionType
    localFunction(const Fem::Function<typename GridFunction::FunctionSpaceType, GridFunction>& f_)
    {
      typedef typename GridFunction::LocalFunctionType LocalFunctionType;
      auto& f = asImp(f_);
 
      return LocalFunctionType(f);
    }
 
 
 
 
  } // ACFem::
 
} // Dune::
 
#endif // __DUNE_ACFEM_BASICFUNCTIONS_HH__