Rheolef  7.2
an efficient C++ finite element environment
 
Loading...
Searching...
No Matches
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
27namespace rheolef { namespace details {
28
29// =========================================================================
30// test_component
31// =========================================================================
32template <class T, class M, class VfTag>
34public:
35
36// typename:
37
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
63 const piola_on_pointset<T>& pops,
64 const integrate_option& iopt)
65 { _u_comp.initialize (pops, iopt); }
68 const piola_on_pointset<T>& pops,
69 const integrate_option& iopt)
70 { _u_comp.initialize (gh, pops, iopt); _is_on_band = true; }
73 const integrate_option& iopt)
74 { _u_comp.initialize (Xh, iopt); }
75
76// evaluators:
77
78 template<class Value, details::differentiate_option::type Diff>
79 void evaluate (
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 (
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 {
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 {
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
130protected:
131// internals:
132 static space_type _init_space_comp(const space_type& Xh, size_type i_comp);
135 const geo_element& K) const;
136 template<class Value>
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>
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// -------------------------------------------------------------------------
168template <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}
181template <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}
196template <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}
209template <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}
222template <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}
230template <class T, class M, class VfTag>
231void
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}
261template <class T, class M, class VfTag>
262template<class Value, details::differentiate_option::type Diff>
263void
266 const geo_element& K,
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}
276template <class T, class M, class VfTag>
277template<class Value>
278void
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}
304template <class T, class M, class VfTag>
305template<class Value, details::differentiate_option::type Diff>
306void
309 const geo_element& K,
310 const side_information_type& sid,
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}
326template <class T, class M, class VfTag>
327template<class Value>
328void
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}
359template <class T, class M, class VfTag>
360template<class Value>
361void
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{
371trace_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 }
399trace_macro("local_dg_merge_on_side: omega_K="<<omega_K.name()<<", S="<<S.name()<<S.dis_ie()<<" done");
400}
401// =========================================================================
402// test_component
403// =========================================================================
404template <class T, class M, class VfTag>
405class test_component: public smart_pointer<test_component_rep<T,M,VfTag> > {
406public:
407
408// typename:
409
413 typedef typename test_type::size_type size_type;
414 typedef typename test_type::value_type value_type;
415 typedef M memory_type;
416 typedef typename test_type::scalar_type scalar_type;
417 typedef typename test_type::float_type float_type;
421 typedef VfTag vf_tag_type;
422 typedef typename details::dual_vf_tag<VfTag>::type
426
427// allocators:
428
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(); }
441 static const space_constant::valued_type valued_hint = rep::valued_hint;
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
448 const piola_on_pointset<T>& pops,
449 const integrate_option& iopt)
450 { base::data().initialize (pops, iopt); }
453 const piola_on_pointset<T>& pops,
454 const integrate_option& iopt)
455 { base::data().initialize (gh, pops, iopt); }
458 const integrate_option& iopt)
459 { base::data().initialize (Xh, iopt); }
460
461// evaluators:
462
463 template<class Value, diff_type Diff>
464 void evaluate (
466 const geo_element& K,
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>
474 const geo_element& K,
475 const side_information_type& sid,
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 (
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>
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// -------------------------------------------------------------------------
531template <class T, class M, class VfTag>
532inline
533details::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:430
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 piola_on_pointset< T > &pops, const integrate_option &iopt)
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
smart_pointer< test_component_rep< T, M, VfTag > > _ptr_u_comp_upper_data
void initialize(const space_basic< float_type, memory_type > &Xh, const integrate_option &iopt)
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)
const test_component_rep< T, M, VfTag > & get_u_comp_upper_data() const
static const space_constant::valued_type valued_hint
void initialize(const band_basic< float_type, memory_type > &gh, const piola_on_pointset< T > &pops, const integrate_option &iopt)
test_component_rep< T, M, VfTag > & operator=(const test_component_rep< T, M, VfTag > &)
details::differentiate_option::type diff_type
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
space_constant::valued_type valued_tag() const
void _initialize_numbering(const geo_basic< float_type, memory_type > &omega_K, const geo_element &K) const
const space_type & get_vf_space() 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
test_component< T, M, VfTag > operator[](size_t i_comp) 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 piola_on_pointset< T > &pops, const integrate_option &iopt)
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 space_basic< float_type, memory_type > &Xh, const integrate_option &iopt)
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
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
void initialize(const band_basic< float_type, memory_type > &gh, const piola_on_pointset< T > &pops, const integrate_option &iopt)
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
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
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
const space_type & get_vf_space() const
generic mesh with rerefence counting
Definition geo.h:1089
see the geo_element page for the full documentation
size_type dimension() const
variant_type variant() const
size_type dis_ie() const
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
the finite element space
Definition space.h:382
typename rep::size_type size_type
Definition test.h:213
typename rep::value_type value_type
Definition test.h:215
details::test_component< T, M, VfTag > operator[](size_type i_comp) const
typename rep::float_type float_type
Definition test.h:217
typename rep::scalar_type scalar_type
Definition test.h:216
#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.
undeterminated_basic< typename scalar_traits< T >::type > type
point_basic< typename scalar_traits< T >::type > type
Definition leveque.h:25
Expr1::memory_type M