Rheolef  7.2
an efficient C++ finite element environment
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 
47 namespace rheolef {
48 
49 // -------------------------------------------------------------------
50 // 1. concept
51 // -------------------------------------------------------------------
52 namespace details {
53 
54 // Define a trait type for detecting field expression valid arguments
55 template<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 // ---------------------------------------------------------------------------
64 namespace details {
65 
66 template<class Expr>
68 public:
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;
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 (
104  const geo_basic<float_type,memory_type>& omega_K,
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  }
112 protected:
113 // data:
114  Expr _expr;
116 };
117 template<class Expr> struct is_field_expr_quadrature_arg <field_expr_quadrature_on_element<Expr> > : std::true_type {};
118 
119 // ---------------------------------------------------------------------------
120 // inlined
121 // ---------------------------------------------------------------------------
122 template<class Expr>
123 template<class Sfinae>
124 inline
126  : _expr(expr),
127  _pops()
128 {
129 }
130 template<class Expr>
131 void
133  const geo_basic<float_type,memory_type>& omega_K,
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 }
141 template<class Expr>
142 void
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 }
152 template<class Expr>
153 template<class Value>
154 void
156  const geo_basic<float_type,memory_type>& omega_K,
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 // ---------------------------------------------------------------------------
181 namespace details {
182 
183 template<class Expr>
185 public:
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;
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 (
221  const geo_basic<float_type,memory_type>& omega_K,
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  }
230 protected:
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 };
240 template<class Expr> struct is_field_expr_quadrature_arg <field_expr_quadrature_on_sides<Expr> > : std::true_type {};
241 
242 // ---------------------------------------------------------------------------
243 // inlined
244 // ---------------------------------------------------------------------------
245 template<class Expr>
246 template<class Sfinae>
247 inline
249  : _expr(expr),
250  _pops(),
251  _ignore_sys_coord(false),
252  _value_i(),
253  _dis_inod_S(),
254  _DF()
255 {
256 }
257 template<class Expr>
258 void
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 }
268 template<class Expr>
269 void
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 }
280 template<class Expr>
281 template<class Value>
282 void
284  const geo_basic<float_type,memory_type>& omega_K,
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 
316 template<class Expr>
317 inline
318 typename
319 std::enable_if<
322 >::type
323 on_local_sides (const Expr& expr)
324 {
326 }
327 
328 #ifdef TODO
329 // ---------------------------------------------------------------------------
330 // 3. unary function
331 // ---------------------------------------------------------------------------
332 // 3.1. unary node
333 // ---------------------------------------------------------------------------
334 namespace details {
335 
336 template<class UnaryFunction, class Expr>
337 class field_expr_quadrature_unary {
338 public:
339 // typedefs:
340 
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;
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;
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 
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  }
393 protected:
394 // data:
395  UnaryFunction _f;
396  Expr _expr;
397 };
398 template<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) \
406 template<class Expr> \
407 inline \
408 typename \
409 std::enable_if< \
410  details::is_field_expr_quadrature_arg<Expr>::value \
411  ,details::field_expr_quadrature_unary< \
412  FUNCTOR \
413  ,Expr \
414  > \
415 >::type \
416 FUNCTION (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 
434 namespace details {
435 
436 template<class BinaryFunction, class Expr1, class Expr2>
438 public:
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
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
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:
486  void initialize (const geo_basic<float_type,memory_type>& omega_K, const integrate_option& iopt) {
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 (
496  const geo_basic<float_type,memory_type>& omega_K,
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  }
519 protected:
520 // data:
523  Expr2 _expr2;
524 };
525 template<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) \
537 template <class Expr1, class Expr2> \
538 inline \
539 typename \
540 std::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 \
549 FUNCTION (const Expr1& expr1, const Expr2& expr2) \
550 { \
551  return details::field_expr_quadrature_binary \
552  <FUNCTOR, Expr1, Expr2> \
553  (FUNCTOR(), expr1, expr2); \
554 } \
555 template <class Expr1, class ExprVar2> \
556 inline \
557 typename \
558 std::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 \
567 FUNCTION (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 } \
574 template <class ExprVar1, class Expr2> \
575 inline \
576 typename \
577 std::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 \
586 FUNCTION (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 
607 namespace details {
608 
609 template<class Expr1, class Expr2, class Sfinae = void>
610 struct is_field_expr_quadrature_binary_multiplies_divides_constant_left : std::false_type {};
611 
612 template<class Expr1, class Expr2>
613 struct 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 
625 template<class Expr1, class Expr2>
626 struct 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) \
632 template<class Expr1, class Expr2> \
633 inline \
634 typename \
635 std::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 \
642 FUNCTION (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) \
650 template<class Expr1, class Expr2> \
651 inline \
652 typename \
653 std::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 \
660 FUNCTION (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)
details::generic_binary_traits< BinaryFunction >::template result_hint< typename Expr1::value_type,typename Expr2::value_type >::type result_hint
void initialize(const band_basic< float_type, memory_type > &gh, const integrate_option &iopt)
geo_basic< float_type, memory_type > geo_type
promote_memory< typename Expr1::memory_type, typename Expr2::memory_type >::type memory_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 hint< typename Expr1::value_type,typename Expr2::value_type,result_hint >::result_type value_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
field_expr_quadrature_binary< BinaryFunction, Expr1, Expr2 > self_type
details::bf_vf_tag< BinaryFunction, typename Expr1::vf_tag_type, typename Expr2::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)
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
geo_basic< float_type, memory_type > geo_type
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
see the geo_element page for the full documentation
Definition: geo_element.h:102
size_type edge(size_type i) const
Definition: geo_element.h:209
size_type face(size_type i) const
Definition: geo_element.h:210
reference_element::size_type size_type
Definition: geo_element.h:125
size_type dimension() const
Definition: geo_element.h:167
orientation_type get_side_informations(const geo_element &S, size_type &loc_isid, size_type &shift) const
Definition: geo_element.cc:185
size_type n_subgeo(size_type subgeo_dim) const
Definition: geo_element.h:212
see the integrate_option page for the full documentation
typename scalar_traits< value_type >::type scalar_type
typename float_traits< value_type >::type float_type
typename Expr1::memory_type memory_type
rheolef::std type
size_t size_type
Definition: basis_get.cc:76
typename details::generic_binary_traits< BinaryFunction >::template result_hint< typename Expr1::result_type, typename Expr2::result_type >::type result_type
static const space_constant::valued_type valued_hint
rheolef::std BinaryFunction
rheolef::std value
BinaryFunction _f
result_type value_type
rheolef::std Expr1
dot(x,y): see the expression page for the full documentation
#define fatal_macro(message)
Definition: dis_macros.h:33
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.
void initialize(const piola_on_pointset< float_type > &pops, const integrate_option &iopt)
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
bool valued_check() const
void evaluate(const geo_basic< float_type, M > &omega_K, const geo_element &K, Eigen::Matrix< Result, Eigen::Dynamic, 1 > &value) const
_RHEOLEF_field_expr_quadrature_binary(operator+, details::plus) _RHEOLEF_field_expr_quadrature_binary(operator-
Definition: cavity_dg.h:29