Rheolef  7.2
an efficient C++ finite element environment
 
Loading...
Searching...
No Matches
space_constitution.h
Go to the documentation of this file.
1#ifndef _RHEOLEF_SPACE_CONSTITUTION_H
2#define _RHEOLEF_SPACE_CONSTITUTION_H
23
24#include "rheolef/geo.h"
25#include "rheolef/geo_domain.h"
26#include "rheolef/space_constant.h"
27
28namespace rheolef {
29
30// forward declarations:
31template <class T, class M> class space_mult_list;
32template <class T, class M> class space_constitution;
33
34// =====================================================================
35// space_act = a domain + an act (block, unblock)
36// =====================================================================
37
38class space_act {
39public:
40
41// typedefs:
42
43 typedef size_t size_type;
44 static const size_type unset_index = std::numeric_limits<size_type>::max();
45
46 enum act_type {
47 block = 0,
50 unblock_n = 3
51 };
52
53// allocators:
54
55 space_act(const std::string& dom_name, act_type act)
56 : _dom_name(dom_name), _i_comp(unset_index), _act(act) {}
57 space_act(const std::string& dom_name, size_type i_comp, act_type act)
58 : _dom_name(dom_name), _i_comp(i_comp), _act(act) {}
63
64// accessors:
65
66 const std::string& get_domain_name() const { return _dom_name; }
67 act_type get_act() const { return _act; }
69
70// data:
71protected:
72 std::string _dom_name;
75};
76// =====================================================================
77// space_constitution_terminal = a table of acts
78// =====================================================================
79
80template <class T, class M>
82public:
83 typedef typename std::vector<space_act> container_type;
84 typedef typename container_type::size_type size_type;
85 typedef typename container_type::const_iterator const_iterator;
86
87// allocators:
88
91
93 const geo_basic<T,M>& omega,
94 std::string approx);
95
97 : _acts(scr._acts), _omega(scr._omega), _fem_basis(scr._fem_basis)
98 {
99 trace_macro ("physical copy of space_constitution_terminal_rep: size="<< size());
100 }
101
102// accessors:
103
104 const geo_basic<T,M>& get_geo() const { return _omega; }
105 const geo_basic<T,M>& get_background_geo() const { return _omega.get_background_geo(); }
106 const basis_basic<T>& get_basis() const { return _fem_basis; }
107
108 bool is_initialized() const { return _fem_basis.is_initialized(); }
109 size_type size() const { return _acts.size(); }
110 const_iterator begin() const { return _acts.begin(); }
111 const_iterator end() const { return _acts.end(); }
112
113// utility:
114
116 disarray<size_type,M>& idof2ios_dis_idof,
117 disarray<size_type,M>& ios_idof2dis_idof) const;
118
119// inquiries:
120
121 size_type degree_max() const { return _fem_basis.degree(); }
122 bool have_compact_support_inside_element() const { return _fem_basis.have_compact_support_inside_element(); }
123 bool is_discontinuous() const { return ! _fem_basis.is_continuous(); }
124 void neighbour_guard() const { return get_geo().neighbour_guard(); }
125
126// modifiers
127
128 void set_geo (const geo_basic<T,M>& omega) { _omega = omega; }
129 void set_basis (const basis_basic<T>& b) { _fem_basis = b; }
130 void do_act (const space_act& act);
131
132// comparator:
133
134 bool operator== (const space_constitution_terminal_rep<T,M>& V2) const { return _omega == V2._omega && _fem_basis.name() == V2._fem_basis.name(); }
135
136// internal:
137 void build_blocked_flag (
138 disarray<size_type,M>& blocked_flag,
139 const distributor& comp_ownership,
140 const distributor& start_by_component) const;
141protected:
142// data:
143 std::vector<space_act> _acts;
146};
147template <class T, class M>
148class space_constitution_terminal : public smart_pointer<space_constitution_terminal_rep<T,M> > {
149public:
150
153 typedef typename rep::size_type size_type;
154 typedef typename rep::const_iterator const_iterator;
155
156// allocators:
157
160
162 const geo_basic<T,M>& omega,
163 std::string approx)
164 : smart_pointer<rep>(new_macro(rep (omega,approx))) {}
165
166// accessors:
167
168 const geo_basic<T,M>& get_geo() const { return base::data().get_geo(); }
169 const geo_basic<T,M>& get_background_geo() const { return base::data().get_background_geo(); }
170 const basis_basic<T>& get_basis() const { return base::data().get_basis(); }
171 size_type size() const { return base::data().size(); }
172 const_iterator begin() const { return base::data().begin(); }
173 const_iterator end() const { return base::data().end(); }
174
175// utility:
176
178 disarray<size_type,M>& idof2ios_dis_idof,
179 disarray<size_type,M>& ios_idof2dis_idof) const
180 { base::data().set_ios_permutations (idof2ios_dis_idof, ios_idof2dis_idof); }
181
182// inquiries:
183
184 bool have_compact_support_inside_element() const { return base::data().have_compact_support_inside_element(); }
185 bool is_discontinuous() const { return base::data().is_discontinuous(); }
186 size_type degree_max() const { return base::data().degree_max(); }
187 void neighbour_guard() const { return base::data().neighbour_guard(); }
188
189// comparator:
190
191 bool operator== (const space_constitution_terminal<T,M>& V2) const { return base::data().operator==(V2.data()); }
192
193// modifiers
194
195 void set_geo (const geo_basic<T,M>& omega) { base::data().set_geo (omega); }
196 void set_basis (const basis_basic<T>& b) { base::data().set_basis (b); }
197 void do_act (const space_act& act) { base::data().do_act(act); }
198
199 void block (const domain_indirect_basic<M>& dom) { do_act (space_act(dom.name(), space_act::block)); }
203};
204// =======================================================================
205// space_constitution = a recursive hierarchy of constitution
206// =======================================================================
207template <class T, class M>
209public:
212 typedef std::vector<value_type> hierarchy_type;
214 typedef typename hierarchy_type::size_type size_type;
215 typedef typename hierarchy_type::iterator iterator;
216 typedef typename hierarchy_type::const_iterator const_iterator;
218
219// allocator:
220
223 space_constitution_rep (const geo_basic<T,M>& omega, std::string approx);
225
226// accessors & modifiers:
227
228 const distributor& ownership() const { return _ownership; }
229 std::string name() const;
230 size_type ndof() const { return _ownership.size(); }
231 size_type dis_ndof() const { return _ownership.dis_size(); }
232 communicator comm() const { return _ownership.comm(); }
233 size_type ios_ndof() const;
234 void do_act (const space_act& act);
235 const geo_basic<T,M>& get_geo() const;
236 const geo_basic<T,M>& get_background_geo() const;
237 const basis_basic<T>& get_basis() const;
238 size_type loc_ndof (const reference_element& hat_K) const;
239 size_type assembly_loc_ndof (const geo_basic<T,M>& dom, const geo_element& bgd_K) const;
240 void assembly_dis_idof (const geo_basic<T,M>& dom,
241 const geo_element& bgd_K, std::vector<geo_element::size_type>& dis_idof) const;
242 void compute_external_dofs (std::set<size_type>& ext_dof_set) const;
245 const valued_type& valued_tag() const { return _valued_tag; }
246 const std::string& valued() const { return space_constant::valued_name (_valued_tag); }
247 bool is_hierarchical() const { return _is_hier; }
248 void set_hierarchy (bool hier) { _is_hier = hier; }
249
250// inquiries:
251
253 bool is_discontinuous() const;
254 size_type degree_max() const;
255 void neighbour_guard() const;
256
257// scalar accessors & modifiers:
258
261
262// hierarchy accessors & modifiers:
263
266 size_type size() const { return _is_hier ? _hier_constit.size() : 0; }
268 const space_constitution<T,M>& operator[] (size_type i_comp) const { return get_hierarchy() [i_comp]; }
269
271 size_type comp_dis_idof2dis_idof (size_type i_comp, size_type comp_dis_idof) const;
272
273// utility:
274
276 disarray<size_type,M>& idof2ios_dis_idof,
277 disarray<size_type,M>& ios_idof2dis_idof) const;
278
279// comparator:
280
281 bool operator== (const space_constitution_rep<T,M>& V2) const;
282
283// internal:
284 void initialize() const;
286 const geo_basic<T,M>& dom,
287 std::set<size_type>& ext_dof_set,
288 const distributor& dof_ownership,
289 const distributor& start_by_component) const;
291 std::set<size_type>& ext_dof_set,
292 const distributor& dof_ownership,
293 const std::vector<distributor>& start_by_component,
294 size_type& i_comp) const;
296 disarray<size_type,M>& blocked_flag, // disarray<bool,M> not supported
297 const std::vector<distributor>& start_by_component,
298 size_type& i_comp) const;
300
301// io:
302 void put (std::ostream& out, size_type level = 0) const;
303
304protected:
305// internals:
306 friend class space_constitution<T,M>;
307 void hierarchy_guard() const { check_macro ( _is_hier, "invalid access to a non-hierarchical constitution"); }
308 void scalar_guard() const { check_macro (!_is_hier, "invalid access to a hierarchical constitution"); }
310 disarray<size_type,M>& idof2ios_dis_idof,
311 size_type& comp_start_idof,
312 size_type& comp_start_dis_idof) const;
315 size_type& i_flat_comp,
316 size_type& start_flat_comp_idof,
317 size_type& dis_start_flat_comp_idof,
318 std::vector<distributor>& start_by_flattened_component) const;
319 void _init_start_by_component() const;
321 const geo_basic<T,M>& dom,
322 const geo_element& bgd_K,
323 typename std::vector<geo_element::size_type>::iterator& dis_idof_t,
324 const distributor& hier_ownership,
325 const std::vector<distributor>& start_by_flattened_component,
326 size_type& i_flat_comp) const;
327
328// data:
329 // union (hier,not hier):
330 mutable bool _is_initialized;
332 mutable std::vector<distributor> _start_by_flattened_component;
333 mutable std::vector<distributor> _start_by_component;
339 mutable std::array<size_type, reference_element::max_variant> _loc_ndof; // working array
340};
341// ----------------------------------------------------------------------------
342// inlined
343// ----------------------------------------------------------------------------
344// allocators: there are 4 allocators, here are 2, the 2 others are in .cc
345template <class T, class M>
346inline
348 : _is_initialized(false),
349 _flattened_size(0),
350 _start_by_flattened_component(),
351 _start_by_component(),
352 _ownership(),
353 _valued_tag(space_constant::mixed),
354 _is_hier(false),
355 _terminal_constit(),
356 _hier_constit(),
357 _loc_ndof()
358{
359 _loc_ndof.fill (std::numeric_limits<size_type>::max());
360}
361template <class T, class M>
362inline
364 : _is_initialized(x._is_initialized),
365 _flattened_size(x._flattened_size),
366 _start_by_flattened_component(x._start_by_flattened_component),
367 _start_by_component(x._start_by_component),
368 _ownership(x._ownership),
369 _valued_tag(x._valued_tag),
370 _is_hier(x._is_hier),
371 _terminal_constit(x._terminal_constit),
372 _hier_constit(x._hier_constit),
373 _loc_ndof()
374{
375 _loc_ndof.fill (std::numeric_limits<size_type>::max());
376}
377template <class T, class M>
378inline
380 const geo_basic<T,M>& omega,
381 std::string approx)
382 : _is_initialized(false),
383 _flattened_size(0),
384 _start_by_flattened_component(),
385 _start_by_component(),
386 _ownership(),
387 _valued_tag(space_constant::scalar),
388 _is_hier(false),
389 _terminal_constit(),
390 _hier_constit(),
391 _loc_ndof()
392{
393 _loc_ndof.fill (std::numeric_limits<size_type>::max());
394 _terminal_constit = scalar_type (omega, approx);
395 if (_terminal_constit.get_basis().is_initialized()) {
396 _valued_tag = _terminal_constit.get_basis().valued_tag();
397 }
398 initialize();
399}
400// ----------------------------------------------------------------------------
401// space_constitution
402// ----------------------------------------------------------------------------
403
404template <class T, class M = rheo_default_memory_model>
405class space_constitution : public smart_pointer<space_constitution_rep<T,M> > {
406public:
407
410 typedef typename rep::size_type size_type;
415
416// allocators:
417
419 : base(new_macro(rep)) {}
420
422 : base(b) {}
423
425 const geo_basic<T,M>& omega,
426 std::string approx)
427 : base(new_macro(rep (omega,approx))) {}
428
430 : base(new_macro(rep (expr))) {}
431
432// accessors & modifiers:
433
434 const distributor& ownership() const { return base::data().ownership(); }
435 std::string name() const { return base::data().name(); }
436 size_type ndof() const { return base::data().ndof(); }
437 size_type dis_ndof() const { return base::data().dis_ndof(); }
438 size_type ios_ndof() const { return base::data().ios_ndof(); }
439 communicator comm() const { return base::data().comm(); }
440 const geo_basic<T,M>& get_geo() const { return base::data().get_geo(); }
441 const geo_basic<T,M>& get_background_geo() const { return base::data().get_background_geo(); }
442 const basis_basic<T>& get_basis() const { return base::data().get_basis(); }
443 size_type loc_ndof (const reference_element& hat_K) const { return base::data().loc_ndof (hat_K); }
444 size_type assembly_loc_ndof (const geo_basic<T,M>& dom, const geo_element& bgd_K) const {
445 return base::data().assembly_loc_ndof (dom, bgd_K); }
446 void assembly_dis_idof ( const geo_basic<T,M>& dom, const geo_element& bgd_K, std::vector<geo_element::size_type>& dis_idof) const {
447 base::data().assembly_dis_idof (dom, bgd_K, dis_idof); }
448 void do_act (const space_act& act) { base::data().do_act(act); }
449 void block (const domain_indirect_basic<M>& dom) { do_act (space_act(dom.name(), space_act::block)); }
453 disarray<size_type,M> build_blocked_flag() const { return base::data().build_blocked_flag(); }
454 void compute_external_dofs (std::set<size_type>& ext_dof_set) const
455 { base::data().compute_external_dofs(ext_dof_set); }
456 bool is_hierarchical() const { return base::data().is_hierarchical(); }
457
458// inquiries:
459
460 bool have_compact_support_inside_element() const { return base::data().have_compact_support_inside_element(); }
461 bool is_discontinuous() const { return base::data().is_discontinuous(); }
462 size_type degree_max() const { return base::data().degree_max(); }
463 void neighbour_guard() const { return base::data().neighbour_guard(); }
464
465// scalar accessors & modifiers:
466
467 const space_constitution_terminal<T,M>& get_terminal() const { return base::data().get_terminal(); }
468 space_constitution_terminal<T,M>& get_terminal() { return base::data().get_terminal(); }
469
470// hierarchy accessors & modifiers:
471
472 void set_hierarchy(bool hier = true) { return base::data().set_hierarchy(hier); }
473 void set_valued_tag (valued_type valued_tag){ base::data().set_valued_tag(valued_tag); }
474 void set_valued (const std::string& valued){ base::data().set_valued (valued); }
475 const valued_type& valued_tag() const { return base::data().valued_tag(); }
476 const std::string& valued() const { return base::data().valued(); }
477 const hierarchy_type& get_hierarchy() const { return base::data().get_hierarchy(); }
478 hierarchy_type& get_hierarchy() { return base::data().get_hierarchy(); }
479 size_type size() const { return base::data().size(); }
480 space_constitution<T,M>& operator[] (size_type i_comp) { return base::data().operator[] (i_comp); }
481 const space_constitution<T,M>& operator[] (size_type i_comp) const { return base::data().operator[] (i_comp); }
482 size_type flattened_size() const { return base::data().flattened_size(); }
484 { return base::data().comp_dis_idof2dis_idof (i_comp, comp_dis_idof); }
485
486// utility:
487
489 disarray<size_type,M>& idof2ios_dis_idof,
490 disarray<size_type,M>& ios_idof2dis_idof) const
491 { base::data().set_ios_permutations (idof2ios_dis_idof, ios_idof2dis_idof); }
492
493// comparator:
494
495 bool operator== (const space_constitution<T,M>& V2) const { return base::data().operator==(V2.data()); }
496
497protected:
498// internal:
499 friend class space_constitution_rep<T,M>;
501 disarray<size_type,M>& idof2ios_dis_idof,
502 size_type& comp_start_idof,
503 size_type& comp_start_dis_idof) const
504 { base::data().set_ios_permutation_recursion (idof2ios_dis_idof, comp_start_idof, comp_start_dis_idof); }
505};
506template<class T, class M>
507idiststream&
508operator>> (idiststream& ids, space_constitution<T,M>& constit);
509
510} // namespace rheolef
511#endif // _RHEOLEF_SPACE_CONSTITUTION_H
field::size_type size_type
Definition branch.cc:430
see the disarray page for the full documentation
Definition disarray.h:497
see the distributor page for the full documentation
Definition distributor.h:69
size_type dis_size() const
global and local sizes
size_type size(size_type iproc) const
const communicator_type & comm() const
the finite element boundary domain
generic mesh with rerefence counting
Definition geo.h:1089
see the geo_element page for the full documentation
see the reference_element page for the full documentation
see the smart_pointer page for the full documentation
const std::string & get_domain_name() const
size_type get_component_index() const
space_act(const std::string &dom_name, act_type act)
space_act(const space_act &x)
static const size_type unset_index
space_act(const std::string &dom_name, size_type i_comp, act_type act)
act_type get_act() const
void append_external_dof(const geo_basic< T, M > &dom, std::set< size_type > &ext_dof_set, const distributor &dof_ownership, const distributor &start_by_component) const
const scalar_type & get_terminal() const
disarray< size_type, M > build_blocked_flag() const
space_constitution_terminal< T, M > scalar_type
void set_ios_permutations(disarray< size_type, M > &idof2ios_dis_idof, disarray< size_type, M > &ios_idof2dis_idof) const
const basis_basic< T > & get_basis() const
const geo_basic< T, M > & get_background_geo() const
std::array< size_type, reference_element::max_variant > _loc_ndof
void put(std::ostream &out, size_type level=0) const
std::vector< value_type > hierarchy_type
const valued_type & valued_tag() const
std::vector< distributor > _start_by_flattened_component
space_constitution_rep< T, M > this_type
void set_valued(const std::string &valued)
void build_blocked_flag_recursive(disarray< size_type, M > &blocked_flag, const std::vector< distributor > &start_by_component, size_type &i_comp) const
space_constant::valued_type valued_type
void _init_start_by_flattened_component(size_type &i_flat_comp, size_type &start_flat_comp_idof, size_type &dis_start_flat_comp_idof, std::vector< distributor > &start_by_flattened_component) const
void set_ios_permutation_recursion(disarray< size_type, M > &idof2ios_dis_idof, size_type &comp_start_idof, size_type &comp_start_dis_idof) const
hierarchy_type::iterator iterator
bool operator==(const space_constitution_rep< T, M > &V2) const
void assembly_dis_idof(const geo_basic< T, M > &dom, const geo_element &bgd_K, std::vector< geo_element::size_type > &dis_idof) const
space_constitution< T, M > value_type
void _assembly_dis_idof_recursive(const geo_basic< T, M > &dom, const geo_element &bgd_K, typename std::vector< geo_element::size_type >::iterator &dis_idof_t, const distributor &hier_ownership, const std::vector< distributor > &start_by_flattened_component, size_type &i_flat_comp) const
size_type loc_ndof(const reference_element &hat_K) const
const hierarchy_type & get_hierarchy() const
hierarchy_type::const_iterator const_iterator
std::vector< distributor > _start_by_component
space_constitution< T, M > & operator[](size_type i_comp)
hierarchy_type::size_type size_type
const std::string & valued() const
const geo_basic< T, M > & get_geo() const
void set_valued_tag(valued_type valued_tag)
size_type assembly_loc_ndof(const geo_basic< T, M > &dom, const geo_element &bgd_K) const
const distributor & ownership() const
void compute_external_dofs(std::set< size_type > &ext_dof_set) const
void do_act(const space_act &act)
size_type comp_dis_idof2dis_idof(size_type i_comp, size_type comp_dis_idof) const
bool operator==(const space_constitution_terminal_rep< T, M > &V2) const
void set_ios_permutations(disarray< size_type, M > &idof2ios_dis_idof, disarray< size_type, M > &ios_idof2dis_idof) const
const basis_basic< T > & get_basis() const
container_type::const_iterator const_iterator
const geo_basic< T, M > & get_background_geo() const
space_constitution_terminal_rep(const space_constitution_terminal_rep< T, M > &scr)
void build_blocked_flag(disarray< size_type, M > &blocked_flag, const distributor &comp_ownership, const distributor &start_by_component) const
void set_basis(const basis_basic< T > &b)
void set_geo(const geo_basic< T, M > &omega)
const geo_basic< T, M > & get_geo() const
void set_ios_permutations(disarray< size_type, M > &idof2ios_dis_idof, disarray< size_type, M > &ios_idof2dis_idof) const
const basis_basic< T > & get_basis() const
const geo_basic< T, M > & get_background_geo() const
void block(const domain_indirect_basic< M > &dom)
void unblock_n(const domain_indirect_basic< M > &dom)
void set_basis(const basis_basic< T > &b)
void set_geo(const geo_basic< T, M > &omega)
bool operator==(const space_constitution_terminal< T, M > &V2) const
void block_n(const domain_indirect_basic< M > &dom)
void unblock(const domain_indirect_basic< M > &dom)
space_constitution_terminal(const geo_basic< T, M > &omega, std::string approx)
const geo_basic< T, M > & get_geo() const
space_constitution_terminal_rep< T, M > rep
disarray< size_type, M > build_blocked_flag() const
rep::const_iterator const_iterator
bool operator==(const space_constitution< T, M > &V2) const
space_constitution_rep< T, M > rep
bool have_compact_support_inside_element() const
void set_ios_permutations(disarray< size_type, M > &idof2ios_dis_idof, disarray< size_type, M > &ios_idof2dis_idof) const
const basis_basic< T > & get_basis() const
const geo_basic< T, M > & get_background_geo() const
void block(const domain_indirect_basic< M > &dom)
const valued_type & valued_tag() const
space_constitution_terminal< T, M > & get_terminal()
rep::hierarchy_type hierarchy_type
void set_valued(const std::string &valued)
size_type loc_ndof(const reference_element &hat_K) const
space_constitution(const space_mult_list< T, M > &expr)
void unblock_n(const domain_indirect_basic< M > &dom)
void set_ios_permutation_recursion(disarray< size_type, M > &idof2ios_dis_idof, size_type &comp_start_idof, size_type &comp_start_dis_idof) const
size_type assembly_loc_ndof(const geo_basic< T, M > &dom, const geo_element &bgd_K) const
void set_hierarchy(bool hier=true)
void assembly_dis_idof(const geo_basic< T, M > &dom, const geo_element &bgd_K, std::vector< geo_element::size_type > &dis_idof) const
const space_constitution_terminal< T, M > & get_terminal() const
space_constitution(const geo_basic< T, M > &omega, std::string approx)
const hierarchy_type & get_hierarchy() const
void block_n(const domain_indirect_basic< M > &dom)
space_constitution< T, M > & operator[](size_type i_comp)
void unblock(const domain_indirect_basic< M > &dom)
size_type comp_dis_idof2dis_idof(size_type i_comp, size_type comp_dis_idof) const
const std::string & valued() const
const geo_basic< T, M > & get_geo() const
void set_valued_tag(valued_type valued_tag)
const distributor & ownership() const
void compute_external_dofs(std::set< size_type > &ext_dof_set) const
void do_act(const space_act &act)
#define trace_macro(message)
Definition dis_macros.h:111
Expr1::float_type T
Definition field_expr.h:230
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)
valued_type valued_tag(const std::string &name)
This file is part of Rheolef.
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition catchmark.h:88
Expr1::memory_type M