Rheolef  7.1
an efficient C++ finite element environment
field_expr.h File Reference

Go to the source code of this file.

Classes

class  std
 

Namespaces

 rheolef
 This file is part of Rheolef.
 

Macros

#define _RHEOLEF_field_expr_v2_op_assign_field(OP, FUNCTOR)
 
#define _RHEOLEF_field_expr_v2_op_assign_auxil(OP, FUNCTOR, NAME, IDX)
 
#define _RHEOLEF_field_expr_v2_op_assign(OP, FUNCTOR)
 
#define _RHEOLEF_field_expr_v2_op_assign_constant_field(OP, FUNCTOR)
 
#define _RHEOLEF_field_expr_v2_op_assign_constant_auxil(OP, FUNCTOR, NAME, IDX)
 
#define _RHEOLEF_field_expr_v2_op_assign_constant(OP, FUNCTOR)
 

Typedefs

typedef Expr1::float_type T
 
typedef Expr1::memory_type M
 

Functions

 _RHEOLEF_field_expr_v2_op_assign (+=, details::plus_assign) _RHEOLEF_field_expr_v2_op_assign(-
 
 _RHEOLEF_field_expr_v2_op_assign_constant (+=, details::plus_assign) _RHEOLEF_field_expr_v2_op_assign_constant(-
 
details::minus_assign _RHEOLEF_field_expr_v2_op_assign_constant details::multiplies_assign _RHEOLEF_field_expr_v2_op_assign_constant (/=, details::divides_assign) template< class Expr1
 
rheolef::std enable_if ::type dual const Expr1 expr1, const Expr2 expr2 dual (const Expr1 &expr1, const Expr2 &expr2)
 
 check_macro (expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
 
 check_macro (expr2.have_homogeneous_space(Xh2), "dual(expr1,expr2); expr2 should have homogeneous space. HINT: use dual(expr1,interpolate(Xh, expr2))")
 
 check_macro (Xh1.name()==Xh2.name(), "dual(expr1,expr2); incompatible \""<< Xh1.name()<<"\" and \""<< Xh2.name()<<" spaces for expr1 and expr2")
 
return dis_inner_product (expr1.begin_dof(), expr2.begin_dof(), Xh1.ndof(), Xh1.ownership().comm(), M())
 
template<class Expr >
std::enable_if< details::is_field_convertible< Expr >::value &&! details::is_field< Expr >::value,form_basic< typename Expr::value_type, typename Expr::memory_type >>::type diag (const Expr &expr)
 
template<class Expr >
std::enable_if< details::is_field_convertible< Expr >::value &&! details::is_field< Expr >::value,odiststream & >::type operator<< (odiststream &ops, const Expr &expr)
 

Variables

space_basic< T, MXh1
 
space_basic< T, MXh2
 

Macro Definition Documentation

◆ _RHEOLEF_field_expr_v2_op_assign_field

#define _RHEOLEF_field_expr_v2_op_assign_field (   OP,
  FUNCTOR 
)
Value:
template<class T, class M, class Expr> \
inline \
typename std::enable_if< \
details::is_field_expr_affine_homogeneous<Expr>::value, \
field_basic<T,M>& \
>::type \
operator OP (field_basic<T,M>& uh, const Expr& expr) \
{ \
space_basic<T,M> Xh; \
check_macro (expr.have_homogeneous_space (Xh), \
"field [domain] " << #OP << " expr; expr should have homogeneous space. " \
<< "HINT: use field [domain] " << #OP << " interpolate(Xh, expr)"); \
check_macro (uh.name() == Xh.name(), "field " << #OP << " field_expression : incompatible spaces " \
<< uh.name() << " and " << Xh.name()); \
details::assign_with_operator (uh.begin_dof(), uh.end_dof(), expr.begin_dof(), FUNCTOR()); \
return uh; \
}
void assign_with_operator(ForwardIterator first, ForwardIterator last, InputIterator iter_rhs, OpAssign op_assign)

Definition at line 131 of file field_expr.h.

◆ _RHEOLEF_field_expr_v2_op_assign_auxil

#define _RHEOLEF_field_expr_v2_op_assign_auxil (   OP,
  FUNCTOR,
  NAME,
  IDX 
)
Value:
template<class T, class M, class Expr> \
inline \
typename std::enable_if< \
details::is_field_expr_affine_homogeneous<Expr>::value, \
NAME<T,M>& \
>::type \
operator OP (NAME<T,M>&& uh, const Expr& expr) \
{ \
space_basic<T,M> Xh; \
check_macro (expr.have_homogeneous_space (Xh), \
"field [" << #IDX << "] " << #OP << " expr; expr should have homogeneous space. " \
<< "HINT: use field [" << #IDX << "] " << #OP << " interpolate(Xh, expr)"); \
check_macro (uh.name() == Xh.name(), "field [" << #IDX << "] " << #OP << " field_expression : incompatible spaces " \
<< uh.name() << " and " << Xh.name()); \
details::assign_with_operator (uh.begin_dof(), uh.end_dof(), expr.begin_dof(), FUNCTOR()); \
return uh; \
}

Definition at line 150 of file field_expr.h.

◆ _RHEOLEF_field_expr_v2_op_assign

#define _RHEOLEF_field_expr_v2_op_assign (   OP,
  FUNCTOR 
)
Value:
_RHEOLEF_field_expr_v2_op_assign_auxil(OP, FUNCTOR, field_component, "i_comp") \
_RHEOLEF_field_expr_v2_op_assign_auxil(OP, FUNCTOR, field_indirect, "domain")
#define _RHEOLEF_field_expr_v2_op_assign_field(OP, FUNCTOR)
Definition: field_expr.h:131

Definition at line 169 of file field_expr.h.

◆ _RHEOLEF_field_expr_v2_op_assign_constant_field

#define _RHEOLEF_field_expr_v2_op_assign_constant_field (   OP,
  FUNCTOR 
)
Value:
template<class T, class M, class Expr> \
inline \
typename std::enable_if< \
details::is_field_expr_v2_constant<Expr>::value \
,field_basic<T,M>& \
>::type \
operator OP (field_basic<T,M>& uh, const Expr& expr) \
{ \
details::assign_with_operator (uh.begin_dof(), uh.end_dof(), details::iterator_on_constant<Expr>(expr), FUNCTOR()); \
return uh; \
}

Definition at line 183 of file field_expr.h.

◆ _RHEOLEF_field_expr_v2_op_assign_constant_auxil

#define _RHEOLEF_field_expr_v2_op_assign_constant_auxil (   OP,
  FUNCTOR,
  NAME,
  IDX 
)
Value:
template<class T, class M, class Expr> \
inline \
typename std::enable_if< \
details::is_field_expr_v2_constant<Expr>::value \
,NAME<T,M>& \
>::type \
operator OP (NAME<T,M>&& uh, const Expr& expr) \
{ \
details::assign_with_operator (uh.begin_dof(), uh.end_dof(), details::iterator_on_constant<Expr>(expr), FUNCTOR()); \
return uh; \
}

Definition at line 196 of file field_expr.h.

◆ _RHEOLEF_field_expr_v2_op_assign_constant

#define _RHEOLEF_field_expr_v2_op_assign_constant (   OP,
  FUNCTOR 
)
Value:
_RHEOLEF_field_expr_v2_op_assign_constant_auxil(OP, FUNCTOR, field_component, "i_comp") \
_RHEOLEF_field_expr_v2_op_assign_constant_auxil(OP, FUNCTOR, field_indirect, "domain")
#define _RHEOLEF_field_expr_v2_op_assign_constant_field(OP, FUNCTOR)
Definition: field_expr.h:183

Definition at line 209 of file field_expr.h.

Typedef Documentation

◆ T

typedef Expr1::float_type T

Definition at line 261 of file field_expr.h.

◆ M

typedef Expr1::memory_type M

Definition at line 262 of file field_expr.h.

Function Documentation

◆ check_macro() [1/3]

dual::check_macro ( expr1.  have_homogeneous_spaceXh1,
"dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)"   
)

◆ check_macro() [2/3]

dual::check_macro ( expr2.  have_homogeneous_spaceXh2,
"dual(expr1,expr2); expr2 should have homogeneous space. HINT: use dual(expr1,interpolate(Xh, expr2))"   
)

◆ check_macro() [3/3]

dual::check_macro ( Xh1.  name() = =Xh2.name(),
"dual(expr1,expr2); incompatible \""<< Xh1.name()<<"\" and \""<< Xh2.name()<<" spaces for expr1 and expr2"   
)

◆ dis_inner_product()

return dual::dis_inner_product ( expr1.  begin_dof(),
expr2.  begin_dof(),
Xh1.  ndof(),
Xh1.  ownership).comm(,
M()   
)

Variable Documentation

◆ Xh1

space_basic<T,M> Xh1

Definition at line 263 of file field_expr.h.

◆ Xh2

space_basic<T,M> Xh2

Definition at line 263 of file field_expr.h.