instationary.hh

#ifndef DUNE_FEM_FUNCTION_COMMON_INSTATIONARY_HH
#define DUNE_FEM_FUNCTION_COMMON_INSTATIONARY_HH
 
#include <functional>
#include <type_traits>
#include <utility>
 
#include <dune/fem/function/common/function.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    // BasicInstationaryFunction
    // -------------------------
 
    template< class FunctionSpace, class Function >
    class BasicInstationaryFunction
      : public Dune::Fem::Function< FunctionSpace, Function >
    {
    public:
      explicit BasicInstationaryFunction ( double time )
        : time_( time )
      {}
 
      double setTime ( double time ) { return (time_ = time); }
 
      double time () const { return time_; }
 
    private:
      double time_;
    };
 
 
 
#ifndef DOXYGEN
 
    namespace __InstationaryFunction
    {
 
      // HoldCopy
      // --------
 
      template< class Function >
      struct HoldCopy
      {
        explicit HoldCopy ( Function function )
          : function_( std::move( function ) )
        {}
 
        const Function &get () const noexcept { return function_; }
 
      private:
        Function function_;
      };
 
 
 
      // HoldReference
      // -------------
 
      template< class Function >
      struct HoldReference
      {
        explicit HoldReference ( const Function &function )
          : function_( function )
        {}
 
        const Function &get () const noexcept { return function_.get(); }
 
      private:
        std::reference_wrapper< const Function > function_;
      };
 
    } // namespace __InstationaryFunction
 
#endif // #ifndef DOXYGEN
 
 
 
    // InstationaryFunction
    // --------------------
 
    template< class Function,
              template< class > class StoragePolicy = __InstationaryFunction::HoldCopy >
    class InstationaryFunction
      : public BasicInstationaryFunction< typename Function::FunctionSpaceType, InstationaryFunction< Function, StoragePolicy > >,
        private StoragePolicy< Function >
    {
      typedef BasicInstationaryFunction< typename Function::FunctionSpaceType, InstationaryFunction< Function, StoragePolicy > > BaseType;
      typedef StoragePolicy< Function > StoragePolicyType;
 
    public:
      typedef typename BaseType::DomainType DomainType;
 
      InstationaryFunction ( const Function &function, double time )
        : BaseType( time ),
          StoragePolicyType( function )
      {}
 
      InstationaryFunction ( Function &&function, double time )
        : BaseType( time ),
          StoragePolicyType( std::move( function ) )
      {}
 
      void evaluate ( const DomainType &x, typename BaseType::RangeType &value ) const
      {
        this->get().evaluate( x, this->time(), value );
      }
 
      void jacobian ( const DomainType &x, typename BaseType::JacobianRangeType &jacobian ) const
      {
        this->get().jacobian( x, this->time(), jacobian );
      }
 
      void hessian ( const DomainType &x, typename BaseType::HessianRangeType &hessian ) const
      {
        this->get().hessian( x, this->time(), hessian );
      }
 
    };
 
 
 
    // instationaryFunction
    // --------------------
 
    template< class Function >
    InstationaryFunction< Function, __InstationaryFunction::HoldCopy >
    instationaryFunction ( Function function, double time )
    {
      typedef InstationaryFunction< Function, __InstationaryFunction::HoldCopy > InstationaryFunctionType;
      return InstationaryFunctionType( std::move( function ), time );
    }
 
    template< class Function >
    InstationaryFunction< typename std::remove_const< Function >::type, __InstationaryFunction::HoldReference >
    instationaryFunction ( std::reference_wrapper< Function > function, double time )
    {
      typedef InstationaryFunction< typename std::remove_const< Function >::type, __InstationaryFunction::HoldReference > InstationaryFunctionType;
      return InstationaryFunctionType( function.get(), time );
    }
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_FUNCTION_COMMON_INSTATIONARY_HH