1 #ifndef _RHEOLEF_FIELD_EXPR_H
2 #define _RHEOLEF_FIELD_EXPR_H
44 #include "rheolef/field_expr_recursive.h"
56 template<
class T,
class M>
59 typename std::enable_if<
60 details::is_field_expr_affine_homogeneous<Expr>::value
61 && ! details::is_field_expr_v2_constant <Expr>::value
62 && ! details::is_field <Expr>::value
69 "field = expr; expr should have homogeneous space. HINT: use field = interpolate(Xh, expr)");
70 if (
name() != Xh.name()) {
77 template<
class T,
class M>
78 template<
class Expr,
class Sfinae>
84 _dis_dof_indexes_requires_update(true),
85 _dis_dof_assembly_requires_update(false)
93 template<
class T,
class M>
94 template<
class Expr,
class Sfinae>
101 "field [idx] = expr; expr should have homogeneous space. HINT: use field [idx] = interpolate(Xh, expr)");
102 check_macro (
name() == Xh.name(),
"field [i_comp] = expr : incompatible spaces "
103 <<
name() <<
" and " << Xh.name());
111 template<
class T,
class M>
112 template<
class Expr,
class Sfinae>
118 "field [domain] = expr; expr should have homogeneous space. HINT: use field [domain] = interpolate(Xh, expr)");
119 check_macro (
name() == Xh.name(),
"field [domain] = field_expression : incompatible spaces "
120 <<
name() <<
" and " << Xh.name());
131 #define _RHEOLEF_field_expr_v2_op_assign_field(OP, FUNCTOR) \
132 template<class T, class M, class Expr> \
134 typename std::enable_if< \
135 details::is_field_expr_affine_homogeneous<Expr>::value, \
138 operator OP (field_basic<T,M>& uh, const Expr& expr) \
140 space_basic<T,M> Xh; \
141 check_macro (expr.have_homogeneous_space (Xh), \
142 "field [domain] " << #OP << " expr; expr should have homogeneous space. " \
143 << "HINT: use field [domain] " << #OP << " interpolate(Xh, expr)"); \
144 check_macro (uh.name() == Xh.name(), "field " << #OP << " field_expression : incompatible spaces " \
145 << uh.name() << " and " << Xh.name()); \
146 details::assign_with_operator (uh.begin_dof(), uh.end_dof(), expr.begin_dof(), FUNCTOR()); \
150 #define _RHEOLEF_field_expr_v2_op_assign_auxil(OP, FUNCTOR, NAME, IDX) \
151 template<class T, class M, class Expr> \
153 typename std::enable_if< \
154 details::is_field_expr_affine_homogeneous<Expr>::value, \
157 operator OP (NAME<T,M>&& uh, const Expr& expr) \
159 space_basic<T,M> Xh; \
160 check_macro (expr.have_homogeneous_space (Xh), \
161 "field [" << #IDX << "] " << #OP << " expr; expr should have homogeneous space. " \
162 << "HINT: use field [" << #IDX << "] " << #OP << " interpolate(Xh, expr)"); \
163 check_macro (uh.name() == Xh.name(), "field [" << #IDX << "] " << #OP << " field_expression : incompatible spaces " \
164 << uh.name() << " and " << Xh.name()); \
165 details::assign_with_operator (uh.begin_dof(), uh.end_dof(), expr.begin_dof(), FUNCTOR()); \
169 #define _RHEOLEF_field_expr_v2_op_assign(OP, FUNCTOR) \
170 _RHEOLEF_field_expr_v2_op_assign_field(OP, FUNCTOR) \
171 _RHEOLEF_field_expr_v2_op_assign_auxil(OP, FUNCTOR, field_component, "i_comp") \
172 _RHEOLEF_field_expr_v2_op_assign_auxil(OP, FUNCTOR, field_indirect, "domain")
176 #undef _RHEOLEF_field_expr_v2_op_assign_field
177 #undef _RHEOLEF_field_expr_v2_op_assign_auxil
178 #undef _RHEOLEF_field_expr_v2_op_assign
183 #define _RHEOLEF_field_expr_v2_op_assign_constant_field(OP, FUNCTOR) \
184 template<class T, class M, class Expr> \
186 typename std::enable_if< \
187 details::is_field_expr_v2_constant<Expr>::value \
190 operator OP (field_basic<T,M>& uh, const Expr& expr) \
192 details::assign_with_operator (uh.begin_dof(), uh.end_dof(), details::iterator_on_constant<Expr>(expr), FUNCTOR()); \
196 #define _RHEOLEF_field_expr_v2_op_assign_constant_auxil(OP, FUNCTOR, NAME, IDX) \
197 template<class T, class M, class Expr> \
199 typename std::enable_if< \
200 details::is_field_expr_v2_constant<Expr>::value \
203 operator OP (NAME<T,M>&& uh, const Expr& expr) \
205 details::assign_with_operator (uh.begin_dof(), uh.end_dof(), details::iterator_on_constant<Expr>(expr), FUNCTOR()); \
209 #define _RHEOLEF_field_expr_v2_op_assign_constant(OP, FUNCTOR) \
210 _RHEOLEF_field_expr_v2_op_assign_constant_field(OP, FUNCTOR) \
211 _RHEOLEF_field_expr_v2_op_assign_constant_auxil(OP, FUNCTOR, field_component, "i_comp") \
212 _RHEOLEF_field_expr_v2_op_assign_constant_auxil(OP, FUNCTOR, field_indirect, "domain")
218 #undef _RHEOLEF_field_expr_v2_op_assign_constant_field
219 #undef _RHEOLEF_field_expr_v2_op_assign_constant_auxil
220 #undef _RHEOLEF_field_expr_v2_op_assign_constant
228 template <
class Expr1,
class Expr2>
232 details::is_field_expr_affine_homogeneous<Expr1>::value &&
233 details::is_field_expr_affine_homogeneous<Expr2>::value,
235 typename Expr1::float_type,
236 typename Expr2::float_type>::type
238 dual (
const Expr1& expr1,
const Expr2& expr2)
240 typedef typename Expr1::float_type
T;
241 typedef typename Expr1::memory_type
M;
242 space_basic<T,M>
Xh1,
Xh2;
244 "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)");
246 "dual(expr1,expr2); expr2 should have homogeneous space. HINT: use dual(expr1,interpolate(Xh, expr2))");
248 "dual(expr1,expr2); incompatible \""<<
Xh1.name()<<
"\" and \""<<
Xh2.name()<<
" spaces for expr1 and expr2");
252 template <
class Expr1,
class Expr2>
256 details::is_field_expr_v2_constant <Expr1>::value &&
257 details::is_field_expr_affine_homogeneous<Expr2>::value
258 ,
typename Expr2::float_type
260 dual (
const Expr1& expr1,
const Expr2& expr2)
262 typedef typename Expr2::float_type
T;
263 typedef typename Expr2::memory_type
M;
266 "dual(cte,expr2); expr2 should have homogeneous space. HINT: use dual(cte,interpolate(Xh, expr2))");
270 template <
class Expr1,
class Expr2>
274 details::is_field_expr_affine_homogeneous<Expr1>::value &&
275 details::is_field_expr_v2_constant <Expr2>::value
276 ,
typename Expr1::float_type
278 dual (
const Expr1& expr1,
const Expr2& expr2)
280 typedef typename Expr1::float_type
T;
281 typedef typename Expr1::memory_type
M;
282 space_basic<T,M>
Xh1;
284 "dual(expr1,cte); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),cte)");
294 details::is_field_convertible<Expr>::value
295 && ! details::is_field<Expr>::value
296 ,form_basic <typename Expr::value_type, typename Expr::memory_type>
300 typedef typename Expr::value_type
T;
301 typedef typename Expr::memory_type
M;
307 template <
class Expr>
311 details::is_field_convertible<Expr>::value
312 && ! details::is_field<Expr>::value
318 typedef typename Expr::value_type
T;
319 typedef typename Expr::memory_type
M;
321 return tmp.put (ops);
325 #endif // _RHEOLEF_FIELD_EXPR_H