dune-fem 2.8.0
Loading...
Searching...
No Matches
Public Types | Public Member Functions | List of all members
Dune::Fem::CombinedLocalOperator< A, B > Class Template Reference

#include <dune/fem/operator/common/localoperator.hh>

Inheritance diagram for Dune::Fem::CombinedLocalOperator< A, B >:
Inheritance graph

Public Types

typedef A FirstOperatorType
 The type of the operators exported.
 
typedef B SecondOperatorType
 

Public Member Functions

 CombinedLocalOperator (A &a, B &b, bool printMsg=false)
 Constructor for combinations storing the two operators.
 
 ~CombinedLocalOperator ()
 Destructor.
 
template<class ScalarType >
void scaleIt (const ScalarType scalar)
 method to scale the belonging operators
 
template<class FirstParamType , class SecondParamType >
void prepareGlobal (const FirstParamType &pa, SecondParamType &pb)
 prepareGlobal is called before the grid walktrough
 
void finalizeGlobal ()
 finalizeGlobal is called after the grid walktrough
 
template<class EntityType >
void prepareLocal (EntityType &en)
 
template<class EntityType >
void finalizeLocal (EntityType &en)
 
template<class EntityType >
void prepareLocal (EntityType &en1, EntityType &en2)
 
template<class EntityType >
void finalizeLocal (EntityType &en1, EntityType &en2)
 
template<class EntityType >
void applyLocal (EntityType &en)
 
template<class EntityType >
void applyLocal (EntityType &en1, EntityType &en2)
 
template<class DiscrOpType >
void saveObjPointer (DiscrOpType *discrOp)
 Store new generated DiscreteOperator Pointer.
 
template<class DiscrOpType , class LocalOpType >
void saveObjPointer (DiscrOpType *discrOp, LocalOpType *lop)
 

Detailed Description

template<class A, class B>
class Dune::Fem::CombinedLocalOperator< A, B >

This operator combines two local operator in the following way:

\[ Op(a,d) = (A + B)(a,d) \]

whereby B is first applied and then A. The operators A and B have to be defined such that they localy add thier results to a given destination. This workaround can be used directly but the normal way should be to define two discrete operators and then add them which uses intern this class two add the local operators. OP(a,d) = (A + B)(a,d) Note: first B is evaluated, then A

Member Typedef Documentation

◆ FirstOperatorType

template<class A , class B >
typedef A Dune::Fem::CombinedLocalOperator< A, B >::FirstOperatorType

The type of the operators exported.

◆ SecondOperatorType

template<class A , class B >
typedef B Dune::Fem::CombinedLocalOperator< A, B >::SecondOperatorType

Constructor & Destructor Documentation

◆ CombinedLocalOperator()

template<class A , class B >
Dune::Fem::CombinedLocalOperator< A, B >::CombinedLocalOperator ( A &  a,
B &  b,
bool  printMsg = false 
)
inline

Constructor for combinations storing the two operators.

◆ ~CombinedLocalOperator()

template<class A , class B >
Dune::Fem::CombinedLocalOperator< A, B >::~CombinedLocalOperator ( )
inline

Destructor.

Member Function Documentation

◆ applyLocal() [1/2]

template<class A , class B >
template<class EntityType >
void Dune::Fem::CombinedLocalOperator< A, B >::applyLocal ( EntityType &  en)
inline

applyLocal defines the action one might do on a given or on two given entities. Up to now only max two entities may be parameter but this can be advanced. There is also an applyLocal method with no entity which means that also operators which dont need a grid walktrough can be combined.

◆ applyLocal() [2/2]

template<class A , class B >
template<class EntityType >
void Dune::Fem::CombinedLocalOperator< A, B >::applyLocal ( EntityType &  en1,
EntityType &  en2 
)
inline

◆ finalizeGlobal()

template<class A , class B >
void Dune::Fem::CombinedLocalOperator< A, B >::finalizeGlobal
inline

finalizeGlobal is called after the grid walktrough

◆ finalizeLocal() [1/2]

template<class A , class B >
template<class EntityType >
void Dune::Fem::CombinedLocalOperator< A, B >::finalizeLocal ( EntityType &  en)
inline
Todo:
Please doc me!

◆ finalizeLocal() [2/2]

template<class A , class B >
template<class EntityType >
void Dune::Fem::CombinedLocalOperator< A, B >::finalizeLocal ( EntityType &  en1,
EntityType &  en2 
)
inline
Todo:
Please doc me!

◆ prepareGlobal()

template<class A , class B >
template<class FirstParamType , class SecondParamType >
void Dune::Fem::CombinedLocalOperator< A, B >::prepareGlobal ( const FirstParamType &  pa,
SecondParamType &  pb 
)
inline

prepareGlobal is called before the grid walktrough

the parameters of prepareGlobal and finalizeGlobal are set outside via a setParameter method or something

◆ prepareLocal() [1/2]

template<class A , class B >
template<class EntityType >
void Dune::Fem::CombinedLocalOperator< A, B >::prepareLocal ( EntityType &  en)
inline

prepareLocal is called before applyLocal is called, it has different length of parameter list, which are always entities. For example one might give no parameters to prepareLocal or father and son element, depends on grid walktrough outside

◆ prepareLocal() [2/2]

template<class A , class B >
template<class EntityType >
void Dune::Fem::CombinedLocalOperator< A, B >::prepareLocal ( EntityType &  en1,
EntityType &  en2 
)
inline

◆ saveObjPointer() [1/2]

template<class DiscrOpType >
void Dune::Fem::ObjPointerStorage::saveObjPointer ( DiscrOpType *  discrOp)
inlineinherited

Store new generated DiscreteOperator Pointer.

◆ saveObjPointer() [2/2]

template<class DiscrOpType , class LocalOpType >
void Dune::Fem::ObjPointerStorage::saveObjPointer ( DiscrOpType *  discrOp,
LocalOpType *  lop 
)
inlineinherited

Store new generated DiscreteOperator Pointer and the LocalOperator pointer

◆ scaleIt()

template<class A , class B >
template<class ScalarType >
void Dune::Fem::CombinedLocalOperator< A, B >::scaleIt ( const ScalarType  scalar)
inline

method to scale the belonging operators


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