Rheolef  7.2
an efficient C++ finite element environment
 
Loading...
Searching...
No Matches
field_expr_quadrature.h
Go to the documentation of this file.
1#ifndef _RHEOLEF_FIELD_EXPR_QUADRATURE_H
2#define _RHEOLEF_FIELD_EXPR_QUADRATURE_H
23//
24// variational expressions are integrated by using a quadrature formulae
25//
26// author: Pierre.Saramito@imag.fr
27//
28// date: 16 december 2018
29//
30// SUMMARY:
31// 1. concept
32// 2. terminals
33// 2.1. integration on one element K
34// 2.2. integration on element boundary partial K
35// 3. unary function
36// 2.1. unary node
37// 2.2. unary calls
38// 4. binary operators +- between two integrated fields
39// 3.1. binary node
40// 3.2. binary calls
41// 5. binary operators */ between a integrated field and a constant
42//
43#include "rheolef/field_expr_variational.h"
44#include "rheolef/field_expr_variational_terminal.h"
45#include "rheolef/init_expr_quadrature.h"
46
47namespace rheolef {
48
49// -------------------------------------------------------------------
50// 1. concept
51// -------------------------------------------------------------------
52namespace details {
53
54// Define a trait type for detecting field expression valid arguments
55template<class T> struct is_field_expr_quadrature_arg: std::false_type {};
56
57} // namespace details
58
59// ---------------------------------------------------------------------------
60// 2. terminals
61// ---------------------------------------------------------------------------
62// 2.1. integration on one element K
63// ---------------------------------------------------------------------------
64namespace details {
65
66template<class Expr>
68public:
69// typedefs:
70
72 typedef typename Expr::memory_type memory_type;
73 typedef typename Expr::value_type result_hint;
74 typedef typename Expr::value_type value_type;
78 typedef geo_basic <float_type,memory_type> geo_type;
79 typedef typename Expr::vf_tag_type vf_tag_type;
86
87// allocators:
88
89 template<class Sfinae = typename std::enable_if<is_field_expr_v2_variational_arg<Expr>::value, Expr>::type>
90 field_expr_quadrature_on_element (const Expr& expr);
91
92// mutable modifiers:
93
94 void initialize (const geo_basic<float_type,memory_type>& omega_K, const integrate_option& iopt);
96
97// accessors:
98
99 const space_type& get_vf_space() const { return _expr.get_vf_space(); }
100 size_type n_derivative() const { return _expr.n_derivative(); }
101
102 template<class Value>
103 void evaluate (
105 const geo_element& K,
106 Eigen::Matrix<Value,Eigen::Dynamic,1>& lk) const;
107
108 template<class Value>
109 void valued_check() const {
110 if (! is_undeterminated<Value>::value) { _expr.template valued_check<Value>(); }
111 }
112protected:
113// data:
114 Expr _expr;
116};
117template<class Expr> struct is_field_expr_quadrature_arg <field_expr_quadrature_on_element<Expr> > : std::true_type {};
118
119// ---------------------------------------------------------------------------
120// inlined
121// ---------------------------------------------------------------------------
122template<class Expr>
123template<class Sfinae>
124inline
126 : _expr(expr),
127 _pops()
128{
129}
130template<class Expr>
131void
134 const integrate_option& iopt)
135{
136 integrate_option new_iopt = expr_quadrature_init_iopt (omega_K, get_vf_space(), n_derivative(), iopt);
137 quadrature<float_type> quad = expr_quadrature_init_quad<float_type> (new_iopt);
138 _pops.initialize (omega_K.get_piola_basis(), quad, new_iopt);
139 _expr.initialize (_pops, new_iopt);
140}
141template<class Expr>
142void
145 const integrate_option& iopt)
146{
147 integrate_option new_iopt = expr_quadrature_init_iopt (gh.band(), get_vf_space(), n_derivative(), iopt);
148 quadrature<float_type> quad = expr_quadrature_init_quad<float_type> (new_iopt);
149 _pops.initialize (gh.band().get_piola_basis(), quad, new_iopt);
150 _expr.initialize (gh, _pops, new_iopt);
151}
152template<class Expr>
153template<class Value>
154void
157 const geo_element& K,
158 Eigen::Matrix<Value,Eigen::Dynamic,1>& lk) const
159{
160 Eigen::Matrix<float_type,Eigen::Dynamic,Eigen::Dynamic> phij_xi;
161 const Eigen::Matrix<float_type,Eigen::Dynamic,1>& w = _pops.get_weight (omega_K, K);
162 _expr.evaluate (omega_K, K, phij_xi);
163 // blas2: lk(j) = sum_i phi_j(xi)*w(xi) = trans(phi)*w ; TODO: DVT_EIGEN_BLAS2
164 size_t ni = phij_xi.rows();
165 size_t nj = phij_xi.cols();
166 lk.resize (nj);
167 for (size_t j = 0; j < nj; ++j) {
168 Value sum = 0;
169 for (size_t i = 0; i < ni; ++i) {
170 sum += w[i] * phij_xi(i,j);
171 }
172 lk[j] = sum;
173 }
174}
175
176} // namespace details
177
178// ---------------------------------------------------------------------------
179// 2.2. integration on element boundary partial K
180// ---------------------------------------------------------------------------
181namespace details {
182
183template<class Expr>
185public:
186// typedefs:
187
189 typedef typename Expr::memory_type memory_type;
190 typedef typename Expr::value_type result_hint;
191 typedef typename Expr::value_type value_type;
195 typedef geo_basic <float_type,memory_type> geo_type;
196 typedef typename Expr::vf_tag_type vf_tag_type;
203
204// alocators:
205
206 template<class Sfinae = typename std::enable_if<is_field_expr_v2_variational_arg<Expr>::value, Expr>::type>
207 field_expr_quadrature_on_sides (const Expr& expr);
208
209// accessors:
210
211 const space_type& get_vf_space() const { return _expr.get_vf_space(); }
212 size_type n_derivative() const { return _expr.n_derivative(); }
213
214// mutable modifiers:
215
216 void initialize (const geo_basic<float_type,memory_type>& omega_K, const integrate_option& iopt);
218
219 template<class Value>
220 void evaluate (
222 const geo_element& K,
223 Eigen::Matrix<Value,Eigen::Dynamic,1>& value) const;
224
225 template<class Value>
226 void valued_check() const {
227 typedef Value A1;
228 if (! is_undeterminated<A1>::value) { _expr.template valued_check<A1>(); }
229 }
230protected:
231// data:
232 mutable Expr _expr;
234 mutable bool _ignore_sys_coord;
235// working variables:
236 mutable Eigen::Matrix<float_type,Eigen::Dynamic,Eigen::Dynamic> _value_i;
237 mutable std::vector<size_type> _dis_inod_S;
239};
240template<class Expr> struct is_field_expr_quadrature_arg <field_expr_quadrature_on_sides<Expr> > : std::true_type {};
241
242// ---------------------------------------------------------------------------
243// inlined
244// ---------------------------------------------------------------------------
245template<class Expr>
246template<class Sfinae>
247inline
249 : _expr(expr),
250 _pops(),
251 _ignore_sys_coord(false),
252 _value_i(),
253 _dis_inod_S(),
254 _DF()
255{
256}
257template<class Expr>
258void
260{
261 _ignore_sys_coord = iopt.ignore_sys_coord;
262 integrate_option new_iopt = expr_quadrature_init_iopt (omega_K, get_vf_space(), n_derivative(), iopt);
263 quadrature<float_type> quad = expr_quadrature_init_quad<float_type> (new_iopt);
264 new_iopt._is_inside_on_local_sides = true; // propagated recursively in expression
265 _pops.initialize (omega_K.get_piola_basis(), quad, new_iopt);
266 _expr.initialize (_pops, new_iopt);
267}
268template<class Expr>
269void
271{
272 _ignore_sys_coord = iopt.ignore_sys_coord;
273 integrate_option new_iopt = expr_quadrature_init_iopt (gh.band(), get_vf_space(), n_derivative(), iopt);
274 quadrature<float_type> quad = expr_quadrature_init_quad<float_type> (new_iopt);
275 new_iopt._is_inside_on_local_sides = true; // propagated recursively in expression
276 _pops.initialize (gh.band().get_piola_basis(), quad, new_iopt);
277 _expr.initialize (gh, _pops, new_iopt);
278 fatal_macro("on_local_sides: banded level set not yet supported, sorry");
279}
280template<class Expr>
281template<class Value>
282void
285 const geo_element& K,
286 Eigen::Matrix<Value,Eigen::Dynamic,1>& value) const
287{
288 bool do_local_component_assembly = true;
289 size_type sid_dim = K.dimension()-1;
290 for (size_type isid = 0, nsid = K.n_subgeo(sid_dim); isid < nsid; ++isid) {
291 size_type dis_isid = (K.dimension() == 1) ? K[isid] : (K.dimension() == 2) ? K.edge(isid) : K.face(isid);
292 const geo_element& S = omega_K.dis_get_geo_element (sid_dim, dis_isid);
294 K.get_side_informations (S, sid);
295 _expr.evaluate_on_side (omega_K, K, sid, _value_i, do_local_component_assembly);
296 const Eigen::Matrix<float_type,Eigen::Dynamic,1>& w = _pops.get_weight (omega_K, S);
297 // blas2: lk(j) = sum_S sum_i phi_j(xi)*w(xi) = sum_S trans(phi)*w ; TODO: DVT_EIGEN_BLAS2
298 size_t ni = _value_i.rows();
299 size_t nj = _value_i.cols();
300 if (isid == 0) {
301 value = Eigen::Matrix<Value,Eigen::Dynamic,1>::Zero(nj, 1);
302 }
303 for (size_t j = 0; j < nj; ++j) {
304 Value sum = 0;
305 for (size_t i = 0; i < ni; ++i) {
306 sum += w[i] * _value_i(i,j);
307 }
308 value[j] += sum;
309 }
310 }
311}
312
313} // namespace details
314
316template<class Expr>
317inline
318typename
319std::enable_if<
322>::type
323on_local_sides (const Expr& expr)
324{
326}
327
328#ifdef TODO
329// ---------------------------------------------------------------------------
330// 3. unary function
331// ---------------------------------------------------------------------------
332// 3.1. unary node
333// ---------------------------------------------------------------------------
334namespace details {
335
336template<class UnaryFunction, class Expr>
337class field_expr_quadrature_unary {
338public:
339// typedefs:
340
341 typedef geo_element::size_type size_type;
342 typedef typename Expr::memory_type memory_type;
343 typedef typename details::generic_unary_traits<UnaryFunction>::template result_hint<
344 typename Expr::value_type>::type result_hint;
345 typedef typename details::generic_unary_traits<UnaryFunction>::template hint<
346 typename Expr::value_type
347 ,result_hint>::result_type value_type;
348 typedef typename scalar_traits<value_type>::type scalar_type;
349 typedef typename float_traits<value_type>::type float_type;
350 typedef space_basic<float_type,memory_type> space_type;
351 typedef geo_basic <float_type,memory_type> geo_type;
352 typedef typename Expr::vf_tag_type vf_tag_type;
353 typedef typename details::dual_vf_tag<vf_tag_type>::type
354 vf_dual_tag_type;
355 typedef field_expr_quadrature_unary<UnaryFunction,Expr> self_type;
356 typedef field_expr_quadrature_unary<UnaryFunction, typename Expr::dual_self_type>
357 dual_self_type;
358
359 static const space_constant::valued_type valued_hint = space_constant::valued_tag_traits<value_type>::value;
360
361// alocators:
362
363 template<class Sfinae = typename std::enable_if<is_field_expr_quadrature_arg<Expr>::value, Expr>::type>
364 field_expr_quadrature_unary (const UnaryFunction& f, const Expr& expr)
365 : _f(f), _expr(expr) {}
366
367// accessors:
368
369 const space_type& get_vf_space() const { return _expr.get_vf_space(); }
370 size_type n_derivative() const { return _expr.n_derivative(); }
371
372// mutable modifiers:
373
374 void initialize (const geo_basic<float_type,memory_type>& omega_K, const integrate_option& iopt) {
375 return _expr.initialize (omega_K, iopt); }
376 void initialize (const band_basic<float_type,memory_type>& gh, const integrate_option& iopt) {
377 return _expr.initialize (gh, iopt); }
378
379 template<class Value>
380 void evaluate (const geo_element& K, Eigen::Matrix<Value,Eigen::Dynamic,1>& value) const {
381 typedef Value A1; // Value is float_type in general: elementary matrix
382 _expr.evaluate (K, value);
383 for (size_type i = 0, ni = value.rows(); i < ni; ++i) {
384 for (size_type j = 0, nj = value.cols(); j < nj; ++j) {
385 value(i,j) = _f (value(i,j));
386 }}
387 }
388 template<class Value>
389 void valued_check() const {
390 typedef Value A1;
391 if (! is_undeterminated<A1>::value) { _expr.template valued_check<A1>(); }
392 }
393protected:
394// data:
395 UnaryFunction _f;
396 Expr _expr;
397};
398template<class F, class Expr> struct is_field_expr_quadrature_arg <field_expr_quadrature_unary<F,Expr> > : std::true_type {};
399
400} // namespace details
401// ---------------------------------------------------------------------------
402// 3.2. unary calls
403// ---------------------------------------------------------------------------
404
405#define _RHEOLEF_make_field_expr_quadrature_unary(FUNCTION,FUNCTOR) \
406template<class Expr> \
407inline \
408typename \
409std::enable_if< \
410 details::is_field_expr_quadrature_arg<Expr>::value \
411 ,details::field_expr_quadrature_unary< \
412 FUNCTOR \
413 ,Expr \
414 > \
415>::type \
416FUNCTION (const Expr& expr) \
417{ \
418 return details::field_expr_quadrature_unary <FUNCTOR,Expr> (FUNCTOR(), expr); \
419}
420
421_RHEOLEF_make_field_expr_quadrature_unary (operator+, details::unary_plus)
422_RHEOLEF_make_field_expr_quadrature_unary (operator-, details::negate)
423#undef _RHEOLEF_make_field_expr_quadrature_unary
424
425#endif // TODO
426// ---------------------------------------------------------------------------
427// 4. binary operators +- between two integrated fields
428// ---------------------------------------------------------------------------
429// 4.1. binary node
430// ---------------------------------------------------------------------------
431// example: operator+ between two fields as in
432// (u*v) + on_local_sides(u*v)
433
434namespace details {
435
436template<class BinaryFunction, class Expr1, class Expr2>
438public:
439// typedefs:
440
445 typename Expr1::value_type
446 ,typename Expr2::value_type>::type result_hint;
448 typename Expr1::value_type
449 ,typename Expr2::value_type
450 ,result_hint>::result_type value_type;
454 typedef geo_basic <float_type,memory_type> geo_type;
455 typedef typename details::bf_vf_tag<BinaryFunction,
456 typename Expr1::vf_tag_type,
457 typename Expr2::vf_tag_type>::type vf_tag_type;
461 typedef field_expr_quadrature_binary<BinaryFunction,typename Expr1::dual_self_type,
462 typename Expr2::dual_self_type>
465
466// alocators:
467#ifdef TODO
468 template<class Sfinae
469 = typename std::enable_if<
471 ,Expr1
472 >::type
473 >
474#endif // TODO
475 field_expr_quadrature_binary (const BinaryFunction& f,
476 const Expr1& expr1,
477 const Expr2& expr2)
478 : _f(f), _expr1(expr1), _expr2(expr2) {}
479
480// accessors:
481
482 const space_type& get_vf_space() const { return _expr1.get_vf_space(); }
483 size_type n_derivative() const { return std::min(_expr1.n_derivative(), _expr2.n_derivative()); }
484
485// mutable modifiers:
487 _expr1.initialize (omega_K, iopt);
488 _expr2.initialize (omega_K, iopt);
489 }
491 _expr1.initialize (gh, iopt);
492 _expr2.initialize (gh, iopt);
493 }
494 template<class Value>
495 void evaluate (
497 const geo_element& K,
498 Eigen::Matrix<Value,Eigen::Dynamic,1>& value) const
499 {
500 // Value is float_type in general: elementary matrix
501 // for f=operator+ => sum of two elementary matrix of the same type
502 // TODO: otherwise Value and 2 could be obtained from the hint<> helper
503 typedef Value A1;
504 typedef Value A2;
505 Eigen::Matrix<A2,Eigen::Dynamic,1> value2 (value.size());
506 _expr1.evaluate (omega_K, K, value);
507 _expr2.evaluate (omega_K, K, value2);
508 for (size_type i = 0, ni = value.size(); i < ni; ++i) {
509 value[i] = _f (value[i], value2[i]);
510 }
511 }
512 template<class Value>
513 void valued_check() const {
514 typedef Value A1;
515 typedef Value A2;
516 if (! is_undeterminated<A1>::value) { _expr1.template valued_check<A1>(); }
517 if (! is_undeterminated<A2>::value) { _expr2.template valued_check<A2>(); }
518 }
519protected:
520// data:
521 BinaryFunction _f;
522 Expr1 _expr1;
523 Expr2 _expr2;
524};
525template<class F, class Expr1, class Expr2> struct is_field_expr_quadrature_arg <field_expr_quadrature_binary<F,Expr1,Expr2> > : std::true_type {};
526
527} // namespace details
528
529// ---------------------------------------------------------------------------
530// 4.2. binary calls
531// ---------------------------------------------------------------------------
532// expr_quad := expr_quad +- expr_quad
533// expr_quad := expr_var +- expr_quad
534// expr_quad := expr_quad +- expr_var
535
536#define _RHEOLEF_field_expr_quadrature_binary(FUNCTION,FUNCTOR) \
537template <class Expr1, class Expr2> \
538inline \
539typename \
540std::enable_if< \
541 details::is_field_expr_quadrature_arg <Expr1>::value \
542 && details::is_field_expr_quadrature_arg <Expr2>::value \
543 ,details::field_expr_quadrature_binary< \
544 FUNCTOR \
545 ,Expr1 \
546 ,Expr2 \
547 > \
548>::type \
549FUNCTION (const Expr1& expr1, const Expr2& expr2) \
550{ \
551 return details::field_expr_quadrature_binary \
552 <FUNCTOR, Expr1, Expr2> \
553 (FUNCTOR(), expr1, expr2); \
554} \
555template <class Expr1, class ExprVar2> \
556inline \
557typename \
558std::enable_if< \
559 details::is_field_expr_quadrature_arg <Expr1>::value \
560 && details::is_field_expr_v2_variational_arg <ExprVar2>::value \
561 ,details::field_expr_quadrature_binary< \
562 FUNCTOR \
563 ,Expr1 \
564 ,details::field_expr_quadrature_on_element<ExprVar2> \
565 > \
566>::type \
567FUNCTION (const Expr1& expr1, const ExprVar2& expr_var2) \
568{ \
569 using Expr2 = details::field_expr_quadrature_on_element<ExprVar2>; \
570 return details::field_expr_quadrature_binary \
571 <FUNCTOR, Expr1, Expr2> \
572 (FUNCTOR(), expr1, Expr2(expr_var2)); \
573} \
574template <class ExprVar1, class Expr2> \
575inline \
576typename \
577std::enable_if< \
578 details::is_field_expr_v2_variational_arg <ExprVar1>::value \
579 && details::is_field_expr_quadrature_arg <Expr2>::value \
580 ,details::field_expr_quadrature_binary< \
581 FUNCTOR \
582 ,details::field_expr_quadrature_on_element<ExprVar1> \
583 ,Expr2 \
584 > \
585>::type \
586FUNCTION (const ExprVar1& expr_var1, const Expr2& expr2) \
587{ \
588 using Expr1 = details::field_expr_quadrature_on_element<ExprVar1>; \
589 return details::field_expr_quadrature_binary \
590 <FUNCTOR, Expr1, Expr2> \
591 (FUNCTOR(), Expr1(expr_var1), expr2); \
592} \
593
596
597#undef _RHEOLEF_field_expr_quadrature_binary
598
599// ---------------------------------------------------------------------------
600// 5. binary operators */ between a integrated field and a constant
601// ---------------------------------------------------------------------------
602// expr_quad := k*expr_quad
603// expr_quad := expr_quad*k
604// expr_quad := expr_quad/k
605#ifdef TODO
606
607namespace details {
608
609template<class Expr1, class Expr2, class Sfinae = void>
610struct is_field_expr_quadrature_binary_multiplies_divides_constant_left : std::false_type {};
611
612template<class Expr1, class Expr2>
613struct is_field_expr_quadrature_binary_multiplies_divides_constant_left <
614 Expr1
615 ,Expr2
616 ,typename
617 std::enable_if<
618 is_rheolef_arithmetic <Expr1>::value
619 && is_field_expr_quadrature_arg<Expr2>::value
620 >::type
621>
622: std::true_type
623{};
624
625template<class Expr1, class Expr2>
626struct is_field_expr_quadrature_binary_multiplies_divides_constant_right
627: is_field_expr_quadrature_binary_multiplies_divides_constant_left <Expr2,Expr1> {};
628
629} // namespace details
630
631#define _RHEOLEF_make_field_expr_quadrature_binary_operator_multiplies_divides_constant_left(FUNCTION,FUNCTOR) \
632template<class Expr1, class Expr2> \
633inline \
634typename \
635std::enable_if< \
636 details::is_field_expr_quadrature_binary_multiplies_divides_constant_left <Expr1,Expr2>::value \
637 ,details::field_expr_quadrature_unary< \
638 details::binder_first <FUNCTOR, Expr1> \
639 ,Expr2 /* vf */ \
640 > \
641>::type \
642FUNCTION (const Expr1& expr1, const Expr2& expr2) \
643{ \
644 return details::field_expr_quadrature_unary \
645 <details::binder_first <FUNCTOR,Expr1>, Expr2> \
646 (details::binder_first <FUNCTOR,Expr1> (FUNCTOR(), expr1), expr2); \
647}
648
649#define _RHEOLEF_make_field_expr_quadrature_binary_operator_multiplies_divides_constant_right(FUNCTION,FUNCTOR) \
650template<class Expr1, class Expr2> \
651inline \
652typename \
653std::enable_if< \
654 details::is_field_expr_quadrature_binary_multiplies_divides_constant_right <Expr1,Expr2>::value \
655 ,details::field_expr_quadrature_unary< \
656 details::binder_second <FUNCTOR, Expr2> \
657 ,Expr1 /* vf */ \
658 > \
659>::type \
660FUNCTION (const Expr1& expr1, const Expr2& expr2) \
661{ \
662 return details::field_expr_quadrature_unary \
663 <details::binder_second <FUNCTOR,Expr2>, Expr1> \
664 (details::binder_second <FUNCTOR,Expr2> (FUNCTOR(), expr2), expr1); \
665}
666
667#define _RHEOLEF_make_field_expr_quadrature_binary_operator_multiplies_divides_constant(FUNCTION,FUNCTOR) \
668 _RHEOLEF_make_field_expr_quadrature_binary_operator_multiplies_divides_constant_left (FUNCTION,FUNCTOR) \
669 _RHEOLEF_make_field_expr_quadrature_binary_operator_multiplies_divides_constant_right (FUNCTION,FUNCTOR)
670
671
672_RHEOLEF_make_field_expr_quadrature_binary_operator_multiplies_divides_constant (operator*, details::multiplies)
673_RHEOLEF_make_field_expr_quadrature_binary_operator_multiplies_divides_constant_right (operator/, details::divides)
674
675#undef _RHEOLEF_make_field_expr_quadrature_binary_operator_multiplies_divides_constant_right
676#undef _RHEOLEF_make_field_expr_quadrature_binary_operator_multiplies_divides_constant_left
677#undef _RHEOLEF_make_field_expr_quadrature_binary_operator_multiplies_divides_constant
678
679#endif // TODO
680
681} // namespace rheolef
682#endif // _RHEOLEF_FIELD_EXPR_QUADRATURE_H
field::size_type size_type
Definition branch.cc:430
field gh(Float epsilon, Float t, const field &uh, const test &v)
void initialize(const band_basic< float_type, memory_type > &gh, const integrate_option &iopt)
geo_basic< float_type, memory_type > geo_type
field_expr_quadrature_binary< BinaryFunction, typename Expr1::dual_self_type, typename Expr2::dual_self_type > dual_self_type
space_basic< float_type, memory_type > space_type
details::generic_binary_traits< BinaryFunction >::template result_hint< typenameExpr1::value_type, typenameExpr2::value_type >::type result_hint
void initialize(const geo_basic< float_type, memory_type > &omega_K, const integrate_option &iopt)
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< Value, Eigen::Dynamic, 1 > &value) const
field_expr_quadrature_binary< BinaryFunction, Expr1, Expr2 > self_type
details::bf_vf_tag< BinaryFunction, typenameExpr1::vf_tag_type, typenameExpr2::vf_tag_type >::type vf_tag_type
static const space_constant::valued_type valued_hint
details::dual_vf_tag< vf_tag_type >::type vf_dual_tag_type
field_expr_quadrature_binary(const BinaryFunction &f, const Expr1 &expr1, const Expr2 &expr2)
details::generic_binary_traits< BinaryFunction >::template hint< typenameExpr1::value_type, typenameExpr2::value_type, result_hint >::result_type value_type
promote_memory< typenameExpr1::memory_type, typenameExpr2::memory_type >::type memory_type
space_basic< float_type, memory_type > space_type
void initialize(const geo_basic< float_type, memory_type > &omega_K, const integrate_option &iopt)
field_expr_quadrature_on_element< typename Expr::dual_self_type > dual_self_type
static const space_constant::valued_type valued_hint
details::dual_vf_tag< vf_tag_type >::type vf_dual_tag_type
field_expr_quadrature_on_element< Expr > self_type
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< Value, Eigen::Dynamic, 1 > &lk) const
space_basic< float_type, memory_type > space_type
void initialize(const geo_basic< float_type, memory_type > &omega_K, const integrate_option &iopt)
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< Value, Eigen::Dynamic, 1 > &value) const
static const space_constant::valued_type valued_hint
details::dual_vf_tag< vf_tag_type >::type vf_dual_tag_type
field_expr_quadrature_on_sides< Expr > self_type
Eigen::Matrix< float_type, Eigen::Dynamic, Eigen::Dynamic > _value_i
field_expr_quadrature_on_sides< typename Expr::dual_self_type > dual_self_type
generic mesh with rerefence counting
Definition geo.h:1089
see the geo_element page for the full documentation
size_type edge(size_type i) const
size_type face(size_type i) const
reference_element::size_type size_type
size_type dimension() const
orientation_type get_side_informations(const geo_element &S, size_type &loc_isid, size_type &shift) const
size_type n_subgeo(size_type subgeo_dim) const
see the integrate_option page for the full documentation
the finite element space
Definition space.h:382
#define fatal_macro(message)
Definition dis_macros.h:33
#define _RHEOLEF_field_expr_quadrature_binary(FUNCTION, FUNCTOR)
integrate_option expr_quadrature_init_iopt(const geo_basic< T, M > &omega_K, const space_basic< T, M > &X, size_t n_derivative, const integrate_option &iopt)
This file is part of Rheolef.
bool valued_check() const
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
void evaluate(const geo_basic< float_type, M > &omega_K, const geo_element &K, Eigen::Matrix< Result, Eigen::Dynamic, 1 > &value) const
std::enable_if< details::is_field_expr_v2_variational_arg< Expr >::value, details::field_expr_quadrature_on_sides< Expr > >::type on_local_sides(const Expr &expr)
on_local_sides(expr): see the expression page for the full documentation
STL namespace.
Definition cavity_dg.h:29