Rheolef  7.1
an efficient C++ finite element environment
domain_indirect.h
Go to the documentation of this file.
1 #ifndef _RHEOLEF_DOMAIN_INDIRECT_H
2 #define _RHEOLEF_DOMAIN_INDIRECT_H
3 
24 /*Class:domain_indirect
25 NAME: @code{domain_indirect} - a named part of a finite element mesh
26 @cindex mesh boundary
27 @clindex domain_indirect
28 DESCRIPTION:
29  @noindent
30  The @code{domain_indirect} class defines a container for a part of a
31  finite element mesh.
32  This describes the connectivity of edges or faces.
33  This class is useful for boundary condition setting.
34 IMPLEMENTATION NOTE:
35  The @code{domain} class is split into two parts.
36  The first one is the @code{domain_indirect} class, that contains the main
37  renumbering features: it acts as a indirect on a @code{geo} class(@pxref{geo class}).
38  The second one is the @code{domain} class, that simply contains two
39  smart_pointers: one on a @code{domain_indirect} and the second on the
40  @code{geo} where renumbering is acting.
41  Thus, the domain class develops a complete @code{geo}-like interface,
42  via the @code{geo_abstract_rep} pure virtual class derivation,
43  and can be used by the @code{space} class (@pxref{space class}).
44  The split between domain_indirect and domain is necessary,
45  because the @code{geo} class contains a list of domain_indirect.
46  It cannot contains a list of @code{domain} classes, that refers
47  to the geo class itself: a loop in reference counting
48  leads to a blocking situation in the automatic deallocation.
49 
50 DATE: 12 may 1997
51 End:
52 */
53 
54 #include "rheolef/disarray.h"
55 #include "rheolef/geo_element.h"
56 #include "rheolef/geo_element_indirect.h"
57 #include "rheolef/index_set.h"
58 
59 namespace rheolef {
60 
61 // foward declarations:
62 template <class U, class M> class geo_abstract_rep;
63 template <class U, class M> class geo_rep;
64 template <class U, class M> class geo_basic;
65 
66 // ==================================================================================
67 // 1) domain_indirect
68 // representation: domain_indirect_base_rep<M> and domain_indirect_rep<M>
69 // ==================================================================================
70 template <class M>
71 class domain_indirect_base_rep : public disarray<geo_element_indirect,M> {
72 public:
73 
74 // typedefs:
75 
79  typedef typename base::iterator iterator_ioige;
81 
82 // allocators:
83 
85  void resize (size_type n) { base::resize (n); }
86 
87  // build from a table of element indexes
88  domain_indirect_base_rep (const std::string& name, size_type map_dim,
89  const communicator& comm,
90  const std::vector<size_type>& ie_list);
91  void build_from_list (const std::string& name, size_type map_dim,
92  const communicator& comm,
93  const std::vector<size_type>& ie_list);
94 
95  // c := a union b with c=*this
96  void build_union (
99 
100 // accessors & modifiers:
101 
102  size_type size() const { return base::size(); }
103  size_type dis_size() const { return base::dis_size(); }
104 
105  const_iterator_ioige ioige_begin() const { return base::begin(); }
106  const_iterator_ioige ioige_end() const { return base::end(); }
107  iterator_ioige ioige_begin() { return base::begin(); }
108  iterator_ioige ioige_end() { return base::end(); }
109 
110  const geo_element_indirect& oige (size_type ioige) const { return base::operator[] (ioige); }
111 
112  std::string name () const { return _name; }
113  size_type map_dimension () const { return _map_dim; }
114  void set_name (std::string name) { _name = name; }
116  bool is_broken() const { return _is_broken; }
117  void set_broken(bool b) { _is_broken = b; }
118 protected:
119 // data:
120  std::string _name;
122  bool _is_broken; // for e.g. "sides" or "internal_sides"
123 };
124 template <class M>
125 inline
128  _name(),
129  _map_dim(0),
130  _is_broken(false)
131 {
132 }
133 template<class M>
134 inline
136  const std::string& name,
138  const communicator& comm,
139  const std::vector<size_type>& ie_list)
141  _name(),
142  _map_dim(),
143  _is_broken(false)
144 {
145  build_from_list (name, map_dim, comm, ie_list);
146 }
147 // ---------------------------------------------------------------------
148 template <class M> class domain_indirect_rep {};
149 
150 template<>
152 public:
153 
154 // typedefs:
155 
161 
162 // allocators:
163 
165 
167  const std::string& name,
169  const communicator& comm,
170  const std::vector<size_type>& ie_list)
171  : domain_indirect_base_rep<sequential>(name, map_dim, comm, ie_list) {}
172 
173  void resize (size_type n) { base::resize (n); }
174 
175  // c := a union b with c=*this
176  void build_union (
179 
180 // accessors:
181 
182  size_type size() const { return base::size(); }
183  size_type dis_size() const { return base::dis_size(); }
184 
185  const_iterator_ioige ioige_begin() const { return base::ioige_begin(); }
186  const_iterator_ioige ioige_end() const { return base::ioige_end(); }
187  iterator_ioige ioige_begin() { return base::ioige_begin(); }
188  iterator_ioige ioige_end() { return base::ioige_end(); }
189 
190  const geo_element_indirect& oige (size_type ioige) const {
191  return base::oige (ioige); }
192 
193  void set_name (std::string name) { base::set_name(name); }
194  void set_map_dimension (size_type map_dim) { base::set_map_dimension(map_dim); }
195  std::string name () const { return base::name(); }
196  size_type map_dimension () const { return base::map_dimension(); }
197  bool is_broken() const { return base::is_broken(); }
198  void set_broken(bool b) { base::set_broken(b); }
199 
200 // i/o:
201 
202  template<class U>
203  void build_from_data (
204  const geo_rep<U,sequential>& omega,
206  d_tmp,
207  std::vector<index_set>* ball);
208 
209  template <class U>
210  idiststream& get (
211  idiststream& ips,
212  const geo_rep<U,sequential>& omega,
213  std::vector<index_set>* ball);
214 
215  odiststream& put (odiststream& ops) const;
216 };
217 // c := a union b with c=*this
218 inline
219 void
223 {
225 }
226 // ---------------------------------------------------------------------
227 #ifdef _RHEOLEF_HAVE_MPI
228 template<>
230 public:
231 
232 // typedefs:
233 
239 
240 // allocators:
241 
243 
244  template<class T>
246  const geo_abstract_rep<T,distributed>& omega,
247  const std::string& name,
249  const communicator& comm,
250  const std::vector<size_type>& ie_list);
251 
252  template<class T>
253  void init_ios (const geo_abstract_rep<T,distributed>& omega);
254 
255  // c := a union b with c=*this
256  template<class T>
257  void build_union (
258  const geo_basic<T,distributed>& omega,
261 
262 // accessors & modifiers:
263 
264  size_type size() const { return base::size(); }
265  size_type dis_size() const { return base::dis_size(); }
266 
267  const geo_element_indirect& oige (size_type ioige) const {
268  return base::oige (ioige); }
269 
270  void set_name (std::string name) { base::set_name(name); }
271  void set_map_dimension (size_type map_dim) { base::set_map_dimension(map_dim); }
272  std::string name () const { return base::name(); }
273  size_type map_dimension () const { return base::map_dimension(); }
274  bool is_broken() const { return base::is_broken(); }
275  void set_broken(bool b) { base::set_broken(b); }
276 
277 // distributed specific acessors:
278 
279  const distributor& ini_ownership () const { return _ini_ioige2dis_ioige.ownership(); }
280  size_type ioige2ini_dis_ioige (size_type ioige) const { return _ioige2ini_dis_ioige [ioige]; }
281  size_type ini_ioige2dis_ioige (size_type ini_ioige) const { return _ini_ioige2dis_ioige [ini_ioige]; }
282 
283 // i/o:
284 
285  template <class U>
286  idiststream& get (idiststream& ips, const geo_rep<U,distributed>& omega);
287  template <class U>
288  odiststream& put (odiststream& ops, const geo_rep<U,distributed>& omega) const;
289 
290 protected:
291  template <class U1,class M1> friend class geo_rep; // for geo_rep::build_from_domain
292 // data:
295 };
296 inline
299  _ioige2ini_dis_ioige(),
300  _ini_ioige2dis_ioige()
301 {
302 }
303 template<class T>
304 inline
306  const geo_abstract_rep<T,distributed>& omega,
307  const std::string& name,
309  const communicator& comm,
310  const std::vector<size_type>& ie_list)
311  : domain_indirect_base_rep<distributed>(name, map_dim, comm, ie_list),
312  _ioige2ini_dis_ioige(),
313  _ini_ioige2dis_ioige()
314 {
315  init_ios (omega);
316 }
317 // c := a union b with c=*this
318 template<class T>
319 inline
320 void
322  const geo_basic<T,distributed>& omega,
325 {
327  init_ios (omega.data());
328 }
329 #endif // _RHEOLEF_HAVE_MPI
330 // ====================================================================
331 // 2) wrapper: domain_indirect_basic<M>
332 // ====================================================================
334 template <class M = rheo_default_memory_model>
336 public:
337 };
338 typedef domain_indirect_basic<rheo_default_memory_model> domain_indirect;
339 // ---------------------------------------------------------------------
340 //<verbatim:
341 template <>
342 class domain_indirect_basic<sequential> : public smart_pointer<domain_indirect_rep<sequential> > {
343 public:
344 
345 // typedefs:
346 
352 
353 // allocators:
354 
356 
357  template <class T>
359  const geo_abstract_rep<T,sequential>& omega,
360  const std::string& name,
362  const communicator& comm,
363  const std::vector<size_type>& ie_list);
364 
365  template <class T>
367  const geo_basic<T,sequential>& omega,
368  const std::string& name,
370  const communicator& comm,
371  const std::vector<size_type>& ie_list);
372 
373  template <class U>
376  d_tmp,
377  const geo_basic<U, sequential>& omega,
378  std::vector<index_set>* ball);
379 
380  void resize (size_type n);
381 
382 // accessors:
383 
384  size_type size() const;
385  size_type dis_size() const;
386  const distributor& ownership() const;
387 
388  const_iterator_ioige ioige_begin() const;
389  const_iterator_ioige ioige_end() const;
390  iterator_ioige ioige_begin();
391  iterator_ioige ioige_end();
392 
393  const geo_element_indirect& oige (size_type ioige) const;
394 
395  void set_name (std::string name);
396  void set_map_dimension (size_type map_dim);
397  std::string name () const;
398  size_type map_dimension () const;
399  bool is_broken() const;
400  void set_broken(bool b);
401 
402 // i/o:
403 
404  odiststream& put (odiststream&) const;
405  template <class T>
406  idiststream& get (idiststream& ips, const geo_rep<T,sequential>& omega, std::vector<index_set> *ball);
407 };
408 //>verbatim:
409 inline
411  : smart_pointer<rep> (new_macro(rep))
412 {
413 }
414 template<class T>
415 inline
417  const geo_basic<T,sequential>& omega,
418  const std::string& name,
420  const communicator& comm,
421  const std::vector<size_type>& ie_list)
422  : smart_pointer<rep> (new_macro(rep(name, map_dim, comm, ie_list)))
423 {
424 }
425 template<class T>
426 inline
428  const geo_abstract_rep<T,sequential>& omega,
429  const std::string& name,
431  const communicator& comm,
432  const std::vector<size_type>& ie_list)
433  : smart_pointer<rep> (new_macro(rep(name, map_dim, comm, ie_list)))
434 {
435 }
436 inline
437 void
439 {
440  return base::data().resize (n);
441 }
442 inline
445 {
446  return base::data().size();
447 }
448 inline
451 {
452  return base::data().dis_size();
453 }
454 inline
455 const distributor&
457 {
458  return base::data().ownership();
459 }
460 inline
463 {
464  return base::data().oige (ioige);
465 }
466 inline
469 {
470  return base::data().ioige_begin();
471 }
472 inline
475 {
476  return base::data().ioige_end();
477 }
478 inline
481 {
482  return base::data().ioige_begin();
483 }
484 inline
487 {
488  return base::data().ioige_end();
489 }
490 inline
491 std::string
493 {
494  return base::data().name();
495 }
496 inline
499 {
500  return base::data().map_dimension();
501 }
502 inline
503 bool
505 {
506  return base::data().is_broken();
507 }
508 inline
509 void
511 {
512  base::data().set_broken(b);
513 }
514 inline
515 void
517 {
518  return base::data().set_name (name);
519 }
520 inline
521 void
523 {
524  return base::data().set_map_dimension (map_dim);
525 }
526 inline
529 {
530  return base::data().put (ops);
531 }
532 template<class T>
533 inline
534 idiststream&
536  idiststream& ips,
537  const geo_rep<T,sequential>& omega,
538  std::vector<index_set> *ball)
539 {
540  return base::data().template get (ips, omega, ball);
541 }
542 // union:
543 template<class T>
544 inline
547  const geo_basic<T,sequential>& omega,
550 {
552  c.data().build_union (a.data(), b.data());
553  return c;
554 }
555 // ---------------------------------------------------------------------
556 #ifdef _RHEOLEF_HAVE_MPI
557 //<verbatim:
558 template <>
559 class domain_indirect_basic<distributed> : public smart_pointer<domain_indirect_rep<distributed> > {
560 public:
561 
562 // typedefs:
563 
569 
570 // allocators:
571 
573  template<class T>
575  const geo_basic<T,distributed>& omega,
576  const std::string& name,
578  const communicator& comm,
579  const std::vector<size_type>& ie_list);
580 
581  template<class T>
583  const geo_abstract_rep<T,distributed>& omega,
584  const std::string& name,
586  const communicator& comm,
587  const std::vector<size_type>& ie_list);
588 
589 // accessors/modifiers:
590 
591  size_type size() const;
592  size_type dis_size() const;
593  const distributor& ownership() const;
594 
595  const geo_element_indirect& oige (size_type ioige) const;
596 
597  void set_name (std::string name);
598  void set_map_dimension (size_type map_dim);
599  std::string name () const;
600  size_type map_dimension () const;
601  bool is_broken() const;
602  void set_broken(bool b);
603 
604 // distributed specific acessors:
605 
606  const_iterator_ioige ioige_begin() const;
607  const_iterator_ioige ioige_end() const;
608  iterator_ioige ioige_begin();
609  iterator_ioige ioige_end();
610 
611  const distributor& ini_ownership() const;
612  size_type ioige2ini_dis_ioige (size_type ioige) const;
613  size_type ini_ioige2dis_ioige (size_type ini_ioige) const;
614 
615 // i/o:
616 
617  template <class T>
618  idiststream& get (idiststream& ips, const geo_rep<T,distributed>& omega);
619  template <class T>
620  odiststream& put (odiststream& ops, const geo_rep<T,distributed>& omega) const;
621 };
622 //>verbatim:
623 
624 inline
626  : smart_pointer<rep> (new_macro(rep))
627 {
628 }
629 template<class T>
630 inline
632  const geo_basic<T,distributed>& omega,
633  const std::string& name,
635  const communicator& comm,
636  const std::vector<size_type>& ie_list)
637  : smart_pointer<rep> (new_macro(rep(omega.data(), name, map_dim, comm, ie_list)))
638 {
639 }
640 template<class T>
641 inline
643  const geo_abstract_rep<T,distributed>& omega,
644  const std::string& name,
646  const communicator& comm,
647  const std::vector<size_type>& ie_list)
648  : smart_pointer<rep> (new_macro(rep(omega, name, map_dim, comm, ie_list)))
649 {
650 }
651 inline
654 {
655  return base::data().size();
656 }
657 inline
660 {
661  return base::data().dis_size();
662 }
663 inline
664 const distributor&
666 {
667  return base::data().ownership();
668 }
669 template<class T>
670 inline
671 idiststream&
673  idiststream& ips,
674  const geo_rep<T,distributed>& omega)
675 {
676  return base::data().template get (ips, omega);
677 }
678 template<class T>
679 inline
682  odiststream& ops,
683  const geo_rep<T,distributed>& omega) const
684 {
685  return base::data().template put (ops, omega);
686 }
687 inline
688 std::string
690 {
691  return base::data().name();
692 }
693 inline
696 {
697  return base::data().map_dimension();
698 }
699 inline
700 void
702 {
703  return base::data().set_name (name);
704 }
705 inline
706 void
708 {
709  return base::data().set_map_dimension (map_dim);
710 }
711 inline
712 bool
714 {
715  return base::data().is_broken();
716 }
717 inline
718 void
720 {
721  base::data().set_broken(b);
722 }
723 inline
726 {
727  return base::data().oige (ioige);
728 }
729 inline
732 {
733  return base::data().ioige_begin();
734 }
735 inline
738 {
739  return base::data().ioige_end();
740 }
741 inline
744 {
745  return base::data().ioige_begin();
746 }
747 inline
750 {
751  return base::data().ioige_end();
752 }
753 inline
754 const distributor&
756 {
757  return base::data().ini_ownership();
758 }
759 inline
762 {
763  return base::data().ioige2ini_dis_ioige (ioige);
764 }
765 inline
768 {
769  return base::data().ini_ioige2dis_ioige (ini_ioige);
770 }
771 // union:
772 template<class T>
773 inline
776  const geo_basic<T,distributed>& omega,
779 {
781  c.data().build_union (omega, a.data(), b.data());
782  return c;
783 }
784 
785 #endif // _RHEOLEF_HAVE_MPI
786 
787 } // namespace rheolef
788 #endif // _RHEOLEF_DOMAIN_INDIRECT_H
rheolef::domain_indirect_rep< distributed >::size
size_type size() const
Definition: domain_indirect.h:264
rheolef::domain_indirect_rep< distributed >::const_iterator_ioige
base::const_iterator_ioige const_iterator_ioige
Definition: domain_indirect.h:237
rheolef::domain_indirect_rep< distributed >::name
std::string name() const
Definition: domain_indirect.h:272
rheolef::domain_indirect_base_rep::build_from_list
void build_from_list(const std::string &name, size_type map_dim, const communicator &comm, const std::vector< size_type > &ie_list)
Definition: domain_indirect_seq.cc:32
rheolef::domain_indirect_rep< sequential >::map_dimension
size_type map_dimension() const
Definition: domain_indirect.h:196
rheolef::geo_basic
generic mesh with rerefence counting
Definition: domain_indirect.h:64
rheolef::domain_indirect_base_rep::const_iterator_ioige
base::const_iterator const_iterator_ioige
Definition: domain_indirect.h:80
rheolef::domain_indirect_base_rep::size
size_type size() const
Definition: domain_indirect.h:102
put
void put(idiststream &in, odiststream &out, bool do_proj, bool do_lumped_mass, bool def_fill_opt, size_type extract_id, const Float &scale_value, const std::pair< Float, Float > &u_range, render_type render)
Definition: branch.cc:500
rheolef::domain_indirect_base_rep::ioige_end
const_iterator_ioige ioige_end() const
Definition: domain_indirect.h:106
rheolef::domain_indirect_basic< sequential >::rep
domain_indirect_rep< sequential > rep
Definition: domain_indirect.h:347
rheolef::domain_indirect_rep< sequential >::is_broken
bool is_broken() const
Definition: domain_indirect.h:197
rheolef::domain_indirect_base_rep::orientation_type
geo_element_indirect::orientation_type orientation_type
Definition: domain_indirect.h:78
rheolef::domain_indirect_basic< sequential >::base
smart_pointer< rep > base
Definition: domain_indirect.h:348
rheolef::domain_indirect_rep< sequential >::set_name
void set_name(std::string name)
Definition: domain_indirect.h:193
rheolef::domain_indirect_rep< distributed >::map_dimension
size_type map_dimension() const
Definition: domain_indirect.h:273
rheolef::domain_indirect_base_rep::build_union
void build_union(const domain_indirect_base_rep< M > &a, const domain_indirect_base_rep< M > &b)
Definition: domain_indirect_seq.cc:55
rheolef::domain_indirect_rep< distributed >::iterator_ioige
base::iterator_ioige iterator_ioige
Definition: domain_indirect.h:236
rheolef::domain_indirect_rep< sequential >::base
domain_indirect_base_rep< sequential > base
Definition: domain_indirect.h:156
rheolef::domain_indirect_rep< distributed >::_ioige2ini_dis_ioige
disarray< size_type, distributed > _ioige2ini_dis_ioige
Definition: domain_indirect.h:293
rheolef::put
void put(std::ostream &out, std::string name, const tiny_matrix< T > &a)
Definition: tiny_lu.h:155
rheolef::domain_indirect_base_rep::set_map_dimension
void set_map_dimension(size_type map_dim)
Definition: domain_indirect.h:115
rheolef::geo_rep< T, distributed >
distributed mesh representation
Definition: geo.h:929
rheolef::domain_indirect_base_rep::_map_dim
size_type _map_dim
Definition: domain_indirect.h:121
rheolef::geo_rep< T, sequential >
Definition: geo.h:786
rheolef::domain_indirect_basic< distributed >::size_type
rep::size_type size_type
Definition: domain_indirect.h:566
rheolef::sequential
Definition: distributed.h:28
rheolef::domain_indirect_basic< sequential >::size_type
rep::size_type size_type
Definition: domain_indirect.h:349
rheolef::domain_indirect_base_rep::is_broken
bool is_broken() const
Definition: domain_indirect.h:116
rheolef::domain_indirect_rep< distributed >::ini_ioige2dis_ioige
size_type ini_ioige2dis_ioige(size_type ini_ioige) const
Definition: domain_indirect.h:281
rheolef::domain_indirect_base_rep::set_name
void set_name(std::string name)
Definition: domain_indirect.h:114
rheolef::domain_indirect_basic< sequential >::iterator_ioige
rep::iterator_ioige iterator_ioige
Definition: domain_indirect.h:350
rheolef::domain_indirect_basic< sequential >::const_iterator_ioige
rep::const_iterator_ioige const_iterator_ioige
Definition: domain_indirect.h:351
rheolef::disarray< geo_element_indirect, distributed >::const_iterator
rep::base::const_iterator const_iterator
Definition: disarray.h:465
rheolef::domain_indirect_rep< sequential >::dis_size
size_type dis_size() const
Definition: domain_indirect.h:183
rheolef::distributor
see the distributor page for the full documentation
Definition: distributor.h:62
rheolef::domain_indirect_base_rep::map_dimension
size_type map_dimension() const
Definition: domain_indirect.h:113
rheolef::domain_indirect_rep< distributed >::is_broken
bool is_broken() const
Definition: domain_indirect.h:274
rheolef::domain_indirect_rep< sequential >::set_map_dimension
void set_map_dimension(size_type map_dim)
Definition: domain_indirect.h:194
rheolef::geo_rep
sequential mesh representation
Definition: domain_indirect.h:63
mkgeo_ball.c
c
Definition: mkgeo_ball.sh:153
rheolef::domain_indirect_rep< sequential >::name
std::string name() const
Definition: domain_indirect.h:195
rheolef::geo_element_auto
Definition: geo_element.h:99
rheolef::domain_indirect_rep< sequential >::set_broken
void set_broken(bool b)
Definition: domain_indirect.h:198
rheolef::domain_indirect_base_rep::dis_size
size_type dis_size() const
Definition: domain_indirect.h:103
rheolef::domain_indirect_rep< sequential >::iterator_ioige
base::iterator_ioige iterator_ioige
Definition: domain_indirect.h:158
rheolef::domain_indirect_rep< distributed >::ini_ownership
const distributor & ini_ownership() const
Definition: domain_indirect.h:279
rheolef::build_union
domain_indirect_basic< distributed > build_union(const geo_basic< T, distributed > &omega, const domain_indirect_basic< distributed > &a, const domain_indirect_basic< distributed > &b)
Definition: domain_indirect.h:775
rheolef::geo_element_indirect
Definition: geo_element_indirect.h:32
rheolef::domain_indirect_base_rep::size_type
geo_element_indirect::size_type size_type
Definition: domain_indirect.h:77
rheolef::domain_indirect_rep< sequential >::ioige_end
iterator_ioige ioige_end()
Definition: domain_indirect.h:188
rheolef::domain_indirect_rep< sequential >::ioige_begin
iterator_ioige ioige_begin()
Definition: domain_indirect.h:187
rheolef::domain_indirect_basic< distributed >::rep
domain_indirect_rep< distributed > rep
Definition: domain_indirect.h:564
rheolef::domain_indirect_base_rep::_is_broken
bool _is_broken
Definition: domain_indirect.h:122
rheolef::disarray< geo_element_indirect, distributed >::size_type
rep::base::size_type size_type
Definition: disarray.h:463
rheolef::domain_indirect_rep< sequential >::ioige_begin
const_iterator_ioige ioige_begin() const
Definition: domain_indirect.h:185
rheolef::smart_pointer
see the smart_pointer page for the full documentation
Definition: smart_pointer.h:351
rheolef::domain_indirect_base_rep::base
disarray< geo_element_indirect, M > base
Definition: domain_indirect.h:76
rheolef::domain_indirect_basic< distributed >
Definition: domain_indirect.h:559
rheolef::domain_indirect_rep< distributed >::orientation_type
base::orientation_type orientation_type
Definition: domain_indirect.h:238
rheolef::geo_basic< T, sequential >
Definition: geo.h:1108
rheolef::geo_basic< T, distributed >
distributed mesh with rerefence counting
Definition: geo.h:1367
rheolef::domain_indirect_base_rep::ioige_begin
iterator_ioige ioige_begin()
Definition: domain_indirect.h:107
rheolef::domain_indirect_base_rep::domain_indirect_base_rep
domain_indirect_base_rep()
Definition: domain_indirect.h:126
rheolef::disarray< geo_element_indirect, distributed >::iterator
rep::base::iterator iterator
Definition: disarray.h:464
rheolef::geo_element_indirect::orientation_type
short int orientation_type
Definition: geo_element_indirect.h:38
rheolef::domain_indirect_base_rep::set_broken
void set_broken(bool b)
Definition: domain_indirect.h:117
a
Definition: diffusion_isotropic.h:25
rheolef::distributed
Definition: distributed.h:88
rheolef::domain_indirect_rep< distributed >::base
domain_indirect_base_rep< distributed > base
Definition: domain_indirect.h:234
rheolef::geo_abstract_rep
abstract interface class
Definition: domain_indirect.h:62
rheolef::domain_indirect_basic< distributed >::base
smart_pointer< rep > base
Definition: domain_indirect.h:565
rheolef::geo_abstract_rep< T, sequential >
Definition: geo.h:404
rheolef::domain_indirect_rep< sequential >::size_type
base::size_type size_type
Definition: domain_indirect.h:157
rheolef::domain_indirect_rep< sequential >::oige
const geo_element_indirect & oige(size_type ioige) const
Definition: domain_indirect.h:190
rheolef::domain_indirect_base_rep::ioige_begin
const_iterator_ioige ioige_begin() const
Definition: domain_indirect.h:105
rheolef::domain_indirect_rep< distributed >::dis_size
size_type dis_size() const
Definition: domain_indirect.h:265
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
rheolef::domain_indirect_rep< distributed >::set_name
void set_name(std::string name)
Definition: domain_indirect.h:270
rheolef::smart_pointer_base::data
const T & data() const
Definition: smart_pointer.h:266
rheolef::domain_indirect_rep< sequential >::domain_indirect_rep
domain_indirect_rep(const std::string &name, size_type map_dim, const communicator &comm, const std::vector< size_type > &ie_list)
Definition: domain_indirect.h:166
rheolef::domain_indirect_basic< distributed >::iterator_ioige
rep::iterator_ioige iterator_ioige
Definition: domain_indirect.h:567
rheolef::domain_indirect_rep< distributed >::oige
const geo_element_indirect & oige(size_type ioige) const
Definition: domain_indirect.h:267
rheolef::odiststream
odiststream: see the diststream page for the full documentation
Definition: diststream.h:126
rheolef::disarray
see the disarray page for the full documentation
Definition: disarray.h:459
rheolef::domain_indirect_rep< distributed >::size_type
base::size_type size_type
Definition: domain_indirect.h:235
rheolef::domain_indirect_rep< sequential >::size
size_type size() const
Definition: domain_indirect.h:182
rheolef::domain_indirect_basic< sequential >
Definition: domain_indirect.h:342
rheolef::domain_indirect_basic< distributed >::const_iterator_ioige
rep::const_iterator_ioige const_iterator_ioige
Definition: domain_indirect.h:568
mkgeo_ball.b
b
Definition: mkgeo_ball.sh:152
rheolef::domain_indirect_base_rep::name
std::string name() const
Definition: domain_indirect.h:112
rheolef::domain_indirect_rep< distributed >
Definition: domain_indirect.h:229
rheolef::domain_indirect_base_rep::iterator_ioige
base::iterator iterator_ioige
Definition: domain_indirect.h:79
rheolef::geo_element_indirect::size_type
size_t size_type
Definition: geo_element_indirect.h:37
rheolef::geo_abstract_rep< T, distributed >
Definition: geo.h:457
mkgeo_ball.n
n
Definition: mkgeo_ball.sh:150
rheolef::domain_indirect_rep< distributed >::set_map_dimension
void set_map_dimension(size_type map_dim)
Definition: domain_indirect.h:271
rheolef::domain_indirect_base_rep::ioige_end
iterator_ioige ioige_end()
Definition: domain_indirect.h:108
rheolef::domain_indirect_base_rep::resize
void resize(size_type n)
Definition: domain_indirect.h:85
size_type
field::size_type size_type
Definition: branch.cc:425
rheolef::domain_indirect_rep< sequential >
Definition: domain_indirect.h:151
rheolef::domain_indirect_rep< sequential >::orientation_type
base::orientation_type orientation_type
Definition: domain_indirect.h:160
rheolef::domain_indirect_rep< distributed >::ioige2ini_dis_ioige
size_type ioige2ini_dis_ioige(size_type ioige) const
Definition: domain_indirect.h:280
rheolef::domain_indirect_base_rep::oige
const geo_element_indirect & oige(size_type ioige) const
Definition: domain_indirect.h:110
mkgeo_ball.map_dim
map_dim
Definition: mkgeo_ball.sh:337
rheolef::domain_indirect_rep< distributed >::_ini_ioige2dis_ioige
disarray< size_type, distributed > _ini_ioige2dis_ioige
Definition: domain_indirect.h:294
rheolef::domain_indirect
domain_indirect_basic< rheo_default_memory_model > domain_indirect
Definition: domain_indirect.h:338
rheolef::domain_indirect_base_rep
Definition: domain_indirect.h:71
rheolef::domain_indirect_rep< sequential >::ioige_end
const_iterator_ioige ioige_end() const
Definition: domain_indirect.h:186
rheolef::domain_indirect_basic
the finite element boundary domain
Definition: domain_indirect.h:335
rheolef::domain_indirect_rep< sequential >::domain_indirect_rep
domain_indirect_rep()
Definition: domain_indirect.h:164
rheolef::build_union
domain_indirect_basic< sequential > build_union(const geo_basic< T, sequential > &omega, const domain_indirect_basic< sequential > &a, const domain_indirect_basic< sequential > &b)
Definition: domain_indirect.h:546
rheolef::domain_indirect_rep< sequential >::resize
void resize(size_type n)
Definition: domain_indirect.h:173
rheolef::domain_indirect_base_rep::_name
std::string _name
Definition: domain_indirect.h:120
mkgeo_contraction.name
name
Definition: mkgeo_contraction.sh:133
M
Expr1::memory_type M
Definition: vec_expr_v2.h:385
rheolef::domain_indirect_rep< distributed >::set_broken
void set_broken(bool b)
Definition: domain_indirect.h:275
rheolef::domain_indirect_rep
Definition: domain_indirect.h:148
rheolef::domain_indirect_rep< sequential >::const_iterator_ioige
base::const_iterator_ioige const_iterator_ioige
Definition: domain_indirect.h:159