LocalFunctionAdapter wrapped a class with a local evaluate method into a grid function. More...

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

Inheritance diagram for Dune::Fem::LocalFunctionAdapter< LocalFunctionImpl >:

Classes
struct	ArgumentIF

struct	ArgumentInitializer

Public Types
typedef ThisType	DiscreteFunctionType

typedef LocalFunctionImpl	LocalFunctionImplType
	Evaluate class.

typedef BaseType::FunctionType	FunctionType
	type of function

typedef LocalFunctionAdapterTraits< LocalFunctionImplType >	Traits
	traits class

typedef Traits::GridPartType	GridPartType
	type of grid part

typedef Traits::DiscreteFunctionSpaceType	DiscreteFunctionSpaceType
	type of discrete function space

typedef Traits::GridType	GridType
	type of grid

typedef Traits::DomainFieldType	DomainFieldType
	domain type

typedef Traits::RangeFieldType	RangeFieldType
	range type

typedef Traits::DomainType	DomainType
	domain type

typedef Traits::RangeType	RangeType
	range type

typedef Traits::JacobianRangeType	JacobianRangeType
	jacobian type

typedef Traits::EntityType	EntityType
	type of codim 0 entity

typedef Traits::LocalFunctionType	LocalFunctionType
	type of local function to export

typedef LocalFunctionImpl::FunctionSpaceType	FunctionSpaceType
	type of function space this function belongs to

typedef FunctionSpaceType::HessianRangeType	HessianRangeType
	hessian type

typedef Mapping< DomainFieldType, RangeFieldType, DomainType, RangeType >	MappingType
	type of mapping base class

Public Member Functions
	LocalFunctionAdapter (const std::string &name, LocalFunctionImplType &localFunctionImpl, const GridPartType &gridPart, unsigned int order=DiscreteFunctionSpaceType::polynomialOrder)

	LocalFunctionAdapter (const std::string &name, const LocalFunctionImplType &localFunctionImpl, const GridPartType &gridPart, unsigned int order=DiscreteFunctionSpaceType::polynomialOrder)
	constructor taking a const reference instance of the local function class

	LocalFunctionAdapter (const std::string &name, LocalFunctionImplType &&localFunctionImpl, const GridPartType &gridPart, unsigned int order=DiscreteFunctionSpaceType::polynomialOrder)
	constructor taking a r-value reference instance of the local function class

template<class ... Args>
	LocalFunctionAdapter (const std::string &name, const GridPartType &gridPart, unsigned int order, Args &... args)

template<class ... Args>
	LocalFunctionAdapter (const std::string &name, const GridPartType &gridPart, const std::tuple< Args &... > &args, unsigned int order=DiscreteFunctionSpaceType::polynomialOrder)

	LocalFunctionAdapter (const ThisType &other)

unsigned int	order () const
	return the order of the space

bool	continuous () const
	return true, probably

const LocalFuncStorageType &	localFunctionImpl () const
	return local function implementation

LocalFuncStorageType &	localFunctionImpl ()
	return local function implementation

void	evaluate (const DomainType &global, RangeType &result) const
	evaluate function on local coordinate local

LocalFunctionType	localFunction (const EntityType &entity)

const LocalFunctionType	localFunction (const EntityType &entity) const

const std::string &	name () const
	obtain the name of the discrete function

const DiscreteFunctionSpaceType &	space () const

const GridPartType &	gridPart () const

template<class DFType >
DiscreteFunctionType &	operator+= (const DFType &g)

template<class DFType >
DiscreteFunctionType &	operator-= (const DFType &g)
	substract all degrees of freedom from given discrete function using the dof iterators

DiscreteFunctionType &	operator*= (const RangeFieldType &scalar)
	multiply all DoFs with a scalar factor

DiscreteFunctionType &	operator/= (const RangeFieldType &scalar)
	devide all DoFs by a scalar factor

template<class ArgumentType >
void	initialize (const ArgumentType &arg, double time)
	initialize local function with argument and time

void	registerLocalFunction (LocalFunctionType *lf) const
	add LocalFunction to list of local functions

void	deleteLocalFunction (LocalFunctionType *lf) const
	remove LocalFunction to list of local 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	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

Protected Types
typedef Traits::LocalFuncStorageType	LocalFuncStorageType

Protected Member Functions
template<class ... Args, std::size_t ... index>
	LocalFunctionAdapter (const std::string &name, const GridPartType &gridPart, const std::tuple< Args &... > &args, unsigned int order, std::index_sequence< index... >)

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)

Protected Attributes
DiscreteFunctionSpaceType	space_

LocalFuncStorageType	localFunctionImpl_

std::set< LocalFunctionType * >	lfList_

std::unique_ptr< ArgumentIF >	argInitializer_

const std::string	name_

const unsigned int	order_

Friends
class	LocalFunctionAdapterLocalFunction< LocalFunctionImpl >

Related Symbols
(Note that these are not member symbols.)
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 LocalFunctionImpl>
class Dune::Fem::LocalFunctionAdapter< LocalFunctionImpl >

LocalFunctionAdapter wrapped a class with a local evaluate method into a grid function.

The class takes one template argument LocalFunctionImpl which holds the method evaluate(...) to evaluate the local function

template<class PointType> LocalFunctionImpl::evaluate(const PointType& x,RangeType& val)

and a method init(...)

LocalFunctionImpl::init(const EntityType& entity)

to set the entity.

It is important to know that the point x it is not necessary of type DomainType. More precisely, if the evaluate(...) is used with a caching quadrature point the type is different. Indeed floating point coordinates are not very well suited to address the cache therefore quadrature[i] return a QuadraturePointWrapper (which simply stores a reference to the quadrature and the index i).

In order to be sure that the point x is of type DomainType, you can use the function coordinate(x) which can be also called with a DomainType.

Therefore, the local implementation should be something like

template<class PointType> LocalFunctionImpl::evaluate(const PointType& x,RangeType& val) { const DomainType xDomain(coordiante(x)); // do stuff with xDomain }

to avoid type conflicts.

Required type in LocalFunctionImpl are:

FunctionSpaceType GridPartType EntityType DomainType RangeType

An instance of the LocalFunctionImpl class is passed to the constructor.

In order to adapt a lambda or a plain C++ function, you can directly use the LocalAnalyticalFunctionBinder which provides all the necessary types and methods.

Member Typedef Documentation

◆ FunctionSpaceType

typedef LocalFunctionImpl::FunctionSpaceType Dune::Fem::Function< LocalFunctionImpl::FunctionSpaceType , LocalFunctionAdapter< LocalFunctionImpl > >::FunctionSpaceType

inherited

type of function space this function belongs to

◆ HessianRangeType

typedef FunctionSpaceType::HessianRangeType Dune::Fem::Function< LocalFunctionImpl::FunctionSpaceType , LocalFunctionAdapter< LocalFunctionImpl > >::HessianRangeType

inherited

hessian type

◆ MappingType

typedef Mapping< DomainFieldType, RangeFieldType, DomainType, RangeType > Dune::Fem::Function< LocalFunctionImpl::FunctionSpaceType , LocalFunctionAdapter< LocalFunctionImpl > >::MappingType

inherited

type of mapping base class

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

◆ hessian()

void Dune::Fem::Function< LocalFunctionImpl::FunctionSpaceType , LocalFunctionAdapter< LocalFunctionImpl > >::hessian	(	const DomainType &	x,
		HessianRangeType &	hessian
	)		const

inlineinherited

evaluate the hessian of the function

Parameters

[in]	x	evaluation point
[out]	hessian	value of the hessian in x

◆ jacobian()

void Dune::Fem::Function< LocalFunctionImpl::FunctionSpaceType , LocalFunctionAdapter< LocalFunctionImpl > >::jacobian	(	const DomainType &	x,
		JacobianRangeType &	jacobian
	)		const

inlineinherited

evaluate the Jacobian of the function

Parameters

[in]	x	evaluation point
[out]	jacobian	value of the Jacobian in x

◆ operator()() [1/2]

virtual void Dune::Fem::Function< LocalFunctionImpl::FunctionSpaceType , LocalFunctionAdapter< LocalFunctionImpl > >::operator()	(	const DomainType &	arg,
		RangeType &	dest
	)		const

inlinevirtualinherited

application operator call evaluate

Parameters

[in]	arg	argument
[out]	dest	destination, 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]	arg	argument
[out]	dest	destination