dune-fem 2.8.0
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Protected Member Functions | Static Protected Member Functions | Related Functions | List of all members
Dune::Fem::InstationaryFunction< Function, StoragePolicy > Class Template Reference

implementation of a Dune::Fem::Function taking an instationary function More...

#include <dune/fem/function/common/instationary.hh>

Inheritance diagram for Dune::Fem::InstationaryFunction< Function, StoragePolicy >:
Inheritance graph

Public Types

typedef BaseType::DomainType DomainType
 domain type
 
typedef FunctionSpace FunctionSpaceType
 type of function space this function belongs to
 
typedef Function FunctionType
 type of the implementation (Barton-Nackman)
 
typedef FunctionSpaceType::DomainFieldType DomainFieldType
 field type of domain
 
typedef FunctionSpaceType::RangeFieldType RangeFieldType
 field type of range
 
typedef FunctionSpaceType::RangeType RangeType
 range type
 
typedef FunctionSpaceType::JacobianRangeType JacobianRangeType
 jacobian type
 
typedef FunctionSpaceType::HessianRangeType HessianRangeType
 hessian type
 
typedef Mapping< DomainFieldType, RangeFieldType, DomainType, RangeTypeMappingType
 type of mapping base class
 

Public Member Functions

virtual void operator() (const DomainType &arg, RangeType &dest) const
 application operator call evaluate
 
void operator() (const DomainType &arg, RangeType &dest) const
 Application operator that applies all operators in the linear combination stack.
 
void evaluate (const DomainType &x, RangeType &value) const
 evaluate the function
 
void jacobian (const DomainType &x, JacobianRangeType &jacobian) const
 evaluate the Jacobian of the function
 
void hessian (const DomainType &x, HessianRangeType &hessian) const
 evaluate the hessian of the function
 
Constructon
 InstationaryFunction (const Function &function, double time)
 
 InstationaryFunction (Function &&function, double time)
 
Public member methods
void evaluate (const DomainType &x, typename BaseType::RangeType &value) const
 evaluate the function
 
void jacobian (const DomainType &x, typename BaseType::JacobianRangeType &jacobian) const
 evaluate the Jacobian of the function
 
void hessian (const DomainType &x, typename BaseType::HessianRangeType &hessian) const
 evaluate the hessian of the function
 
Set time
double setTime (double time)
 set time to give value
 
double time () const
 return set time
 

Protected Member Functions

const Implementation & asImp () const
 
Implementation & asImp ()
 

Static Protected Member Functions

static const Implementation & asImp (const ThisType &other)
 
static Implementation & asImp (ThisType &other)
 
static const Implementation & asImp (const ThisType &other)
 
static Implementation & asImp (ThisType &other)
 

Related Functions

(Note that these are not member functions.)

template<class DFieldType , class RFieldType , class DType , class RType >
static Mapping< DFieldType, RFieldType, DType, RType > operator+ (const Mapping< DFieldType, RFieldType, DType, RType > &a, const Mapping< DFieldType, RFieldType, DType, RType > &b)
 add two mappings
 
template<class DFieldType , class RFieldType , class DType , class RType >
static Mapping< DFieldType, RFieldType, DType, RType > operator- (const Mapping< DFieldType, RFieldType, DType, RType > &a, const Mapping< DFieldType, RFieldType, DType, RType > &b)
 substract two mappings
 
template<class DFieldType , class RFieldType , class DType , class RType >
static Mapping< DFieldType, RFieldType, DType, RType > operator* (const Mapping< DFieldType, RFieldType, DType, RType > &mapping, const RFieldType &factor)
 scale mapping with factor
 
template<class DFieldType , class RFieldType , class DType , class RType >
static Mapping< DFieldType, RFieldType, DType, RType > operator* (const RFieldType &factor, const Mapping< DFieldType, RFieldType, DType, RType > &mapping)
 scale mapping with factor
 
template<class DFieldType , class RFieldType , class DType , class RType >
static Mapping< DFieldType, RFieldType, DType, RType > operator/ (const Mapping< DFieldType, RFieldType, DType, RType > &mapping, const RFieldType &factor)
 operator / for mappings
 
template<class DFieldType , class RFieldType , class DType , class RType >
static Mapping< DFieldType, RFieldType, DType, RType > operator/ (const RFieldType &factor, const Mapping< DFieldType, RFieldType, DType, RType > &mapping)
 operator / for mappings
 

Detailed Description

template<class Function, template< class > class StoragePolicy = __InstationaryFunction::HoldCopy>
class Dune::Fem::InstationaryFunction< Function, StoragePolicy >

implementation of a Dune::Fem::Function taking an instationary function

It is assumed that all evaluation methods are present on the parameter function and have a second parameter for the time:

void Function::evaluate(const DomainType &x, double time, RangeType &value) const;
void Function::jacobian(const DomainType &x, double time, JacobianRangeType &value) const;
void Function::hessian(const DomainType &x, double time, HessianRangeType &value) const;
Definition: explicitfieldvector.hh:75
FunctionSpaceType::RangeType RangeType
range type
Definition: common/function.hh:68
void evaluate(const DomainType &x, RangeType &value) const
evaluate the function
Definition: common/function.hh:107
FunctionSpaceType::JacobianRangeType JacobianRangeType
jacobian type
Definition: common/function.hh:70
void jacobian(const DomainType &x, JacobianRangeType &jacobian) const
evaluate the Jacobian of the function
Definition: common/function.hh:117
void hessian(const DomainType &x, HessianRangeType &hessian) const
evaluate the hessian of the function
Definition: common/function.hh:127
double time() const
return set time
Definition: instationary.hh:59
BaseType::DomainType DomainType
domain type
Definition: instationary.hh:163

Users may prescribe how the parameter function is stored by providing a second template parameter, the storage policy. The policy is class that must be constructible from a function object or reference and that has a single method:

const Function &Policy::get() const;
Abstract class representing a function.
Definition: common/function.hh:50

The default policy is to copy the function parameter. The free-standing method

InstationaryFunction< Function, __InstationaryFunction::HoldCopy > instationaryFunction(Function function, double time)
Definition: instationary.hh:213

may be used to conveniently create a new instance of InstationaryFunction. Use

auto g = instationaryFunction( std::cref( f ), 0. );

to create an instationary function that holds a reference to f instead of a copy.

Template Parameters
Functionan instationary function
StoragePolicystorage policy

Member Typedef Documentation

◆ DomainFieldType

field type of domain

◆ DomainType

template<class Function , template< class > class StoragePolicy = __InstationaryFunction::HoldCopy>
typedef BaseType::DomainType Dune::Fem::InstationaryFunction< Function, StoragePolicy >::DomainType

domain type

◆ FunctionSpaceType

typedef FunctionSpace Dune::Fem::Function< FunctionSpace , Function >::FunctionSpaceType
inherited

type of function space this function belongs to

◆ FunctionType

typedef Function Dune::Fem::Function< FunctionSpace , Function >::FunctionType
inherited

type of the implementation (Barton-Nackman)

◆ HessianRangeType

hessian type

◆ JacobianRangeType

jacobian type

◆ MappingType

type of mapping base class

◆ RangeFieldType

field type of range

◆ RangeType

range type

Constructor & Destructor Documentation

◆ InstationaryFunction() [1/2]

template<class Function , template< class > class StoragePolicy = __InstationaryFunction::HoldCopy>
Dune::Fem::InstationaryFunction< Function, StoragePolicy >::InstationaryFunction ( const Function function,
double  time 
)
inline

◆ InstationaryFunction() [2/2]

template<class Function , template< class > class StoragePolicy = __InstationaryFunction::HoldCopy>
Dune::Fem::InstationaryFunction< Function, StoragePolicy >::InstationaryFunction ( Function &&  function,
double  time 
)
inline

Member Function Documentation

◆ asImp() [1/6]

Implementation & Dune::Fem::BartonNackmanInterface< Interface, Implementation >::asImp ( )
inlineprotectedinherited

◆ asImp() [2/6]

const Implementation & Dune::Fem::BartonNackmanInterface< Interface, Implementation >::asImp ( ) const
inlineprotectedinherited

◆ asImp() [3/6]

static const Implementation & Dune::Fem::BartonNackmanInterface< Interface, Implementation >::asImp ( const ThisType other)
inlinestaticprotectedinherited

◆ asImp() [4/6]

template<class Interface , class Implementation >
static const Implementation & Dune::Fem::BartonNackmanInterface< Interface, Implementation >::asImp ( const ThisType other)
inlinestaticprotectedinherited

◆ asImp() [5/6]

static Implementation & Dune::Fem::BartonNackmanInterface< Interface, Implementation >::asImp ( ThisType other)
inlinestaticprotectedinherited

◆ asImp() [6/6]

template<class Interface , class Implementation >
static Implementation & Dune::Fem::BartonNackmanInterface< Interface, Implementation >::asImp ( ThisType other)
inlinestaticprotectedinherited

◆ evaluate() [1/2]

void Dune::Fem::Function< FunctionSpace , Function >::evaluate ( const DomainType x,
RangeType value 
) const
inlineinherited

evaluate the function

Parameters
[in]xevaluation point
[out]valuevalue of the function in x

◆ evaluate() [2/2]

template<class Function , template< class > class StoragePolicy = __InstationaryFunction::HoldCopy>
void Dune::Fem::InstationaryFunction< Function, StoragePolicy >::evaluate ( const DomainType x,
typename BaseType::RangeType value 
) const
inline

evaluate the function

Parameters
[in]xevaluation point
[out]valuevalue of the function in x

◆ hessian() [1/2]

void Dune::Fem::Function< FunctionSpace , Function >::hessian ( const DomainType x,
HessianRangeType hessian 
) const
inlineinherited

evaluate the hessian of the function

Parameters
[in]xevaluation point
[out]hessianvalue of the hessian in x

◆ hessian() [2/2]

template<class Function , template< class > class StoragePolicy = __InstationaryFunction::HoldCopy>
void Dune::Fem::InstationaryFunction< Function, StoragePolicy >::hessian ( const DomainType x,
typename BaseType::HessianRangeType hessian 
) const
inline

evaluate the hessian of the function

Parameters
[in]xevaluation point
[out]hessianvalue of the hessian in x

◆ jacobian() [1/2]

void Dune::Fem::Function< FunctionSpace , Function >::jacobian ( const DomainType x,
JacobianRangeType jacobian 
) const
inlineinherited

evaluate the Jacobian of the function

Parameters
[in]xevaluation point
[out]jacobianvalue of the Jacobian in x

◆ jacobian() [2/2]

template<class Function , template< class > class StoragePolicy = __InstationaryFunction::HoldCopy>
void Dune::Fem::InstationaryFunction< Function, StoragePolicy >::jacobian ( const DomainType x,
typename BaseType::JacobianRangeType jacobian 
) const
inline

evaluate the Jacobian of the function

Parameters
[in]xevaluation point
[out]jacobianvalue of the Jacobian in x

◆ operator()() [1/2]

virtual void Dune::Fem::Function< FunctionSpace , Function >::operator() ( const DomainType arg,
RangeType dest 
) const
inlinevirtualinherited

application operator call evaluate

Parameters
[in]argargument
[out]destdestination, i.e. f(arg)

◆ operator()() [2/2]

template<typename DFieldType , typename RFieldType , class DType , class RType >
void Dune::Fem::Mapping< DFieldType, RFieldType, DType, RType >::operator() ( const DomainType arg,
RangeType dest 
) const
inlineinherited

Application operator that applies all operators in the linear combination stack.

Parameters
[in]argargument
[out]destdestination

◆ setTime()

template<class FunctionSpace , class Function >
double Dune::Fem::BasicInstationaryFunction< FunctionSpace, Function >::setTime ( double  time)
inlineinherited

set time to give value

Parameters
[in]timetime to be used
Returns
set time

◆ time()

template<class FunctionSpace , class Function >
double Dune::Fem::BasicInstationaryFunction< FunctionSpace, Function >::time ( ) const
inlineinherited

return set time

Friends And Related Function Documentation

◆ operator*() [1/2]

template<class DFieldType , class RFieldType , class DType , class RType >
static Mapping< DFieldType, RFieldType, DType, RType > operator* ( const Mapping< DFieldType, RFieldType, DType, RType > &  mapping,
const RFieldType &  factor 
)
related

scale mapping with factor

Parameters
[in]mappingMapping which is scaled
[in]factorfactor with which mapping is scaled
Returns
new object mapping

◆ operator*() [2/2]

template<class DFieldType , class RFieldType , class DType , class RType >
static Mapping< DFieldType, RFieldType, DType, RType > operator* ( const RFieldType &  factor,
const Mapping< DFieldType, RFieldType, DType, RType > &  mapping 
)
related

scale mapping with factor

Parameters
[in]factorfactor with which mapping is scaled
[in]mappingMapping which is scaled
Returns
new object mapping

◆ operator+()

template<class DFieldType , class RFieldType , class DType , class RType >
static Mapping< DFieldType, RFieldType, DType, RType > operator+ ( const Mapping< DFieldType, RFieldType, DType, RType > &  a,
const Mapping< DFieldType, RFieldType, DType, RType > &  b 
)
related

add two mappings

Parameters
[in]amapping 1
[in]bmapping 2
Returns
new object mapping

◆ operator-()

template<class DFieldType , class RFieldType , class DType , class RType >
static Mapping< DFieldType, RFieldType, DType, RType > operator- ( const Mapping< DFieldType, RFieldType, DType, RType > &  a,
const Mapping< DFieldType, RFieldType, DType, RType > &  b 
)
related

substract two mappings

Parameters
[in]amapping 1
[in]bmapping 2
Returns
new object mapping

◆ operator/() [1/2]

template<class DFieldType , class RFieldType , class DType , class RType >
static Mapping< DFieldType, RFieldType, DType, RType > operator/ ( const Mapping< DFieldType, RFieldType, DType, RType > &  mapping,
const RFieldType &  factor 
)
related

operator / for mappings

Parameters
[in]mappingmapping which is divided
[in]factorf factor by which result of mapping is divided
Returns
new object mapping

◆ operator/() [2/2]

template<class DFieldType , class RFieldType , class DType , class RType >
static Mapping< DFieldType, RFieldType, DType, RType > operator/ ( const RFieldType &  factor,
const Mapping< DFieldType, RFieldType, DType, RType > &  mapping 
)
related

operator / for mappings

Parameters
[in]factorby which result of mapping is divided
[in]mappingwhich is divided
Returns
new object mapping

The documentation for this class was generated from the following file: