Rheolef  7.1
an efficient C++ finite element environment
test_component.h
Go to the documentation of this file.
1 #ifndef _RHEOLEF_TEST_COMPONENT_H
2 #define _RHEOLEF_TEST_COMPONENT_H
3 // test[i] : indexation for test and trial functions
24 //
25 #include "rheolef/test.h"
26 
27 namespace rheolef { namespace details {
28 
29 // =========================================================================
30 // field_component
31 // =========================================================================
32 template <class T, class M, class VfTag>
34 public:
35 
36 // typename:
37 
39  typedef typename test_type::size_type size_type;
41  typedef M memory_type;
46 
47 // allocators:
48 
53 
54 // accessors:
55 
56  const space_type& get_vf_space() const { return _u.get_vf_space(); }
58  space_constant::valued_type valued_tag() const { return _u_comp.get_vf_space().valued_tag(); }
59 
60 // initializers:
61 
62  void initialize (
63  const piola_on_pointset<T>& pops,
64  const integrate_option& iopt) const
65  { _u_comp.initialize (pops, iopt); }
66  void initialize (
68  const piola_on_pointset<T>& pops,
69  const integrate_option& iopt) const
70  { _u_comp.initialize (gh, pops, iopt); _is_on_band = true; }
71  void initialize (
73  const integrate_option& iopt) const
74  { _u_comp.initialize (Xh, iopt); }
75 
76 // evaluators:
77 
78  template<class Value, details::differentiate_option::type Diff>
79  void evaluate (
80  const geo_basic<float_type,memory_type>& omega_K,
81  const geo_element& K,
83  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const;
84 
85  template<class Value, details::differentiate_option::type Diff>
86  void evaluate_on_side (
87  const geo_basic<float_type,memory_type>& omega_K,
88  const geo_element& K,
89  const side_information_type& sid,
91  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value,
92  bool do_local_component_assembly) const;
93 
94  template<class Value>
96  const geo_basic<T,M>& omega_K,
97  const geo_element& S,
98  const geo_element& K0,
99  const geo_element& K1,
100  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value0,
101  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value1,
102  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const;
103 
104 // checks:
105 
106  template<class ValueType>
107  void valued_check() const {
109  check_macro (_u_comp.valued_tag() == valued_tag, "unexpected "<<_u_comp.get_vf_space().valued()
110  << "-valued field while a " << space_constant::valued_name(valued_tag)
111  << "-valued one is expected in expression");
112  }
113  template<class ValueType>
114  void grad_valued_check() const {
115  typedef typename space_constant::rank_down<ValueType>::type A1;
117  check_macro (_u_comp.valued_tag() == arg_valued_tag, "grad(): unexpected "<<_u_comp.get_vf_space().valued()
118  << "-valued field while a " << space_constant::valued_name(arg_valued_tag)
119  << "-valued one is expected in expression");
120  }
121  template<class ValueType>
122  void div_valued_check() const {
123  typedef typename space_constant::rank_up<ValueType>::type A1;
125  check_macro (_u_comp.valued_tag() == arg_valued_tag, "div(): unexpected "<<_u_comp.get_vf_space().valued()
126  << "-valued field while a " << space_constant::valued_name(arg_valued_tag)
127  << "-valued one is expected in expression");
128  }
129 
130 protected:
131 // internals:
132  static space_type _init_space_comp(const space_type& Xh, size_type i_comp);
133  void _initialize_numbering (
134  const geo_basic<float_type,memory_type>& omega_K,
135  const geo_element& K) const;
136  template<class Value>
137  void _evaluate_continued (
138  const geo_basic<float_type,memory_type>& omega_K,
139  const geo_element& K,
140  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value_comp,
141  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const;
142  template<class Value>
144  const geo_basic<float_type,memory_type>& omega_K,
145  const geo_element& K,
146  const side_information_type& sid,
147  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value_comp,
148  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const;
149 
150 // data:
152  test_basic<T,M,VfTag> _u, _u_comp; // top-level and curent-level test-function u[i0][i1]...[iN]
154  bool _has_subcomponent() const { return _ptr_u_comp_upper_data.operator->() != 0; }
156  // upper-level test-function u[i0]...[i(N-1)] when N>1
157  // note: clang++ cannot manage directly test_component<..> that has incomplete type
158  // but g++ can, so fall back to smart_pointer for clang++...
159  mutable std::array<size_type,reference_element::max_variant> // lazy initialization, on the fly
163  mutable bool _is_on_band;
164 };
165 // -------------------------------------------------------------------------
166 // inlined
167 // -------------------------------------------------------------------------
168 template <class T, class M, class VfTag>
170 : _i_comp (x._i_comp),
171  _u (x._u),
172  _u_comp (x._u_comp),
173  _ptr_u_comp_upper_data (x._ptr_u_comp_upper_data),
174  _loc_ndof (x._loc_ndof),
175  _first_loc_idof (x._first_loc_idof),
176  _last_loc_idof (x._last_loc_idof),
177  _is_on_band (x._is_on_band)
178 {
179  trace_macro ("** PHYSICAL COPY OF TEST_COMPONENT **");
180 }
181 template <class T, class M, class VfTag>
184 {
185  trace_macro ("** PHYSICAL ASSIGN OF TEST_COMPONENT **");
186  _i_comp = x._i_comp;
187  _u = x._u;
188  _u_comp = x._u_comp;
189  _ptr_u_comp_upper_data = x._ptr_u_comp_upper_data;
190  _loc_ndof = x._loc_ndof;
191  _first_loc_idof = x._first_loc_idof;
192  _last_loc_idof = x._last_loc_idof;
193  _is_on_band = x._is_on_band;
194  return *this;
195 }
196 template <class T, class M, class VfTag>
198  : _i_comp(i_comp),
199  _u(u),
200  _u_comp (_init_space_comp(u.get_vf_space(),i_comp)),
201  _ptr_u_comp_upper_data(),
202  _loc_ndof(),
203  _first_loc_idof(),
204  _last_loc_idof(),
205  _is_on_band(false)
206 {
207  _first_loc_idof.fill (std::numeric_limits<size_type>::max());
208 }
209 template <class T, class M, class VfTag>
211  : _i_comp(i_subcomp),
212  _u(u_comp_upper.data()._u),
213  _u_comp (_init_space_comp(u_comp_upper.data()._u_comp.get_vf_space(),i_subcomp)),
214  _ptr_u_comp_upper_data(u_comp_upper),
215  _loc_ndof(),
216  _first_loc_idof(),
217  _last_loc_idof(),
218  _is_on_band(false)
219 {
220  _first_loc_idof.fill (std::numeric_limits<size_type>::max());
221 }
222 template <class T, class M, class VfTag>
225 {
226  check_macro (i_comp < Xh.size(), "test component index "<<i_comp<<" is out of range [0:"<<Xh.size()<<"[");
227  space_basic<T,M> Xh_comp = Xh[i_comp];
228  return Xh_comp;
229 }
230 template <class T, class M, class VfTag>
231 void
233  const geo_basic<float_type,memory_type>& omega_K,
234  const geo_element& K) const
235 {
236  size_type variant = K.variant();
237  if (_has_subcomponent()) {
238  const space_type& Xh_upper = get_u_comp_upper_data()._u_comp.get_vf_space();
239  get_u_comp_upper_data()._initialize_numbering (omega_K, K); // recursive call
240  _loc_ndof[variant] = get_u_comp_upper_data()._loc_ndof [variant];
241  _first_loc_idof[variant] = get_u_comp_upper_data()._first_loc_idof[variant];
242  for (size_type j_comp = 0; j_comp < _i_comp; ++j_comp) {
243  size_type loc_jcomp_ndof = Xh_upper.get_constitution()[j_comp].assembly_loc_ndof (omega_K, K);
244  _first_loc_idof[variant] += loc_jcomp_ndof;
245  }
246  size_type loc_icomp_ndof = Xh_upper.get_constitution()[_i_comp].assembly_loc_ndof (omega_K, K);
247  _last_loc_idof[variant] = _first_loc_idof[variant] + loc_icomp_ndof;
248  } else {
249  const space_type& Xh_upper = _u.get_vf_space();
250  _loc_ndof[variant] = _u.get_vf_space().get_constitution().assembly_loc_ndof (omega_K, K);
251  _first_loc_idof[variant] = 0;
252  for (size_type j_comp = 0; j_comp < _i_comp; ++j_comp) {
253  size_type loc_jcomp_ndof = Xh_upper.get_constitution()[j_comp].assembly_loc_ndof (omega_K, K);
254  _first_loc_idof[variant] += loc_jcomp_ndof;
255  }
256  size_type loc_icomp_ndof = 0;
257  loc_icomp_ndof = Xh_upper.get_constitution()[_i_comp].assembly_loc_ndof (omega_K, K);
258  _last_loc_idof[variant] = _first_loc_idof[variant] + loc_icomp_ndof;
259  }
260 }
261 template <class T, class M, class VfTag>
262 template<class Value, details::differentiate_option::type Diff>
263 void
265  const geo_basic<float_type,memory_type>& omega_K,
266  const geo_element& K,
267  const details::differentiate_option& gopt,
268  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
269 {
270  // 1) evaluate the component: u[i_comp]:
271  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic> value_comp;
272  _u_comp.template evaluate<Value,Diff> (omega_K, K, gopt, value_comp);
273  // 2) copy value_comp[] into value[]
274  _evaluate_continued (omega_K, K, value_comp, value);
275 }
276 template <class T, class M, class VfTag>
277 template<class Value>
278 void
280  const geo_basic<float_type,memory_type>& omega_K,
281  const geo_element& K,
282  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value_comp,
283  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
284 {
285  check_macro (!_is_on_band, "test_component: not yet on band");
286  reference_element hat_K = K;
287  _initialize_numbering (omega_K, K);
288  size_type loc_comp_ndof = _last_loc_idof[hat_K.variant()] - _first_loc_idof[hat_K.variant()];
289  size_type loc_ndof = _loc_ndof [hat_K.variant()];
290  check_macro (size_type(value_comp.cols()) == loc_comp_ndof,
291  "omega_K="<<omega_K.name()<<", K="<<K.name()<<K.dis_ie()
292  <<", space="<<_u.get_vf_space().name()<<", i_comp="<<_i_comp<<", comp_space="<<_u_comp.get_vf_space().name()
293  <<", value_comp("<<value_comp.rows()<<","<<value_comp.cols()<<") has incompatible cols size : expect loc_comp_ndof="<<loc_comp_ndof
294  << " associated to local dof sub-range ["<<_first_loc_idof[hat_K.variant()]<<":"<< _last_loc_idof[hat_K.variant()]<<"["
295  << " in full local dof range [0:"<<loc_ndof<<"[");
296  size_type loc_nnod = value_comp.rows();
297  value.resize (loc_nnod, loc_ndof);
298  value.fill (Value());
299  for (size_type loc_inod = 0; loc_inod < loc_nnod; ++loc_inod) {
300  for (size_type loc_jdof = _first_loc_idof[hat_K.variant()], loc_comp_jdof = 0; loc_comp_jdof < loc_comp_ndof; ++loc_jdof, ++loc_comp_jdof) {
301  value (loc_inod,loc_jdof) = value_comp (loc_inod,loc_comp_jdof);
302  }}
303 }
304 template <class T, class M, class VfTag>
305 template<class Value, details::differentiate_option::type Diff>
306 void
308  const geo_basic<float_type,memory_type>& omega_K,
309  const geo_element& K,
310  const side_information_type& sid,
311  const details::differentiate_option& gopt,
312  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value,
313  bool do_local_component_assembly) const
314 {
315  if (!do_local_component_assembly) {
316  // DG on an internal side: compute only one-side value here
317  // as it is bi-valued, it will be later assembled by local_dg_merge_on_side(), when the two values are computed
318  _u_comp.template evaluate_on_side<Value,Diff> (omega_K, K, sid, gopt, value, do_local_component_assembly);
319  return;
320  }
321  // on_local_side(DG); is uni-valued as the inner value, then assembled immediately
322  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic> value_comp;
323  _u_comp.template evaluate_on_side<Value,Diff> (omega_K, K, sid, gopt, value_comp, do_local_component_assembly);
324  _evaluate_on_side_continued (omega_K, K, sid, value_comp, value);
325 }
326 template <class T, class M, class VfTag>
327 template<class Value>
328 void
330  const geo_basic<float_type,memory_type>& omega_K,
331  const geo_element& K,
332  const side_information_type& sid,
333  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value_comp,
334  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
335 {
336  check_macro (!_is_on_band, "test_component: not yet on band");
337  check_macro (K.dimension() > 0, "unexpected 0D element for HDG multiplier");
338  size_type sid_map_d = K.dimension() - 1;
339  _initialize_numbering (omega_K, K);
340  reference_element hat_K = K;
341  size_type first_loc_jdof = _first_loc_idof [hat_K.variant()];
342  size_type loc_comp_ndof = _last_loc_idof [hat_K.variant()] - _first_loc_idof[hat_K.variant()];
343  size_type loc_ndof = _loc_ndof [hat_K.variant()];
344  check_macro (size_type(value_comp.cols()) == loc_comp_ndof,
345  "omega_K="<<omega_K.name()<<", K="<<K.name()<<K.dis_ie()
346  <<", space="<<_u.get_vf_space().name()<<", i_comp="<<_i_comp<<", comp_space="<<_u_comp.get_vf_space().name()
347  <<", value_comp("<<value_comp.rows()<<","<<value_comp.cols()<<") has incompatible cols size : expect loc_comp_ndof="<<loc_comp_ndof
348  << " associated to local dof sub-range ["<<_first_loc_idof[hat_K.variant()]<<":"<< _last_loc_idof[hat_K.variant()]<<"["
349  << " in full local dof range [0:"<<loc_ndof<<"[");
350  check_macro (first_loc_jdof + loc_comp_ndof <= loc_ndof, "invalid sizes");
351  size_type loc_nnod = value_comp.rows();
352  value.resize (loc_nnod, loc_ndof);
353  value.fill (Value());
354  for (size_type loc_inod = 0; loc_inod < loc_nnod; ++loc_inod) {
355  for (size_type loc_jdof = first_loc_jdof, loc_comp_jdof = 0; loc_comp_jdof < loc_comp_ndof; ++loc_jdof, ++loc_comp_jdof) {
356  value (loc_inod,loc_jdof) = value_comp (loc_inod,loc_comp_jdof);
357  }}
358 }
359 template <class T, class M, class VfTag>
360 template<class Value>
361 void
363  const geo_basic<T,M>& omega_K,
364  const geo_element& S,
365  const geo_element& K0,
366  const geo_element& K1,
367  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value_comp0,
368  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value_comp1,
369  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
370 {
371 trace_macro("local_dg_merge_on_side: omega_K="<<omega_K.name()<<", S="<<S.name()<<S.dis_ie()<<"...");
372  _initialize_numbering (omega_K, S);
373  reference_element hat_S = S;
374  size_type loc_nnod = value_comp0.rows();
375  size_type loc_ndof = _loc_ndof [hat_S.variant()];
376  size_type loc_comp_ndof = _last_loc_idof [hat_S.variant()] - _first_loc_idof[hat_S.variant()];
377  size_type first_loc_jdof = _first_loc_idof [hat_S.variant()];
378  check_macro (size_type(value_comp0.cols() + value_comp1.cols()) == loc_comp_ndof,
379  "omega_K="<<omega_K.name()<<", S="<<S.name()<<S.dis_ie()
380  <<", space="<<_u.get_vf_space().name()<<", i_comp="<<_i_comp<<", comp_space="<<_u_comp.get_vf_space().name()
381  <<", value_comp0("<<value_comp0.rows()<<","<<value_comp0.cols()<<") and "
382  << " value_comp1("<<value_comp1.rows()<<","<<value_comp1.cols()<<") have incompatible cols sizes : expect loc_comp_ndof="<<loc_comp_ndof
383  << " associated to local dof sub-range ["<<_first_loc_idof[hat_S.variant()]<<":"<< _last_loc_idof[hat_S.variant()]<<"["
384  << " in full local dof range [0:"<<loc_ndof<<"[");
385  check_macro (value_comp0.rows() == value_comp1.rows(), "invalid sizes");
386  check_macro (first_loc_jdof + loc_comp_ndof <= loc_ndof, "invalid sizes");
387  value.resize (loc_nnod, loc_ndof);
388  value.fill (Value());
389  for (size_type loc_inod = 0; loc_inod < loc_nnod; ++loc_inod) {
390  for (size_type loc_jdof = first_loc_jdof, loc_comp0_jdof = 0, loc_comp0_ndof = value_comp0.cols();
391  loc_comp0_jdof < loc_comp0_ndof; ++loc_jdof, ++loc_comp0_jdof) {
392  value (loc_inod,loc_jdof) = value_comp0 (loc_inod,loc_comp0_jdof);
393  }
394  for (size_type loc_jdof = first_loc_jdof + value_comp0.cols(), loc_comp1_jdof = 0, loc_comp1_ndof = value_comp1.cols();
395  loc_comp1_jdof < loc_comp1_ndof; ++loc_jdof, ++loc_comp1_jdof) {
396  value (loc_inod,loc_jdof) = value_comp1 (loc_inod,loc_comp1_jdof);
397  }
398  }
399 trace_macro("local_dg_merge_on_side: omega_K="<<omega_K.name()<<", S="<<S.name()<<S.dis_ie()<<" done");
400 }
401 // =========================================================================
402 // field_component
403 // =========================================================================
404 template <class T, class M, class VfTag>
405 class test_component: public smart_pointer<test_component_rep<T,M,VfTag> > {
406 public:
407 
408 // typename:
409 
413  typedef typename test_type::size_type size_type;
415  typedef M memory_type;
421  typedef VfTag vf_tag_type;
422  typedef typename details::dual_vf_tag<VfTag>::type
426 
427 // allocators:
428 
429  test_component () : base(0) {}
431  test_component (const test_basic<T,M,VfTag>& u, size_type i_comp) : base(new_macro(rep(u,i_comp))) {}
432  test_component (const test_component<T,M,VfTag>& u, size_type i_comp) : base(new_macro(rep(u,i_comp))) {}
433 
434 // recursive call:
435 
436  test_component<T,M,VfTag> operator[] (size_t i_comp) const { return test_component<T,M,VfTag> (*this, i_comp); }
437 
438 // accessors:
439 
440  const space_type& get_vf_space() const { return base::data().get_vf_space(); }
442  space_constant::valued_type valued_tag() const { return base::data().valued_tag(); }
443  size_type n_derivative() const { return 0; }
444 
445 // initializers:
446 
447  void initialize (
448  const piola_on_pointset<T>& pops,
449  const integrate_option& iopt) const
450  { base::data().initialize (pops, iopt); }
451  void initialize (
453  const piola_on_pointset<T>& pops,
454  const integrate_option& iopt) const
455  { base::data().initialize (gh, pops, iopt); }
456  void initialize (
458  const integrate_option& iopt) const
459  { base::data().initialize (Xh, iopt); }
460 
461 // evaluators:
462 
463  template<class Value, diff_type Diff>
464  void evaluate (
465  const geo_basic<float_type,memory_type>& omega_K,
466  const geo_element& K,
467  const details::differentiate_option& gopt,
468  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
469  { return base::data().template evaluate<Value,Diff> (omega_K, K, gopt, value); }
470 
471  template<class Value, diff_type Diff>
473  const geo_basic<float_type,memory_type>& omega_K,
474  const geo_element& K,
475  const side_information_type& sid,
476  const details::differentiate_option& gopt,
477  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value,
478  bool do_local_component_assembly) const
479  { return base::data().template evaluate_on_side<Value,Diff> (omega_K, K, sid, gopt, value, do_local_component_assembly); }
480 
481  // abbreviation: evaluate without differentiation
482  template<class Value>
483  void evaluate (
484  const geo_basic<float_type,memory_type>& omega_K,
485  const geo_element& K,
486  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
487  {
489  base::data().template evaluate<Value,details::differentiate_option::none> (omega_K, K, none, value);
490  }
491  template<class Value>
493  const geo_basic<float_type,memory_type>& omega_K,
494  const geo_element& K,
495  const side_information_type& sid,
496  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value,
497  bool do_local_component_assembly) const
498  {
500  base::data().template evaluate_on_side<Value,details::differentiate_option::none> (omega_K, K, sid, none, value, do_local_component_assembly);
501  }
502 
503 
504 
505  template<class Value>
507  const geo_basic<T,M>& omega_K,
508  const geo_element& S,
509  const geo_element& K0,
510  const geo_element& K1,
511  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value0,
512  const Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value1,
513  Eigen::Matrix<Value,Eigen::Dynamic,Eigen::Dynamic>& value) const
514  { return base::data().local_dg_merge_on_side (omega_K, S, K0, K1, value0, value1, value); }
515 
516 // checks:
517 
518  template<class ValueType>
519  void valued_check() const { base::data().template valued_check<ValueType>(); }
520  template<class ValueType>
521  void grad_valued_check() const { base::data().template grad_valued_check<ValueType>(); }
522  template<class ValueType>
523  void div_valued_check() const { base::data().template div_valued_check<ValueType>(); }
524 
525 };
526 
527 } // namespace details
528 // -------------------------------------------------------------------------
529 // test_basic accessor:
530 // -------------------------------------------------------------------------
531 template <class T, class M, class VfTag>
532 inline
533 details::test_component<T,M,VfTag>
535 {
536  return details::test_component<T,M,VfTag> (*this, i_comp);
537 }
538 
539 } // namespace rheolef
540 #endif // _RHEOLEF_TEST_COMPONENT_H
rheolef::details::test_component::size_type
test_type::size_type size_type
Definition: test_component.h:413
rheolef::geo_basic< float_type, memory_type >
rheolef::details::test_component::value_type
test_type::value_type value_type
Definition: test_component.h:414
rheolef::space_constant::last_valued
Definition: space_constant.h:143
rheolef::details::test_component_rep
Definition: test_component.h:33
rheolef::details::test_component::test_component
test_component()
Definition: test_component.h:429
rheolef::details::test_component::get_vf_space
const space_type & get_vf_space() const
Definition: test_component.h:440
gh
field gh(Float epsilon, Float t, const field &uh, const test &v)
Definition: burgers_diffusion_operators.icc:37
rheolef::point_basic
Definition: point.h:87
rheolef::details::test_component_rep::_has_subcomponent
bool _has_subcomponent() const
Definition: test_component.h:154
check_macro
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
rheolef::details::test_component::memory_type
M memory_type
Definition: test_component.h:415
rheolef::details::test_component_rep::valued_hint
static const space_constant::valued_type valued_hint
Definition: test_component.h:57
rheolef::details::test_component::operator[]
test_component< T, M, VfTag > operator[](size_t i_comp) const
Definition: test_component.h:436
rheolef::details::test_component::div_valued_check
void div_valued_check() const
Definition: test_component.h:523
rheolef::details::test_component::local_dg_merge_on_side
void local_dg_merge_on_side(const geo_basic< T, M > &omega_K, const geo_element &S, const geo_element &K0, const geo_element &K1, const Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value0, const Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value1, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value) const
Definition: test_component.h:506
rheolef::details::test_component_rep::scalar_type
test_type::scalar_type scalar_type
Definition: test_component.h:42
rheolef::details::test_component_rep::operator=
test_component_rep< T, M, VfTag > & operator=(const test_component_rep< T, M, VfTag > &)
Definition: test_component.h:183
rheolef::details::test_component::scalar_type
test_type::scalar_type scalar_type
Definition: test_component.h:416
rheolef::details::test_component
Definition: test.h:87
rheolef::details::test_component::test_component
test_component(const test_component< T, M, VfTag > &u)
Definition: test_component.h:430
rheolef::details::test_component_rep::test_component_rep
test_component_rep(const test_basic< T, M, VfTag > &u, size_type i_comp)
Definition: test_component.h:197
rheolef::details::test_component_rep::size_type
test_type::size_type size_type
Definition: test_component.h:39
rheolef::details::test_component::float_type
test_type::float_type float_type
Definition: test_component.h:417
rheolef::details::test_component_rep::value_type
test_type::value_type value_type
Definition: test_component.h:40
rheolef::details::test_component::initialize
void initialize(const band_basic< float_type, memory_type > &gh, const piola_on_pointset< T > &pops, const integrate_option &iopt) const
Definition: test_component.h:451
rheolef::value
rheolef::std value
rheolef::details::test_component_rep::evaluate
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, const details::differentiate_option &gopt, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value) const
Definition: test_component.h:264
rheolef::details::test_component_rep::_u
test_basic< T, M, VfTag > _u
Definition: test_component.h:152
rheolef::space_basic< float_type, M >
rheolef::details::test_component_rep::initialize
void initialize(const band_basic< float_type, memory_type > &gh, const piola_on_pointset< T > &pops, const integrate_option &iopt) const
Definition: test_component.h:66
rheolef::details::test_component_rep::_ptr_u_comp_upper_data
smart_pointer< test_component_rep< T, M, VfTag > > _ptr_u_comp_upper_data
Definition: test_component.h:155
rheolef::details::test_component::grad_valued_check
void grad_valued_check() const
Definition: test_component.h:521
rheolef::details::test_component_rep::local_dg_merge_on_side
void local_dg_merge_on_side(const geo_basic< T, M > &omega_K, const geo_element &S, const geo_element &K0, const geo_element &K1, const Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value0, const Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value1, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value) const
Definition: test_component.h:362
rheolef::geo_element
see the geo_element page for the full documentation
Definition: geo_element.h:102
rheolef::details::test_component::geo_type
geo_basic< float_type, M > geo_type
Definition: test_component.h:419
rheolef::space_constant::valued_type
valued_type
Definition: space_constant.h:135
rheolef::size_type
size_t size_type
Definition: basis_get.cc:76
rheolef::undeterminated_basic
helper for generic field value_type: T, point_basic<T> or tensor_basic<T>
Definition: undeterminated.h:32
rheolef::details::test_component_rep::_evaluate_continued
void _evaluate_continued(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, const Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value_comp, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value) const
Definition: test_component.h:279
rheolef::details::test_component::test_component
test_component(const test_component< T, M, VfTag > &u, size_type i_comp)
Definition: test_component.h:432
rheolef::geo_element::variant
variant_type variant() const
Definition: geo_element.h:161
rheolef::details::test_component_rep::valued_check
void valued_check() const
Definition: test_component.h:107
rheolef::geo_element::dis_ie
size_type dis_ie() const
Definition: geo_element.h:163
rheolef::details::test_component_rep::_last_loc_idof
std::array< size_type, reference_element::max_variant > _last_loc_idof
Definition: test_component.h:160
rheolef::details::test_component::self_type
test_component< T, M, VfTag > self_type
Definition: test_component.h:424
rheolef::details::test_component_rep::grad_valued_check
void grad_valued_check() const
Definition: test_component.h:114
rheolef::side_information_type
Definition: reference_element_face_transformation.h:37
rheolef::reference_element
see the reference_element page for the full documentation
Definition: reference_element.h:66
rheolef::smart_pointer
see the smart_pointer page for the full documentation
Definition: smart_pointer.h:351
rheolef::details::test_component::evaluate_on_side
void evaluate_on_side(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, const side_information_type &sid, const details::differentiate_option &gopt, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value, bool do_local_component_assembly) const
Definition: test_component.h:472
rheolef::details::test_component_rep::memory_type
M memory_type
Definition: test_component.h:41
rheolef::integrate_option
see the integrate_option page for the full documentation
Definition: integrate_option.h:125
mkgeo_ball.variant
variant
Definition: mkgeo_ball.sh:149
rheolef::details::test_component::valued_tag
space_constant::valued_type valued_tag() const
Definition: test_component.h:442
rheolef::details::test_component_rep::_i_comp
size_type _i_comp
Definition: test_component.h:151
rheolef::details::vf_tag_nonlinear
Definition: field_expr_variational_tag.h:49
rheolef::test_basic
Definition: test.h:207
rheolef::geo_element::dimension
size_type dimension() const
Definition: geo_element.h:167
rheolef::details::test_component_rep::initialize
void initialize(const space_basic< float_type, memory_type > &Xh, const integrate_option &iopt) const
Definition: test_component.h:71
rheolef::details::test_component_rep::_loc_ndof
std::array< size_type, reference_element::max_variant > _loc_ndof
Definition: test_component.h:160
rheolef::details::test_component::evaluate_on_side
void evaluate_on_side(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, const side_information_type &sid, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value, bool do_local_component_assembly) const
Definition: test_component.h:492
rheolef::test_basic::scalar_type
rep::scalar_type scalar_type
Definition: test.h:216
rheolef::details::test_component_rep::float_type
test_type::float_type float_type
Definition: test_component.h:43
rheolef::details::test_component::initialize
void initialize(const space_basic< float_type, memory_type > &Xh, const integrate_option &iopt) const
Definition: test_component.h:456
rheolef::details::test_component::vf_tag_type
VfTag vf_tag_type
Definition: test_component.h:421
rheolef::details::differentiate_option
Definition: piola.h:41
rheolef::reference_element::variant
variant_type variant() const
Definition: reference_element.h:99
rheolef::details::test_component::evaluate
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value) const
Definition: test_component.h:483
rheolef::details::test_component_rep::valued_tag
space_constant::valued_type valued_tag() const
Definition: test_component.h:58
rheolef::details::test_component_rep::get_vf_space
const space_type & get_vf_space() const
Definition: test_component.h:56
rheolef::details::test_component_rep::_is_on_band
bool _is_on_band
Definition: test_component.h:163
rheolef::details::test_component_rep::div_valued_check
void div_valued_check() const
Definition: test_component.h:122
rheolef::test_basic::operator[]
details::test_component< T, M, VfTag > operator[](size_type i_comp) const
Definition: test_component.h:534
rheolef::piola_on_pointset
Definition: piola_on_pointset.h:142
rheolef::details::test_component_rep::test_type
test_basic< T, M, VfTag > test_type
Definition: test_component.h:38
rheolef::space_constant::valued_name
const std::string & valued_name(valued_type valued_tag)
Definition: space_constant.cc:43
rheolef::band_basic
Definition: band.h:95
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
rheolef::details::test_component::test_type
test_basic< T, M, VfTag > test_type
Definition: test_component.h:412
u
Definition: leveque.h:25
rheolef::smart_pointer_base< T, details::constructor_copy< T > >::data
const T & data() const
Definition: smart_pointer.h:266
rheolef::details::test_component_rep::_init_space_comp
static space_type _init_space_comp(const space_type &Xh, size_type i_comp)
Definition: test_component.h:224
rheolef::details::test_component::n_derivative
size_type n_derivative() const
Definition: test_component.h:443
rheolef::details::test_component_rep::_evaluate_on_side_continued
void _evaluate_on_side_continued(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, const side_information_type &sid, const Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value_comp, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value) const
Definition: test_component.h:329
rheolef::details::test_component_rep::_initialize_numbering
void _initialize_numbering(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K) const
Definition: test_component.h:232
rheolef::details::test_component::vf_dual_tag_type
details::dual_vf_tag< VfTag >::type vf_dual_tag_type
Definition: test_component.h:423
rheolef::test_basic::size_type
rep::size_type size_type
Definition: test.h:213
rheolef::details::test_component_rep::space_type
space_basic< float_type, M > space_type
Definition: test_component.h:45
rheolef::details::test_component::valued_hint
static const space_constant::valued_type valued_hint
Definition: test_component.h:441
rheolef::details::test_component::dual_self_type
test_component< T, M, vf_dual_tag_type > dual_self_type
Definition: test_component.h:425
size_type
field::size_type size_type
Definition: branch.cc:425
rheolef::details::test_component::space_type
space_basic< float_type, M > space_type
Definition: test_component.h:420
rheolef::geo_element::name
char name() const
Definition: geo_element.h:169
rheolef::details::test_component::initialize
void initialize(const piola_on_pointset< T > &pops, const integrate_option &iopt) const
Definition: test_component.h:447
rheolef::details::test_component_rep::evaluate_on_side
void evaluate_on_side(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, const side_information_type &sid, const details::differentiate_option &gopt, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value, bool do_local_component_assembly) const
Definition: test_component.h:307
rheolef::details::test_component::test_component
test_component(const test_basic< T, M, VfTag > &u, size_type i_comp)
Definition: test_component.h:431
rheolef::details::test_component::evaluate
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, const details::differentiate_option &gopt, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value) const
Definition: test_component.h:464
rheolef::details::test_component_rep::_first_loc_idof
std::array< size_type, reference_element::max_variant > _first_loc_idof
Definition: test_component.h:160
rheolef::test_basic::float_type
rep::float_type float_type
Definition: test.h:217
rheolef::details::test_component::base
smart_pointer< rep > base
Definition: test_component.h:411
rheolef::details::test_component_rep::initialize
void initialize(const piola_on_pointset< T > &pops, const integrate_option &iopt) const
Definition: test_component.h:62
rheolef::space_constant::valued_tag_traits
Definition: space_constant.h:161
M
Expr1::memory_type M
Definition: vec_expr_v2.h:385
rheolef::details::differentiate_option::type
type
Definition: piola.h:42
rheolef::details::test_component::diff_type
details::differentiate_option::type diff_type
Definition: test_component.h:418
rheolef::details::test_component::rep
test_component_rep< T, M, VfTag > rep
Definition: test_component.h:410
rheolef::details::test_component_rep::_u_comp
test_basic< T, M, VfTag > _u_comp
Definition: test_component.h:152
rheolef::details::test_component::valued_check
void valued_check() const
Definition: test_component.h:519
rheolef::details::test_component_rep::get_u_comp_upper_data
const test_component_rep< T, M, VfTag > & get_u_comp_upper_data() const
Definition: test_component.h:153
trace_macro
#define trace_macro(message)
Definition: dis_macros.h:111
rheolef::details::test_component_rep::diff_type
details::differentiate_option::type diff_type
Definition: test_component.h:44