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
23 // 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
field::size_type size_type
Definition: branch.cc:425
field gh(Float epsilon, Float t, const field &uh, const test &v)
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
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
space_basic< float_type, M > space_type
std::array< size_type, reference_element::max_variant > _first_loc_idof
void initialize(const space_basic< float_type, memory_type > &Xh, const integrate_option &iopt) const
test_basic< T, M, VfTag > test_type
test_basic< T, M, VfTag > _u
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
smart_pointer< test_component_rep< T, M, VfTag > > _ptr_u_comp_upper_data
void initialize(const band_basic< float_type, memory_type > &gh, const piola_on_pointset< T > &pops, const integrate_option &iopt) const
void initialize(const piola_on_pointset< T > &pops, const integrate_option &iopt) const
test_type::scalar_type scalar_type
std::array< size_type, reference_element::max_variant > _last_loc_idof
std::array< size_type, reference_element::max_variant > _loc_ndof
static space_type _init_space_comp(const space_type &Xh, size_type i_comp)
test_component_rep(const test_basic< T, M, VfTag > &u, size_type i_comp)
static const space_constant::valued_type valued_hint
test_component_rep< T, M, VfTag > & operator=(const test_component_rep< T, M, VfTag > &)
details::differentiate_option::type diff_type
const test_component_rep< T, M, VfTag > & get_u_comp_upper_data() const
test_basic< T, M, VfTag > _u_comp
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
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
const space_type & get_vf_space() const
space_constant::valued_type valued_tag() const
void _initialize_numbering(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K) const
void evaluate(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K, Eigen::Matrix< Value, Eigen::Dynamic, Eigen::Dynamic > &value) const
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
space_basic< float_type, M > space_type
test_type::float_type float_type
void initialize(const space_basic< float_type, memory_type > &Xh, const integrate_option &iopt) const
test_basic< T, M, VfTag > test_type
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
void initialize(const band_basic< float_type, memory_type > &gh, const piola_on_pointset< T > &pops, const integrate_option &iopt) const
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
void initialize(const piola_on_pointset< T > &pops, const integrate_option &iopt) const
test_type::scalar_type scalar_type
test_component< T, M, vf_dual_tag_type > dual_self_type
test_component(const test_component< T, M, VfTag > &u)
test_component(const test_basic< T, M, VfTag > &u, size_type i_comp)
static const space_constant::valued_type valued_hint
test_component< T, M, VfTag > operator[](size_t i_comp) const
test_type::value_type value_type
details::differentiate_option::type diff_type
test_component< T, M, VfTag > self_type
test_component_rep< T, M, VfTag > rep
test_type::size_type size_type
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
geo_basic< float_type, M > geo_type
const space_type & get_vf_space() const
test_component(const test_component< T, M, VfTag > &u, size_type i_comp)
details::dual_vf_tag< VfTag >::type vf_dual_tag_type
space_constant::valued_type valued_tag() const
see the geo_element page for the full documentation
Definition: geo_element.h:102
size_type dimension() const
Definition: geo_element.h:167
variant_type variant() const
Definition: geo_element.h:161
size_type dis_ie() const
Definition: geo_element.h:163
char name() const
Definition: geo_element.h:169
see the integrate_option page for the full documentation
see the reference_element page for the full documentation
variant_type variant() const
see the smart_pointer page for the full documentation
details::test_component< T, M, VfTag > operator[](size_type i_comp) const
rep::float_type float_type
Definition: test.h:217
rep::size_type size_type
Definition: test.h:213
rep::scalar_type scalar_type
Definition: test.h:216
size_t size_type
Definition: basis_get.cc:76
rheolef::std value
#define trace_macro(message)
Definition: dis_macros.h:111
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
const std::string & valued_name(valued_type valued_tag)
This file is part of Rheolef.
helper for generic field value_type: T, point_basic<T> or tensor_basic<T>
Definition: leveque.h:25
Expr1::memory_type M
Definition: vec_expr_v2.h:416