Rheolef  7.1
an efficient C++ finite element environment
geo.h
Go to the documentation of this file.
1 #ifndef _RHEOLEF_GEO_H
2 #define _RHEOLEF_GEO_H
3 //
4 // This file is part of Rheolef.
5 //
6 // Copyright (C) 2000-2009 Pierre Saramito <Pierre.Saramito@imag.fr>
7 //
8 // Rheolef is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 2 of the License, or
11 // (at your option) any later version.
12 //
13 // Rheolef is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
17 //
18 // You should have received a copy of the GNU General Public License
19 // along with Rheolef; if not, write to the Free Software
20 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 //
22 // =========================================================================
23 // author: Pierre.Saramito@imag.fr
24 // date: 20 april 2013
25 
26 namespace rheolef {
93 } // namespace rheolef
94 
95 /*
96  Implementation note: geo = mesh data structure
97 
98  geo is an alias to geo_basic<T,M>
99  T: the current Float representation (e.g. double)
100  M: the memory model (sequential or distributed)
101  the default memory model has been chosen by the configure script
102 
103  geo_basic<T,M> is a smart_pointer_clone<geo_abstract_rep<T,M> >
104  i.e. a pointer with shallow copy semantic on a pure virtual base class geo_abstract_rep<T,M>
105  used by polymorphic hierarchy of classes.
106 
107  there are three concrete variants for this base class:
108  geo_rep<T,M> : for usual meshes, as omega
109  geo_domain_indirect_rep<T,M> : for usual boundary domains, as gamma=omega["boundary"]
110  geo_domain_rep<T,M> : for compacted boundary domains, as gamma=omega["boundary"]
111  used when defining a space on a boundary domain, as
112  space W (omega["boundary"], "P1");
113  => elements and vertex are renumbered in a compact form
114  for easy P1 dofs numbering.
115 
116  Most code is shared by these three classes and by the sequential/distributed variants.
117  This leads to the following hierarchy of classes:
118 
119  geo_abstract_base_rep<T> : virtual methods for M=seq
120  geo_abstract_rep<T,M> : M=seq,dis have separated impl; add methods for M=dis
121  geo_domain_indirect_base_rep<T,M>: data + methods for domains
122  geo_domain_indirect_rep<T,M> : M=seq,dis have separated impl; add methods for M=dis
123  geo_base_rep<T,M> : data + methods for geometry
124  geo_rep<T,M> : M=seq,dis have separated impl: add methods for M=dis
125  geo_domain_rep<T,M> : data + methods for compacted geometry on domain
126 */
127 
128 #include "rheolef/geo_element.h"
129 #include "rheolef/disarray.h"
130 #include "rheolef/hack_array.h"
131 #include "rheolef/geo_size.h"
132 #include "rheolef/point.h"
133 #include "rheolef/domain_indirect.h"
134 #include "rheolef/geo_header.h"
135 #include "rheolef/basis.h"
136 #include "rheolef/space_constant.h"
137 #include "rheolef/geo_locate.h"
138 #include "rheolef/geo_trace_ray_boundary.h"
139 #include "rheolef/geo_nearest.h"
140 #include "rheolef/rounder.h"
141 #include <unordered_map>
142 
143 namespace rheolef {
144 
145 namespace details {
146 
147 struct zero_dimension {}; // used by space IR
148 
149 } // namespace details
150 // =========================================================================
151 // point io helpers
152 // =========================================================================
154 template <class T>
155 struct _point_get {
157  _point_get (size_type d1) : d(d1) {}
159  std::istream& operator() (std::istream& is, point_basic<T>& x) { return x.get (is, d); }
160 };
162 template <class T>
163 struct _point_put {
165  _point_put (size_type d1) : d(d1) {}
167  std::ostream& operator() (std::ostream& os, const point_basic<T>& x) { return x.put (os, d); }
168 };
170 template <class T>
173  _round_point_put (size_type d1, const T& eps1) : d(d1), round(eps1) {}
176  std::ostream& operator() (std::ostream& os, const point_basic<T>& x) {
177  for (size_t i = 0; i < d; ++i) {
178  os << round(x[i]);
179  if (i+1 != d) os << " ";
180  }
181  return os;
182  }
183 };
184 
185 // forward declaration:
186 template <class T, class M> class geo_basic;
187 template <class T, class M> class geo_domain_indirect_rep;
188 
189 // =========================================================================
191 // =========================================================================
192 template<class T, class Ref, class Ptr, class IteratorByVariant>
193 struct geo_iterator {
196 
197 // typedefs
198 
199  // see std::deque<T>::iterator : TODO: complete to a full random iterator
200  typedef std::random_access_iterator_tag iterator_category;
201  typedef T value_type;
202  typedef Ptr pointer;
203  typedef Ref reference;
204  typedef typename T::size_type size_type;
205  typedef ptrdiff_t difference_type;
206 
207 // allocators:
208 
209  template<class Geo>
210  geo_iterator (size_type dim, size_type variant, IteratorByVariant iter, Geo& omega);
211  geo_iterator (const _nonconst_iterator& y); // conversion from iter to const_iter
212 
213 // accessors & modifiers:
214 
215  reference operator* () const { return *_iter_by_var; }
216  pointer operator->() const { return _iter_by_var.operator->(); }
217 
219  ++_iter_by_var;
221  return *this;
222  }
225  ++_variant; // then variant <= variant_max
226  if (_variant < _variant_max) {
228  }
229  }
230  }
231  _self operator++ (int) { _self tmp = *this; operator++(); return tmp; }
232 
233  bool operator== (const _self& y) const { return _variant == y._variant && _iter_by_var == y._iter_by_var; }
234  bool operator!= (const _self& y) const { return ! operator== (y); }
235 
236 // data:
237 
240  IteratorByVariant _iter_by_var;
243 };
244 // =========================================================================
246 // =========================================================================
247 template <class T>
249 public:
250 
251 // typedefs
252 
253  typedef enum {
254  geo = 0,
259 
264  typedef const geo_element& const_reference;
266  typedef std::map<size_type,geo_element_auto<>> geo_element_map_type;
267 
270  typedef geo_iterator<
271  geo_element,
272  geo_element&,
273  geo_element*,
276 
279  typedef geo_iterator<
280  geo_element,
281  const geo_element&,
282  const geo_element*,
285 
286 // allocators:
287 
290 
291 // abstract accessors:
292 
293  virtual size_type variant() const = 0;
294  virtual std::string name() const = 0;
295  virtual std::string familyname() const = 0;
296  virtual size_type dimension() const = 0;
297  virtual size_type serial_number() const = 0;
298  virtual size_type map_dimension() const = 0;
299  virtual bool is_broken() const = 0;
300  virtual coordinate_type coordinate_system() const = 0;
301  virtual const basis_basic<T>& get_piola_basis() const = 0;
302  virtual const node_type& xmin() const = 0;
303  virtual const node_type& xmax() const = 0;
304  virtual const T& hmin() const = 0;
305  virtual const T& hmax() const = 0;
306  virtual const geo_size& sizes() const = 0;
307  virtual const geo_size& ios_sizes() const = 0;
308 
309  virtual const distributor& geo_element_ownership (size_type dim) const = 0;
310  virtual const_reference get_geo_element (size_type dim, size_type ige) const = 0;
311  virtual const geo_element& bgd2dom_geo_element (const geo_element& bgd_K) const { return bgd_K; }
312  virtual const geo_element& dom2bgd_geo_element (const geo_element& dom_K) const { return dom_K; }
313  virtual size_type neighbour (size_type ie, size_type loc_isid) const = 0;
314  virtual void neighbour_guard() const = 0;
315 
319 
322 
323  virtual size_type n_node() const = 0;
324  virtual const node_type& node (size_type inod) const = 0;
325  virtual const node_type& dis_node (size_type dis_inod) const = 0;
326  virtual void dis_inod (const geo_element& K, std::vector<size_type>& dis_inod) const = 0;
327  virtual size_type dis_inod2dis_iv (size_type dis_inod) const = 0;
328 
329  virtual size_type n_domain_indirect () const = 0;
330  virtual bool have_domain_indirect (const std::string& name) const = 0;
331  virtual void reset_order (size_type order) = 0;
332 
333  virtual size_type seq_locate (
334  const point_basic<T>& x,
335  size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const = 0;
336  virtual size_type dis_locate (
337  const point_basic<T>& x,
338  size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const = 0;
339 
340  virtual size_type seq_trace_move (
341  const point_basic<T>& x,
342  const point_basic<T>& v,
343  point_basic<T>& y) const = 0;
344  virtual size_type dis_trace_move (
345  const point_basic<T>& x,
346  const point_basic<T>& v,
347  point_basic<T>& y) const = 0;
348 
349  virtual size_type seq_nearest (
350  const point_basic<T>& x,
351  point_basic<T>& x_nearest) const = 0;
352  virtual size_type dis_nearest (
353  const point_basic<T>& x,
354  point_basic<T>& x_nearest) const = 0;
355 
356 // virtual i/o:
357 
358  virtual odiststream& put (odiststream& ops) const = 0;
359  virtual bool check(bool verbose) const = 0;
360 
361 // deduced comparator:
362 
363  bool operator== (const geo_abstract_base_rep<T>& omega2) const {
364  return name() == omega2.name(); }
365 };
366 template<class T, class Ref, class Ptr, class IteratorByVariant>
367 template<class Geo>
369  size_type dim,
371  IteratorByVariant iter,
372  Geo& omega)
373  : _variant (variant),
374  _variant_max (reference_element::last_variant_by_dimension(dim)),
375  _iter_by_var (iter),
376  _first_by_var(),
377  _last_by_var()
378 {
381  _first_by_var [variant] = omega.begin_by_variant (variant);
382  _last_by_var [variant] = omega. end_by_variant (variant);
383  }
385 }
386 template<class T, class Ref, class Ptr, class IteratorByVariant>
388  : _variant (y._variant),
389  _variant_max (y._variant_max),
390  _iter_by_var (y._iter_by_var),
391  _first_by_var(),
392  _last_by_var()
393 {
396 }
397 // =========================================================================
399 // =========================================================================
400 template <class T, class M>
401 class geo_abstract_rep {};
402 
403 template <class T>
405 public:
406 
407 // typedefs
408 
410  typedef typename base::size_type size_type;
411  typedef typename base::node_type node_type;
413  typedef typename base::iterator iterator;
417  typedef typename base::reference reference;
418  typedef typename base::const_reference const_reference;
419 
420 // allocators:
421 
423  virtual geo_abstract_rep<T,sequential>* clone() const = 0;
424  virtual ~geo_abstract_rep () {}
425 
426 // abstract accessors:
427 
428  virtual const domain_indirect_basic<sequential>& get_domain_indirect (size_type i) const = 0;
429  virtual const domain_indirect_basic<sequential>& get_domain_indirect (const std::string& name) const = 0;
430  virtual void insert_domain_indirect (const domain_indirect_basic<sequential>& dom) const = 0;
431 
432  virtual const disarray<node_type,sequential>& get_nodes() const = 0;
433  virtual void set_nodes (const disarray<node_type,sequential>&) = 0;
434 
435  virtual void locate (
438  bool do_check = false) const = 0;
439  virtual void trace_ray_boundary (
444  bool do_check = false) const = 0;
445  virtual void trace_move (
449  disarray<point_basic<T>,sequential>& y) const = 0;
450  virtual void nearest (
452  disarray<point_basic<T>,sequential>& x_nearest,
453  disarray<size_type, sequential>& dis_ie) const = 0;
454 };
455 #ifdef _RHEOLEF_HAVE_MPI
456 template <class T>
458 public:
459 
460 // typedefs
461 
463  typedef typename base::size_type size_type;
464  typedef typename base::node_type node_type;
465  typedef typename base::const_reference const_reference;
466  typedef std::map <size_type, node_type, std::less<size_type>,
468 
469 // allocators:
470 
472  virtual geo_abstract_rep<T,distributed>* clone() const = 0;
473  virtual ~geo_abstract_rep () {}
474 
475 // abstract accessors:
476 
477  virtual distributor geo_element_ios_ownership (size_type dim) const = 0;
478  virtual const_reference dis_get_geo_element (size_type dim, size_type dis_ige) const = 0;
479  virtual size_type ige2ios_dis_ige (size_type dim, size_type ige) const = 0;
480  virtual size_type dis_ige2ios_dis_ige (size_type dim, size_type dis_ige) const = 0;
481  virtual size_type ios_ige2dis_ige (size_type dim, size_type ios_ige) const = 0;
482 
483  virtual const domain_indirect_basic<distributed>& get_domain_indirect (size_type i) const = 0;
484  virtual const domain_indirect_basic<distributed>& get_domain_indirect (const std::string& name) const = 0;
485  virtual void insert_domain_indirect (const domain_indirect_basic<distributed>& dom) const = 0;
486 
487  virtual const disarray<node_type,distributed>& get_nodes() const = 0;
488  virtual void set_nodes (const disarray<node_type,distributed>&) = 0;
489 
490  virtual void locate (
493  bool do_check = true) const = 0;
494  virtual void trace_ray_boundary (
499  bool do_check = false) const = 0;
500  virtual void trace_move (
504  disarray<point_basic<T>,distributed>& y) const = 0;
505  virtual void nearest (
507  disarray<point_basic<T>,distributed>& x_nearest,
508  disarray<size_type, distributed>& dis_ie) const = 0;
509 
510 // utility:
511 
512  virtual void set_ios_permutation (disarray<size_type,distributed>& idof2ios_dis_idof) const = 0;
513 
514  // used by space_constritution for ios numbering
515  virtual const std::array<disarray<size_type,distributed>,reference_element::max_variant>&
516  get_igev2ios_dis_igev() const = 0;
517 
518 };
519 #endif // _RHEOLEF_HAVE_MPI
520 // =========================================================================
522 // =========================================================================
523 // NOTE: since geo_rep<seq> contains sequential arrays for vertices and elts,
524 // the geo_rep<mpi> cannot derive from geo_rep<seq>. The solution is to
525 // derive both geo_rep<seq> and geo_rep<mpi> classes from a generic base class
526 // named geo_base_rep that takes the memory model (seq or mpi) as template argument.
527 template <class T, class M>
528 class geo_base_rep : public geo_abstract_rep<T,M> {
529 public:
530 // typedefs:
531 
533  typedef typename base::size_type size_type;
534  typedef typename base::node_type node_type;
536  typedef typename base::iterator iterator;
540  typedef typename base::reference reference;
541  typedef typename base::const_reference const_reference;
543 
544 // allocators:
545 
546  geo_base_rep ();
548 
549  void build_from_list (
550  const geo_basic<T,M>& lambda,
551  const disarray<point_basic<T>,M>& node_list,
553  reference_element::max_variant>& elt_list);
554 
555  ~geo_base_rep();
556 
557 // abstract accessors defined:
558 
560  std::string familyname() const { return _name; }
561  std::string name() const;
563  size_type dimension() const { return _dimension; }
564  size_type map_dimension() const { return _gs.map_dimension(); }
565  bool is_broken() const { return false; }
568  void set_name (std::string name) { _name = name; }
571  const basis_basic<T>& get_piola_basis() const { return _piola_basis; }
572  const node_type& xmin() const { return _xmin; }
573  const node_type& xmax() const { return _xmax; }
574  const T& hmin() const { return _hmin; }
575  const T& hmax() const { return _hmax; }
576  const geo_size& sizes() const { return _gs; }
577  const geo_size& ios_sizes() const { return _gs; }
578 
582 
587 
588  const node_type& node (size_type inod) const { return _node [inod]; }
589  const node_type& dis_node (size_type dis_inod) const { return _node.dis_at (dis_inod); }
590  const node_type& node (const geo_element& K, size_type loc_inod) const;
591  void dis_inod (const geo_element& K, std::vector<size_type>& dis_inod) const;
592  const disarray<node_type,M>& get_nodes() const { return _node; }
593 
594  void set_nodes (const disarray<node_type,M>& x) { _node = x; _node.reset_dis_indexes(); compute_bbox(); }
595  size_type n_domain_indirect () const { return _domains.size(); }
596  bool have_domain_indirect (const std::string& name) const;
598  const domain_indirect_basic<M>& get_domain_indirect (const std::string& name) const;
599  void insert_domain_indirect (const domain_indirect_basic<M>& dom) const;
600 
602  const point_basic<T>& x,
603  size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const;
605  const point_basic<T>& x,
606  size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const;
608  const point_basic<T>& x,
609  const point_basic<T>& v,
610  point_basic<T>& y) const;
612  const point_basic<T>& x,
613  const point_basic<T>& v,
614  point_basic<T>& y) const;
616  const point_basic<T>& x,
617  point_basic<T>& x_nearest) const;
619  const point_basic<T>& x,
620  point_basic<T>& x_nearest) const;
621 
622  size_type neighbour (size_type ie, size_type loc_isid) const;
623  void neighbour_guard() const;
624 
625 // additional accessors & modifier:
626 
630 
631 // deduced accessors:
632 
633  size_type size(size_type dim) const;
636  const distributor& vertex_ownership() const { return geo_element_ownership (0); }
637  const communicator& comm() const { return ownership().comm(); }
638  size_type order() const { return get_piola_basis().degree(); }
639 
640  size_type n_node() const { return _node. size(); }
641  size_type dis_n_node() const { return _node.dis_size(); }
642  size_type n_vertex() const { return size (0); }
643  size_type size() const { return size (map_dimension()); }
644  size_type dis_n_vertex() const { return dis_size (0); }
645  size_type dis_size() const { return dis_size (map_dimension()); }
646  size_type dis_n_edge() const { return dis_size (1); }
647  size_type dis_n_face() const { return dis_size (2); }
649  size_type dis_iv2dis_inod (size_type dis_iv) const;
650 
653 
654  const_iterator begin (size_type dim) const { return base::begin (dim); }
655  const_iterator end (size_type dim) const { return base::end (dim); }
656 
657  const_iterator begin() const { return base::begin (map_dimension()); }
658  const_iterator end() const { return base::end (map_dimension()); }
659 
660  const_iterator begin_edge() const { return base::begin (1); }
661  const_iterator end_edge() const { return base::end (1); }
662  const_iterator begin_face() const { return base::begin (2); }
663  const_iterator end_face() const { return base::end (2); }
664 
665 protected:
666  void compute_bbox();
667  void init_neighbour() const;
668  template<class U> friend void add_ball_externals (const geo_base_rep<U,M>&, const disarray<index_set,M>&);
669 
670  friend class geo_rep<T,M>;
671 
672 // data:
673 // 0) header:
674  std::string _name;
677 // 1) connectivity:
678  std::array<hack_array<geo_element_hack,M>, reference_element::max_variant> _geo_element;
679  geo_size _gs; // counters by geo_element dimension: 0,1,2,3
680  mutable std::vector<domain_indirect_basic<M> > _domains;
681  bool _have_connectivity; // e.g.list of edges in a 2d triangular mesh
682  mutable bool _have_neighbour; // inter-element connectivity
683 // 2) coordinates:
687  node_type _xmin; // bounding box
695 
696 // static data member: loaded geo table
697 public:
698  typedef std::unordered_map<std::string,void*> loaded_map_t;
699  static loaded_map_t& loaded_map();
700 protected:
702 };
703 template <class T, class M>
704 inline
705 void
707 {
708  if (_have_neighbour) return;
709  _have_neighbour = true;
710  init_neighbour();
711 }
712 template <class T, class M>
715 {
716  return _geo_element [variant].begin();
717 }
718 template <class T, class M>
721 {
722  return _geo_element [variant].begin();
723 }
724 template <class T, class M>
727 {
728  return _geo_element [variant].end();
729 }
730 template <class T, class M>
733 {
734  return _geo_element [variant].end();
735 }
737 template <class T, class M>
738 inline
741 {
743  iterator_by_variant iter = begin_by_variant (variant);
744  iterator res = iterator (dim, variant, iter, *this);
745  return res;
746 }
747 template <class T, class M>
748 inline
751 {
753  iterator_by_variant iter = end_by_variant (variant - 1);
754  iterator res = iterator (dim, variant, iter, *this);
755  return res;
756 }
757 template <class T>
758 inline
761 {
763  const_iterator_by_variant iter = begin_by_variant (variant);
764  return const_iterator (dim, variant, iter, *this);
765 }
766 template <class T>
767 inline
770 {
772  const_iterator_by_variant iter = end_by_variant (variant - 1);
773  return const_iterator (dim, variant, iter, *this);
774 }
775 // =========================================================================
777 // =========================================================================
778 template <class T, class M> class geo_rep {};
779 template <class T, class M>
781  geo_rep <T,M>& new_omega,
782  const geo_basic<T,M>& old_omega,
783  typename geo_rep<T,M>::size_type k);
784 
785 template <class T>
786 class geo_rep<T,sequential> : public geo_base_rep<T,sequential> {
787 public:
788 // typedefs:
789 
791  typedef typename base::size_type size_type;
792  typedef typename base::node_type node_type;
794  typedef typename base::reference reference;
795  typedef typename base::const_reference const_reference;
796  typedef typename base::iterator iterator;
802 
803 // allocators:
804 
805  geo_rep();
807  geo_abstract_rep<T,sequential>* clone() const;
808 
809  // build from_list (for level set)
810  geo_rep (
812  const disarray<point_basic<T>,sequential>& node_list,
814  reference_element::max_variant>& elt_list);
815 
816  void build_from_domain (
817  const domain_indirect_rep<sequential>& indirect,
818  const geo_abstract_rep<T,sequential>& omega,
819  std::map<size_type,size_type>& bgd_ie2dom_ie,
820  std::map<size_type,size_type>& dis_bgd_ie2dis_dom_ie);
821 
822 // abstract accessors redefined:
823 
824  void locate (
827  bool do_check = false) const;
828  void trace_ray_boundary (
833  bool do_check = false) const;
834  void trace_move (
839  void nearest (
841  disarray<point_basic<T>,sequential>& x_nearest,
842  disarray<size_type, sequential>& dis_ie) const;
843 
844 // herited accessors:
845 
846  size_type map_dimension () const { return base::map_dimension(); }
847  bool is_broken() const { return base::is_broken(); }
848  const distributor& geo_element_ownership(size_type dim) const { return base::geo_element_ownership (dim); }
849  const_reference get_geo_element (size_type dim, size_type ige) const { return base::get_geo_element (dim, ige); }
850  reference get_geo_element (size_type dim, size_type ige) { return base::get_geo_element (dim, ige); }
851  iterator begin (size_type dim) { return base::begin(dim); }
852  iterator end (size_type dim) { return base::end (dim); }
853  const_iterator begin (size_type dim) const { return base::begin(dim); }
854  const_iterator end (size_type dim) const { return base::end (dim); }
855  const geo_element_map_type& get_external_geo_element_map (size_type variant) const;
856 
857  const domain_indirect_basic<sequential>& get_domain_indirect (size_type idom) const { return base::get_domain_indirect (idom); }
858  const domain_indirect_basic<sequential>& get_domain_indirect (const std::string& name) const { return base::get_domain_indirect (name); }
859 
860 // deduced accessors:
861 
862  const distributor& vertex_ownership() const { return geo_element_ownership(0); }
863  const_reference operator[] (size_type ie) const { return get_geo_element (map_dimension(), ie); }
864  reference operator[] (size_type ie) { return get_geo_element (map_dimension(), ie); }
865 
866 // i/o:
867 
868  idiststream& get (idiststream&);
869  odiststream& put_geo (odiststream&) const;
870  odiststream& put (odiststream& ops) const { return put_geo(ops); }
871 
872  void dump (std::string name) const;
873  void load (std::string name, const communicator& = communicator());
874  bool check(bool verbose) const;
875 
876 // modifier:
877 
878  void reset_order (size_type order);
879  void build_by_subdividing (const geo_basic<T,sequential>& omega, size_type k);
880  void build_from_data (
881  const geo_header& hdr,
884  tmp_geo_element,
885  bool do_upgrade);
886 
887 // internal:
888 protected:
889  idiststream& get_standard (idiststream&, const geo_header&);
890  idiststream& get_upgrade (idiststream&, const geo_header&);
891  void build_connectivity (
893 
894  void build_connectivity_sides (
895  size_type side_dim,
897  void set_element_side_index (size_type side_dim);
898  void domain_set_side_part1 (
899  const domain_indirect_rep<sequential>& indirect,
900  const geo_abstract_rep<T,sequential>& bgd_omega,
901  size_type sid_dim,
902  disarray<size_type,sequential>& bgd_isid2dom_dis_isid,
903  disarray<size_type,sequential>& dom_isid2bgd_isid,
904  disarray<size_type,sequential>& dom_isid2dom_ios_dis_isid,
905  size_type size_by_variant [reference_element::max_variant]);
906  void domain_set_side_part2 (
907  const domain_indirect_rep<sequential>& indirect,
908  const geo_abstract_rep<T,sequential>& bgd_omega,
909  disarray<size_type,sequential>& bgd_iv2dom_dis_iv,
910  size_type sid_dim,
911  disarray<size_type,sequential>& bgd_isid2dom_dis_isid,
912  disarray<size_type,sequential>& dom_isid2bgd_isid,
913  disarray<size_type,sequential>& dom_isid2dom_ios_dis_isid,
914  size_type size_by_variant [reference_element::max_variant]);
915  void build_external_entities () {} // for distributed compat
916 
917 // friends:
918 
919  friend void geo_build_by_subdividing<> (
920  geo_rep<T,sequential>& new_omega,
921  const geo_basic<T,sequential>& old_omega,
923 };
924 #ifdef _RHEOLEF_HAVE_MPI
925 // =========================================================================
927 // =========================================================================
928 template <class T>
929 class geo_rep<T,distributed> : public geo_base_rep<T,distributed> {
930 public:
931 // typedefs:
932 
934  typedef typename base::size_type size_type;
935  typedef typename base::node_type node_type;
937  typedef typename base::node_map_type node_map_type;
938  typedef typename base::reference reference;
939  typedef typename base::const_reference const_reference;
940  typedef typename base::iterator iterator;
946 
947 // allocators:
948 
949  geo_rep ();
951  geo_abstract_rep<T,distributed>* clone() const;
952 
953  void build_from_domain (
954  const domain_indirect_rep<distributed>& indirect,
955  const geo_abstract_rep<T,distributed>& omega,
956  std::map<size_type,size_type>& bgd_ie2dom_ie,
957  std::map<size_type,size_type>& dis_bgd_ie2dis_dom_ie);
958 
959  // build from_list (for level set)
960  geo_rep (
962  const disarray<point_basic<T>,distributed>& node_list,
964  reference_element::max_variant>& elt_list);
965 
966 // abstract accessors defined:
967 
968  distributor geo_element_ios_ownership (size_type dim) const;
969 
970  size_type ige2ios_dis_ige (size_type dim, size_type ige) const;
971  size_type dis_ige2ios_dis_ige (size_type dim, size_type dis_ige) const;
972  size_type ios_ige2dis_ige (size_type dim, size_type ios_ige) const;
973  const geo_size& ios_sizes() const { return _ios_gs; }
974  void locate (
977  bool do_check = false) const;
978  void trace_ray_boundary (
983  bool do_check = false) const;
984  void trace_move (
989  void nearest (
991  disarray<point_basic<T>,distributed>& x_nearest,
992  disarray<size_type, distributed>& dis_ie) const;
993 
994 // herited accessors:
995 
996  size_type map_dimension () const { return base::map_dimension(); }
997  bool is_broken() const { return base::is_broken(); }
998  size_type size (size_type dim) const { return base::size(dim); }
999  const distributor& geo_element_ownership(size_type dim) const { return base::geo_element_ownership (dim); }
1000  const_reference get_geo_element (size_type dim, size_type ige) const { return base::get_geo_element (dim, ige); }
1001  reference get_geo_element (size_type dim, size_type ige) { return base::get_geo_element (dim, ige); }
1002 
1003  const_iterator begin (size_type dim) const { return base::begin(dim); }
1004  const_iterator end (size_type dim) const { return base::end (dim); }
1005  iterator begin (size_type dim) { return base::begin(dim); }
1006  iterator end (size_type dim) { return base::end (dim); }
1008  { return base::_geo_element[variant].get_dis_map_entries(); }
1009 
1010  const domain_indirect_basic<distributed>& get_domain_indirect (size_type idom) const { return base::get_domain_indirect (idom); }
1011  const domain_indirect_basic<distributed>& get_domain_indirect (const std::string& name) const { return base::get_domain_indirect (name); }
1012 
1013 // deduced accessors:
1014 
1015  size_type size () const { return size (map_dimension()); }
1016  const distributor& vertex_ownership() const { return geo_element_ownership(0); }
1017  const_reference operator[] (size_type ie) const { return get_geo_element (map_dimension(), ie); }
1018 #ifdef TODO
1019  reference operator[] (size_type ie) { return get_geo_element (map_dimension(), ie); }
1020 #endif // TODO
1021 
1022 // modifier:
1023 
1024  void reset_order (size_type order);
1025  void build_by_subdividing (const geo_basic<T,distributed>& omega, size_type k);
1026 
1027 // i/o:
1028 
1029  idiststream& get (idiststream&);
1030  odiststream& put (odiststream&) const;
1031  void dump (std::string name) const;
1032  void load (std::string name, const communicator& comm);
1033  bool check(bool verbose) const;
1034 
1035 // utilities:
1036 
1037  void set_ios_permutation (disarray<size_type,distributed>& idof2ios_dis_idof) const;
1038 
1039 protected:
1040 // internal:
1041  void build_external_entities ();
1042  void set_element_side_index (size_type side_dim);
1043  void domain_set_side_part1 (
1044  const domain_indirect_rep<distributed>& indirect,
1045  const geo_abstract_rep<T,distributed>& bgd_omega,
1046  size_type sid_dim,
1047  disarray<size_type>& bgd_isid2dom_dis_isid,
1048  disarray<size_type>& dom_isid2bgd_isid,
1049  disarray<size_type>& dom_isid2dom_ios_dis_isid,
1050  size_type size_by_variant [reference_element::max_variant]);
1051  void domain_set_side_part2 (
1052  const domain_indirect_rep<distributed>& indirect,
1053  const geo_abstract_rep<T,distributed>& bgd_omega,
1054  disarray<size_type>& bgd_iv2dom_dis_iv,
1055  size_type sid_dim,
1056  disarray<size_type>& bgd_isid2dom_dis_isid,
1057  disarray<size_type>& dom_isid2bgd_isid,
1058  disarray<size_type>& dom_isid2dom_ios_dis_isid,
1059  size_type size_by_variant [reference_element::max_variant]);
1060 
1061  void node_renumbering (const distributor& ios_node_ownership);
1062 
1063 // data:
1064  disarray<size_type> _inod2ios_dis_inod; // permutation for node
1065  disarray<size_type> _ios_inod2dis_inod; // reverse permutation for node
1066  std::array<disarray<size_type>, 4> _ios_ige2dis_ige; // reverse permutation for geo_element[dim]
1068  std::array<disarray<size_type,distributed>,reference_element::max_variant> _igev2ios_dis_igev;
1069  std::array<disarray<size_type,distributed>,reference_element::max_variant> _ios_igev2dis_igev;
1070 
1071 public:
1072  // used by space_constritution for ios numbering
1073  const std::array<disarray<size_type,distributed>,reference_element::max_variant>&
1074  get_igev2ios_dis_igev() const { return _igev2ios_dis_igev; }
1075 
1076 // friends:
1077 
1078  friend void geo_build_by_subdividing<> (
1079  geo_rep<T,distributed>& new_omega,
1080  const geo_basic<T,distributed>& old_omega,
1082 };
1083 #endif // _RHEOLEF_HAVE_MPI
1084 
1085 // =========================================================================
1087 // =========================================================================
1088 template <class T, class M = rheo_default_memory_model>
1089 class geo_basic {
1090 public:
1091  typedef M memory_type;
1092 };
1093 // =========================================================================
1095 // =========================================================================
1096 // handler for complex geo names as "square[boundary]"
1097 template<class T, class M> geo_basic<T,M> geo_load (const std::string& name);
1098 
1099 // guards for omega.boundary(), omega.internal_sides() and omega.sides()
1100 template<class T, class M> void boundary_guard (const geo_basic<T,M>&);
1101 template<class T, class M> void internal_sides_guard (const geo_basic<T,M>&);
1102 template<class T, class M> void sides_guard (const geo_basic<T,M>&);
1103 
1104 // [verbatim_geo_basic]
1107 template <class T>
1108 class geo_basic<T,sequential> : public smart_pointer_clone<geo_abstract_rep<T,sequential> > {
1109 public:
1110 
1111 // typedefs:
1112 
1117  typedef typename rep::size_type size_type;
1118  typedef typename rep::node_type node_type;
1120  typedef typename rep::reference reference;
1122  typedef typename rep::iterator iterator;
1128 
1129 // allocators:
1130 
1131  geo_basic ();
1132  geo_basic (std::string name, const communicator& comm = communicator());
1133  void load (std::string name, const communicator& comm = communicator());
1135 
1136  // build from_list (for level set)
1139  const disarray<point_basic<T>,sequential>& node_list,
1141  reference_element::max_variant>& elt_list)
1142  : base (new_macro(rep_geo_rep(lambda,node_list,elt_list))) {}
1143 
1144 // accessors:
1145 
1146  std::string name() const { return base::data().name(); }
1147  std::string familyname() const { return base::data().familyname(); }
1148  size_type dimension() const { return base::data().dimension(); }
1149  size_type map_dimension() const { return base::data().map_dimension(); }
1150  bool is_broken() const { return base::data().is_broken(); }
1151  size_type serial_number() const { return base::data().serial_number(); }
1152  size_type variant() const { return base::data().variant(); }
1153  coordinate_type coordinate_system() const { return base::data().coordinate_system(); }
1155  const basis_basic<T>& get_piola_basis() const { return base::data().get_piola_basis(); }
1156  size_type order() const { return base::data().get_piola_basis().degree(); }
1157  const node_type& xmin() const { return base::data().xmin(); }
1158  const node_type& xmax() const { return base::data().xmax(); }
1159  const T& hmin() const { return base::data().hmin(); }
1160  const T& hmax() const { return base::data().hmax(); }
1161  const distributor& geo_element_ownership(size_type dim) const { return base::data().geo_element_ownership(dim); }
1162  const geo_size& sizes() const { return base::data().sizes(); }
1163  const geo_size& ios_sizes() const { return base::data().ios_sizes(); }
1164  const_reference get_geo_element (size_type dim, size_type ige) const { return base::data().get_geo_element (dim, ige); }
1166  { return get_geo_element (dim, dis_ige); }
1167  const geo_element& bgd2dom_geo_element (const geo_element& bgd_K) const { return base::data().bgd2dom_geo_element (bgd_K); }
1168  const geo_element& dom2bgd_geo_element (const geo_element& dom_K) const { return base::data().dom2bgd_geo_element (dom_K); }
1169  size_type neighbour (size_type ie, size_type loc_isid) const {
1170  return base::data().neighbour (ie, loc_isid); }
1171  void neighbour_guard() const { base::data().neighbour_guard(); }
1172  size_type n_node() const { return base::data().n_node(); }
1173  const node_type& node(size_type inod) const { return base::data().node(inod); }
1174  const node_type& dis_node(size_type dis_inod) const { return base::data().dis_node(dis_inod); }
1175  void dis_inod (const geo_element& K, std::vector<size_type>& dis_inod) const {
1176  return base::data().dis_inod(K,dis_inod); }
1177  const disarray<node_type,sequential>& get_nodes() const { return base::data().get_nodes(); }
1178  size_type dis_inod2dis_iv (size_type dis_inod) const { return base::data().dis_inod2dis_iv(dis_inod); }
1179 
1180  size_type n_domain_indirect () const { return base::data().n_domain_indirect (); }
1181  bool have_domain_indirect (const std::string& name) const { return base::data().have_domain_indirect (name); }
1183  return base::data().get_domain_indirect (i); }
1184  const domain_indirect_basic<sequential>& get_domain_indirect (const std::string& name) const {
1185  return base::data().get_domain_indirect (name); }
1187  base::data().insert_domain_indirect (dom); }
1188 
1189  size_type n_domain () const { return base::data().n_domain_indirect (); }
1190  geo_basic<T,sequential> get_domain (size_type i) const;
1191  geo_basic<T,sequential> operator[] (const std::string& name) const;
1193  geo_basic<T,sequential> internal_sides() const;
1195 
1196 // modifiers:
1197 
1198  void set_name (std::string name);
1199  void set_dimension (size_type dim);
1200  void set_serial_number (size_type i);
1201  void reset_order (size_type order);
1202  void set_coordinate_system (coordinate_type sys_coord);
1203  void set_coordinate_system (std::string sys_coord_name) { set_coordinate_system (space_constant::coordinate_system(sys_coord_name)); }
1204  void set_nodes (const disarray<node_type,sequential>& x);
1205 
1206 // extended accessors:
1207 
1208  const communicator& comm() const { return geo_element_ownership (0).comm(); }
1209  size_type size(size_type dim) const { return base::data().geo_element_ownership(dim).size(); }
1210  size_type dis_size(size_type dim) const { return base::data().geo_element_ownership(dim).dis_size(); }
1211  size_type size() const { return size (map_dimension()); }
1212  size_type dis_size() const { return dis_size (map_dimension()); }
1213  size_type n_vertex() const { return size (0); }
1214  size_type dis_n_vertex() const { return dis_size (0); }
1215  const_reference operator[] (size_type ie) const { return get_geo_element (map_dimension(), ie); }
1216  const_iterator begin (size_type dim) const { return base::data().begin(dim); }
1217  const_iterator end (size_type dim) const { return base::data().end (dim); }
1218  const_iterator begin () const { return begin(map_dimension()); }
1219  const_iterator end () const { return end (map_dimension()); }
1220 
1221 // comparator:
1222 
1223  bool operator== (const geo_basic<T,sequential>& omega2) const { return base::data().operator== (omega2.data()); }
1224 
1225 // i/o:
1226 
1227  void save (std::string filename = "") const;
1228 // [verbatim_geo_basic]
1229 
1230 // internals:
1231  geo_basic (details::zero_dimension, const communicator& comm = communicator());
1232  bool check (bool verbose = true) const { return base::data().check(verbose); }
1233  idiststream& get (idiststream& ips);
1234  odiststream& put (odiststream& ops) const;
1235 
1236  void build_by_subdividing (const geo_basic<T,sequential>& omega, size_type k);
1237  void build_from_data (
1238  const geo_header& hdr,
1239  const disarray<node_type, sequential>& node,
1241  tmp_geo_element,
1242  bool do_upgrade);
1243 
1244  // locators:
1246  const point_basic<T>& x,
1247  size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const
1248  { return base::data().seq_locate (x, dis_ie_guest); }
1250  const point_basic<T>& x,
1251  size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const
1252  { return base::data().dis_locate (x, dis_ie_guest); }
1253  void locate (
1254  const disarray<point_basic<T>, sequential>& x,
1255  disarray<size_type, sequential>& dis_ie) const
1256  { return base::data().locate (x, dis_ie); }
1258  const point_basic<T>& x,
1259  const point_basic<T>& v,
1260  point_basic<T>& y) const
1261  { return base::data().seq_trace_move (x,v,y); }
1263  const point_basic<T>& x,
1264  const point_basic<T>& v,
1265  point_basic<T>& y) const
1266  { return base::data().dis_trace_move (x,v,y); }
1272  { return base::data().trace_ray_boundary (x,v,dis_ie,y); }
1273  void trace_move (
1278  { return base::data().trace_move (x,v,dis_ie,y); }
1280  const point_basic<T>& x,
1281  point_basic<T>& x_nearest) const
1282  { return base::data().seq_nearest (x, x_nearest); }
1284  const point_basic<T>& x,
1285  point_basic<T>& x_nearest) const
1286  { return base::data().dis_nearest (x, x_nearest); }
1287  void nearest (
1289  disarray<point_basic<T>,sequential>& x_nearest,
1290  disarray<size_type, sequential>& dis_ie) const
1291  { base::data().nearest (x, x_nearest, dis_ie); }
1292 
1294  { return base::data().begin_by_variant (variant); }
1296  { return base::data(). end_by_variant (variant); }
1298  { return base::data().get_external_geo_element_map(variant); }
1299 
1300  const geo_basic<T,sequential>& get_background_geo() const; // code in geo_domain.h
1301  geo_basic<T,sequential> get_background_domain() const;
1302 
1303  // for compatibility with distributed interface:
1304  size_type ige2ios_dis_ige (size_type dim, size_type ige) const { return ige; }
1305  size_type dis_ige2ios_dis_ige (size_type dim, size_type dis_ige) const { return dis_ige; }
1306  size_type ios_ige2dis_ige (size_type dim, size_type ios_ige) const { return ios_ige; }
1307  void set_ios_permutation (disarray<size_type,sequential>& idof2ios_dis_idof) const {}
1308 
1309 // [verbatim_geo_basic_cont]
1310 };
1311 template <class T, class M>
1312 idiststream& operator>> (idiststream& ips, geo_basic<T,M>& omega);
1313 
1314 template <class T, class M>
1315 odiststream& operator<< (odiststream& ops, const geo_basic<T,M>& omega);
1316 // [verbatim_geo_basic_cont]
1317 
1318 template <class T>
1319 inline
1321  : base (new_macro((geo_rep<T,sequential>)))
1322 {
1323 }
1324 template <class T>
1325 inline
1326 geo_basic<T,sequential>::geo_basic (std::string name, const communicator& comm)
1327  : base (0)
1328 {
1329  base::operator= (geo_load<T,sequential>(name));
1330 }
1331 template <class T>
1332 inline
1333 void
1334 geo_basic<T,sequential>::load (std::string name, const communicator& comm)
1335 {
1336  base::operator= (geo_load<T,sequential>(name));
1337 }
1338 template <class T>
1339 inline
1342 {
1343  boundary_guard (*this);
1344  return operator[] ("boundary");
1345 }
1346 template <class T>
1347 inline
1350 {
1351  internal_sides_guard (*this);
1352  return operator[] ("internal_sides");
1353 }
1354 template <class T>
1355 inline
1358 {
1359  sides_guard (*this);
1360  return operator[] ("sides");
1361 }
1362 #ifdef _RHEOLEF_HAVE_MPI
1363 // =========================================================================
1365 // =========================================================================
1366 template <class T>
1367 class geo_basic<T,distributed> : public smart_pointer_clone<geo_abstract_rep<T,distributed> > {
1368 public:
1369 
1370 // typedefs:
1371 
1376  typedef typename rep::size_type size_type;
1377  typedef typename rep::node_type node_type;
1380  typedef typename rep::reference reference;
1382  typedef typename rep::iterator iterator;
1388 
1389 // allocators:
1390 
1391  geo_basic ();
1392  geo_basic (std::string name, const communicator& comm = communicator());
1393  void load (std::string name, const communicator& comm = communicator());
1395  geo_basic (details::zero_dimension, const communicator& comm = communicator());
1396 
1397  // build from_list (for level set)
1400  const disarray<point_basic<T>,distributed>& node_list,
1402  reference_element::max_variant>& elt_list)
1403  : base (new_macro(rep_geo_rep(lambda,node_list,elt_list))) {}
1404 
1405 // accessors:
1406 
1407  std::string name() const { return base::data().name(); }
1408  std::string familyname() const { return base::data().familyname(); }
1409  size_type dimension() const { return base::data().dimension(); }
1410  size_type map_dimension() const { return base::data().map_dimension(); }
1411  bool is_broken() const { return base::data().is_broken(); }
1412  size_type serial_number() const { return base::data().serial_number(); }
1413  size_type variant() const { return base::data().variant(); }
1414  coordinate_type coordinate_system() const { return base::data().coordinate_system(); }
1416  const basis_basic<T>& get_piola_basis() const { return base::data().get_piola_basis(); }
1417  size_type order() const { return base::data().get_piola_basis().degree(); }
1418  const node_type& xmin() const { return base::data().xmin(); }
1419  const node_type& xmax() const { return base::data().xmax(); }
1420  const T& hmin() const { return base::data().hmin(); }
1421  const T& hmax() const { return base::data().hmax(); }
1423  { return base::data().geo_element_ownership (dim); }
1424  const geo_size& sizes() const { return base::data().sizes(); }
1425  const geo_size& ios_sizes() const { return base::data().ios_sizes(); }
1427  { return base::data().get_geo_element (dim, ige); }
1429  { return base::data().dis_get_geo_element (dim, dis_ige); }
1430  const geo_element& bgd2dom_geo_element (const geo_element& bgd_K) const
1431  { return base::data().bgd2dom_geo_element (bgd_K); }
1432  const geo_element& dom2bgd_geo_element (const geo_element& dom_K) const
1433  { return base::data().dom2bgd_geo_element (dom_K); }
1434  size_type neighbour (size_type ie, size_type loc_isid) const {
1435  return base::data().neighbour (ie, loc_isid); }
1436  void neighbour_guard() const { base::data().neighbour_guard(); }
1438  return base::data().geo_element_ios_ownership (dim); }
1440  return base::data().ige2ios_dis_ige (dim,ige); }
1442  return base::data().dis_ige2ios_dis_ige (dim,dis_ige); }
1444  return base::data().ios_ige2dis_ige (dim, ios_ige); }
1445  size_type n_node() const { return base::data().n_node(); }
1446  const node_type& node(size_type inod) const { return base::data().node(inod); }
1447  const node_type& dis_node(size_type dis_inod) const { return base::data().dis_node(dis_inod); }
1448  void dis_inod (const geo_element& K, std::vector<size_type>& dis_inod) const {
1449  return base::data().dis_inod(K,dis_inod); }
1450  const disarray<node_type,distributed>& get_nodes() const { return base::data().get_nodes(); }
1451 
1452  size_type n_domain_indirect () const { return base::data().n_domain_indirect (); }
1453  bool have_domain_indirect (const std::string& name) const { return base::data().have_domain_indirect (name); }
1455  return base::data().get_domain_indirect (i); }
1457  return base::data().get_domain_indirect (name); }
1459  base::data().insert_domain_indirect (dom); }
1460 
1461  size_type n_domain () const { return base::data().n_domain_indirect (); }
1462  geo_basic<T,distributed> get_domain (size_type i) const;
1463  geo_basic<T,distributed> operator[] (const std::string& name) const;
1465  geo_basic<T,distributed> internal_sides() const;
1467 
1469  const point_basic<T>& x,
1470  size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const
1471  { return base::data().seq_locate (x, dis_ie_guest); }
1473  const point_basic<T>& x,
1474  size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const
1475  { return base::data().dis_locate (x, dis_ie_guest); }
1477  { return base::data().locate (x, dis_ie); }
1479  const point_basic<T>& x,
1480  const point_basic<T>& v,
1481  point_basic<T>& y) const
1482  { return base::data().seq_trace_move (x,v,y); }
1484  const point_basic<T>& x,
1485  const point_basic<T>& v,
1486  point_basic<T>& y) const
1487  { return base::data().dis_trace_move (x,v,y); }
1493  { return base::data().trace_ray_boundary (x,v,dis_ie,y); }
1494  void trace_move (
1499  { return base::data().trace_move (x,v,dis_ie,y); }
1501  const point_basic<T>& x,
1502  point_basic<T>& x_nearest) const
1503  { return base::data().seq_nearest (x, x_nearest); }
1505  const point_basic<T>& x,
1506  point_basic<T>& x_nearest) const
1507  { return base::data().dis_nearest (x, x_nearest); }
1508  void nearest (
1510  disarray<point_basic<T>,distributed>& x_nearest,
1511  disarray<size_type, distributed>& dis_ie) const
1512  { base::data().nearest (x, x_nearest, dis_ie); }
1513 // modifiers:
1514 
1515  void set_nodes (const disarray<node_type,distributed>& x);
1516  void reset_order (size_type order);
1517  size_type dis_inod2dis_iv (size_type dis_inod) const { return base::data().dis_inod2dis_iv(dis_inod); }
1518  void set_coordinate_system (coordinate_type sys_coord);
1519  void set_coordinate_system (std::string sys_coord_name) { set_coordinate_system (space_constant::coordinate_system(sys_coord_name)); }
1520  void set_dimension (size_type dim);
1521  void set_serial_number (size_type i);
1522  void set_name (std::string name);
1523  void build_by_subdividing (const geo_basic<T,distributed>& omega, size_type k);
1524 
1525 // extended accessors:
1526 
1527  size_type size(size_type dim) const { return base::data().geo_element_ownership(dim).size(); }
1528  size_type dis_size(size_type dim) const { return base::data().geo_element_ownership(dim).dis_size(); }
1529  const communicator& comm() const { return geo_element_ownership (0).comm(); }
1530  size_type size() const { return size (map_dimension()); }
1531  size_type dis_size() const { return dis_size (map_dimension()); }
1532  size_type n_vertex() const { return size (0); }
1533  size_type dis_n_vertex() const { return dis_size (0); }
1534  const_reference operator[] (size_type ie) const
1535  { return get_geo_element (map_dimension(), ie); }
1536 
1537  const_iterator begin (size_type dim) const { return base::data().begin(dim); }
1538  const_iterator end (size_type dim) const { return base::data().end (dim); }
1539  const_iterator begin () const { return begin(map_dimension()); }
1540  const_iterator end () const { return end (map_dimension()); }
1541 
1543  { return base::data().begin_by_variant (variant); }
1545  { return base::data(). end_by_variant (variant); }
1547  { return base::data().get_external_geo_element_map(variant); }
1548 
1549  const geo_basic<T,distributed>& get_background_geo() const; // code in geo_domain.h
1550  geo_basic<T,distributed> get_background_domain() const;
1551 
1552 // comparator:
1553 
1554  bool operator== (const geo_basic<T,distributed>& omega2) const { return base::data().operator== (omega2.data()); }
1555 
1556 // i/o:
1557 
1558  odiststream& put (odiststream& ops) const { return base::data().put (ops); }
1559  idiststream& get (idiststream& ips);
1560  void save (std::string filename = "") const;
1561  bool check (bool verbose = true) const { return base::data().check(verbose); }
1562 
1563 // utilities:
1564 
1566  { base::data().set_ios_permutation (idof2ios_dis_idof); }
1567 
1568  // used by space_constritution for ios numbering
1569  const std::array<disarray<size_type,distributed>,reference_element::max_variant>&
1570  get_igev2ios_dis_igev() const { return base::data().get_igev2ios_dis_igev(); }
1571 };
1572 #endif // _RHEOLEF_HAVE_MPI
1573 
1574 // [verbatim_geo]
1576 // [verbatim_geo]
1577 
1578 // ==============================================================================
1579 // inlined: geo<T,distributed>
1580 // ==============================================================================
1581 #ifdef _RHEOLEF_HAVE_MPI
1582 template <class T>
1583 inline
1585  : base (new_macro((geo_rep<T,distributed>)))
1586 {
1587 }
1588 template <class T>
1589 inline
1590 geo_basic<T,distributed>::geo_basic (std::string name, const communicator& comm)
1591  : base (0)
1592 {
1593  base::operator= (geo_load<T,distributed>(name));
1594 }
1595 template <class T>
1596 inline
1597 void
1598 geo_basic<T,distributed>::load (std::string name, const communicator& comm)
1599 {
1600  base::operator= (geo_load<T,distributed>(name));
1601 }
1602 template <class T>
1603 inline
1604 idiststream&
1606 {
1607  // allocate a new geo_rep object (TODO: do a dynamic_cast ?)
1608  geo_rep<T,distributed>* ptr = new_macro((geo_rep<T,distributed>));
1609  ptr->get (ips);
1610  base::operator= (ptr);
1611  return ips;
1612 }
1613 template <class T>
1614 inline
1617 {
1618  boundary_guard (*this);
1619  return operator[] ("boundary");
1620 }
1621 template <class T>
1622 inline
1625 {
1626  internal_sides_guard (*this);
1627  return operator[] ("internal_sides");
1628 }
1629 template <class T>
1630 inline
1633 {
1634  sides_guard (*this);
1635  return operator[] ("sides");
1636 }
1637 #endif // _RHEOLEF_HAVE_MPI
1638 
1639 // ==============================================================================
1640 // inlined: geo<T,M>
1641 // ==============================================================================
1642 template <class T, class M>
1643 inline
1644 idiststream&
1645 operator>> (idiststream& ips, geo_basic<T,M>& omega)
1646 {
1647  return omega.get (ips);
1648 }
1649 template <class T, class M>
1650 inline
1651 odiststream&
1653 {
1654  return omega.put (ops);
1655 }
1656 
1657 } // namespace rheolef
1658 #endif // _RHEOLEF_GEO_H
1659 
1660 #ifdef _RHEOLEF_GEO_DEMO_TST_CC
1661 // demo for the geo class documentation
1662 using namespace rheolef;
1663 using namespace std;
1664 int main(int argc, char**argv) {
1665  environment rheolef (argc, argv);
1666  geo omega (argv[1]);
1667  // [verbatim_geo_demo_tst]
1668  cout << omega.size() << " " << omega.n_node() << endl;
1669  for (size_t i = 0, n = omega.size(); i < n; ++i) {
1670  const geo_element& K = omega[i];
1671  cout << K.name();
1672  for (size_t j = 0, m = K.size(); j < m; ++j)
1673  cout << " " << K[j];
1674  cout << endl;
1675  }
1676  for (size_t jv = 0, nv = omega.n_node(); jv < nv; ++jv)
1677  cout << omega.node(jv) << endl;
1678  // [verbatim_geo_demo_tst]
1679 }
1680 #endif // _RHEOLEF_GEO_DEMO_TST_CC
rheolef::reference_element::last_variant_by_dimension
static variant_type last_variant_by_dimension(size_type dim)
Definition: reference_element.h:150
rheolef::geo_basic< T, distributed >::coordinate_system_name
std::string coordinate_system_name() const
Definition: geo.h:1415
rheolef::geo_base_rep::familyname
std::string familyname() const
Definition: geo.h:560
rheolef::hack_array::iterator
std::vector< T, A >::iterator iterator
Definition: hack_array.h:350
rheolef::geo_domain_indirect_rep
Definition: geo.h:187
rheolef::geo_base_rep::dis_iv2dis_inod
size_type dis_iv2dis_inod(size_type dis_iv) const
Definition: geo.cc:572
rheolef::geo_rep< T, distributed >::map_dimension
size_type map_dimension() const
Definition: geo.h:996
rheolef::geo_basic< T, sequential >::end
const_iterator end() const
Definition: geo.h:1219
rheolef::space_constant::coordinate_system_name
std::string coordinate_system_name(coordinate_type i)
Definition: space_constant.cc:69
rheolef::geo_rep< T, sequential >::node_type
base::node_type node_type
Definition: geo.h:792
rheolef::geo_basic< T, sequential >::begin
const_iterator begin(size_type dim) const
Definition: geo.h:1216
rheolef::geo_basic< T, distributed >::order
size_type order() const
Definition: geo.h:1417
rheolef::geo_base_rep::size_type
base::size_type size_type
Definition: geo.h:533
rheolef::geo_basic< T, sequential >::dis_locate
size_type dis_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
Definition: geo.h:1249
rheolef::geo_rep< T, sequential >::vertex_ownership
const distributor & vertex_ownership() const
Definition: geo.h:862
rheolef::geo_basic< T, sequential >::hmax
const T & hmax() const
Definition: geo.h:1160
rheolef::geo_iterator::operator->
pointer operator->() const
Definition: geo.h:216
rheolef::geo_basic< T, distributed >::iterator
rep::iterator iterator
Definition: geo.h:1382
rheolef::geo_basic< T, M >
rheolef::geo_base_rep::_sys_coord
coordinate_type _sys_coord
Definition: geo.h:686
rheolef::geo_base_rep::dis_n_vertex
size_type dis_n_vertex() const
Definition: geo.h:644
rheolef::geo_base_rep::set_name
void set_name(std::string name)
Definition: geo.h:568
rheolef::geo_basic< T, distributed >::dis_size
size_type dis_size() const
Definition: geo.h:1531
rheolef::geo_base_rep::set_coordinate_system
void set_coordinate_system(coordinate_type sys_coord)
Definition: geo.h:567
rheolef::geo_iterator::_last_by_var
IteratorByVariant _last_by_var[reference_element::max_variant]
Definition: geo.h:242
rheolef::geo_base_rep::xmin
const node_type & xmin() const
Definition: geo.h:572
rheolef::_point_put::_point_put
_point_put(size_type d1)
Definition: geo.h:165
rheolef::geo_basic< T, distributed >::memory_type
distributed memory_type
Definition: geo.h:1372
rheolef::geo_basic< T, distributed >::name
std::string name() const
Definition: geo.h:1407
rheolef::geo_basic< T, sequential >::get_geo_element
const_reference get_geo_element(size_type dim, size_type ige) const
Definition: geo.h:1164
rheolef::geo_base_rep::const_iterator
base::const_iterator const_iterator
Definition: geo.h:537
rheolef::geo_basic< T, distributed >::geo_element_map_type
rep::geo_element_map_type geo_element_map_type
Definition: geo.h:1387
rheolef::_round_point_put::_round_point_put
_round_point_put(size_type d1, const T &eps1)
Definition: geo.h:173
rheolef::geo_base_rep::_gs
geo_size _gs
Definition: geo.h:679
rheolef::geo_rep< T, sequential >::const_reference
base::const_reference const_reference
Definition: geo.h:795
rheolef::_round_point_put::round
rounder_type< T > round
Definition: geo.h:175
rheolef::geo_abstract_base_rep::have_domain_indirect
virtual bool have_domain_indirect(const std::string &name) const =0
rheolef::geo_base_rep::hmax
const T & hmax() const
Definition: geo.h:575
rheolef::geo_abstract_base_rep::max_variant
@ max_variant
Definition: geo.h:257
rheolef::geo_base_rep::n_domain_indirect
size_type n_domain_indirect() const
Definition: geo.h:595
rheolef::geo_basic< T, distributed >::trace_ray_boundary
void trace_ray_boundary(const disarray< point_basic< T >, distributed > &x, const disarray< point_basic< T >, distributed > &v, disarray< size_type, distributed > &dis_ie, disarray< point_basic< T >, distributed > &y) const
Definition: geo.h:1488
rheolef::geo_abstract_base_rep::const_iterator_by_variant
hack_array< geo_element_hack >::const_iterator const_iterator_by_variant
Definition: geo.h:278
rheolef::geo_base_rep::get_piola_basis
const basis_basic< T > & get_piola_basis() const
Definition: geo.h:571
rheolef::geo_rep< T, distributed >::begin
iterator begin(size_type dim)
Definition: geo.h:1005
rheolef::geo_base_rep::set_serial_number
void set_serial_number(size_type i)
Definition: geo.h:570
rheolef::geo_basic< T, distributed >::dom2bgd_geo_element
const geo_element & dom2bgd_geo_element(const geo_element &dom_K) const
Definition: geo.h:1432
rheolef::geo_abstract_base_rep::familyname
virtual std::string familyname() const =0
rheolef::geo_size
Definition: geo_size.h:29
rheolef::point_basic
Definition: point.h:87
rheolef::geo_basic< T, distributed >::size
size_type size() const
Definition: geo.h:1530
rheolef::geo_basic< T, distributed >::dis_locate
size_type dis_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
Definition: geo.h:1472
rheolef::geo_basic< T, sequential >::const_iterator_by_variant
rep::const_iterator_by_variant const_iterator_by_variant
Definition: geo.h:1125
rheolef::distributor::comm
const communicator_type & comm() const
Definition: distributor.h:145
rheolef::put
void put(std::ostream &out, std::string name, const tiny_matrix< T > &a)
Definition: tiny_lu.h:155
rheolef::geo_base_rep::seq_nearest
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition: geo_nearest.cc:331
rheolef::geo_base_rep::ios_sizes
const geo_size & ios_sizes() const
Definition: geo.h:577
rheolef::geo_rep< T, distributed >::base
geo_base_rep< T, distributed > base
Definition: geo.h:933
rheolef::geo_basic< T, sequential >::insert_domain_indirect
void insert_domain_indirect(const domain_indirect_basic< sequential > &dom) const
Definition: geo.h:1186
rheolef::smart_pointer_base::data
const T & data() const
Definition: smart_pointer.h:266
rheolef::geo_base_rep::dis_size
size_type dis_size() const
Definition: geo.h:645
rheolef::geo_basic< T, distributed >::is_broken
bool is_broken() const
Definition: geo.h:1411
rheolef::geo_basic< T, sequential >::trace_ray_boundary
void trace_ray_boundary(const disarray< point_basic< T >, sequential > &x, const disarray< point_basic< T >, sequential > &v, disarray< size_type, sequential > &dis_ie, disarray< point_basic< T >, sequential > &y) const
Definition: geo.h:1267
rheolef::geo_abstract_base_rep::is_broken
virtual bool is_broken() const =0
rheolef::geo_basic< T, distributed >::dis_node
const node_type & dis_node(size_type dis_inod) const
Definition: geo.h:1447
rheolef::geo_iterator::_iter_by_var
IteratorByVariant _iter_by_var
Definition: geo.h:240
rheolef::geo_rep< T, distributed >::iterator_by_variant
base::iterator_by_variant iterator_by_variant
Definition: geo.h:942
rheolef::geo_iterator::operator++
_self & operator++()
Definition: geo.h:218
rheolef::geo_rep< T, distributed >::get_igev2ios_dis_igev
const std::array< disarray< size_type, distributed >, reference_element::max_variant > & get_igev2ios_dis_igev() const
Definition: geo.h:1074
rheolef::geo_basic< T, sequential >::check
bool check(bool verbose=true) const
Definition: geo.h:1232
rheolef::geo_rep< T, distributed >::_ios_igev2dis_igev
std::array< disarray< size_type, distributed >, reference_element::max_variant > _ios_igev2dis_igev
Definition: geo.h:1069
rheolef::geo_base_rep::end
const_iterator end() const
Definition: geo.h:658
rheolef::geo_abstract_base_rep::end_by_variant
virtual const_iterator_by_variant end_by_variant(variant_type variant) const =0
rheolef::geo_basic< T, sequential >::dom2bgd_geo_element
const geo_element & dom2bgd_geo_element(const geo_element &dom_K) const
Definition: geo.h:1168
rheolef::geo_basic< T, distributed >::sizes
const geo_size & sizes() const
Definition: geo.h:1424
rheolef::geo_rep< T, distributed >
distributed mesh representation
Definition: geo.h:929
rheolef::geo_locate
Definition: geo_locate.h:40
rheolef::geo_basic< T, distributed >::rep_geo_rep
geo_rep< T, distributed > rep_geo_rep
Definition: geo.h:1374
rheolef::point_basic::size_type
size_t size_type
Definition: point.h:92
rheolef::geo_abstract_base_rep::size_type
geo_element_hack::size_type size_type
Definition: geo.h:260
rheolef::geo_abstract_base_rep::n_node
virtual size_type n_node() const =0
rheolef::geo_basic< T, distributed >::serial_number
size_type serial_number() const
Definition: geo.h:1412
rheolef::geo_basic< T, distributed >::ios_sizes
const geo_size & ios_sizes() const
Definition: geo.h:1425
rheolef::geo_basic< T, distributed >::iterator_by_variant
rep::iterator_by_variant iterator_by_variant
Definition: geo.h:1384
rheolef::geo_basic< T, distributed >::nearest
void nearest(const disarray< point_basic< T >, distributed > &x, disarray< point_basic< T >, distributed > &x_nearest, disarray< size_type, distributed > &dis_ie) const
Definition: geo.h:1508
rheolef::geo_rep< T, sequential >
Definition: geo.h:786
rheolef::geo_basic< T, distributed >::const_reference
rep::const_reference const_reference
Definition: geo.h:1381
rheolef::geo_abstract_base_rep::dimension
virtual size_type dimension() const =0
rheolef::geo_basic< T, distributed >::dis_nearest
size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition: geo.h:1504
rheolef::sequential
Definition: distributed.h:28
rheolef::geo_basic< T, distributed >::geo_element_ownership
const distributor & geo_element_ownership(size_type dim) const
Definition: geo.h:1422
rheolef::geo_abstract_base_rep::name
virtual std::string name() const =0
rheolef::geo_base_rep::set_dimension
void set_dimension(size_type dim)
Definition: geo.h:569
rheolef::point_basic::get
std::istream & get(std::istream &s, int d=3)
Definition: point.h:377
rheolef::geo_base_rep::~geo_base_rep
~geo_base_rep()
Definition: geo.cc:388
rheolef::geo_base_rep::is_broken
bool is_broken() const
Definition: geo.h:565
rheolef::hack_array::const_iterator
std::vector< T, A >::const_iterator const_iterator
Definition: hack_array.h:351
rheolef::geo_base_rep
base class for M=sequential or distributed meshes representations
Definition: geo.h:528
rheolef::geo_base_rep::_geo_element
std::array< hack_array< geo_element_hack, M >, reference_element::max_variant > _geo_element
Definition: geo.h:678
rheolef::geo_iterator::_variant
size_type _variant
Definition: geo.h:238
rheolef::geo_basic< T, sequential >::dis_size
size_type dis_size(size_type dim) const
Definition: geo.h:1210
rheolef::geo_abstract_base_rep::end
const_iterator end(size_type dim) const
Definition: geo.h:769
rheolef::geo_basic< T, sequential >::geo_element_ownership
const distributor & geo_element_ownership(size_type dim) const
Definition: geo.h:1161
rheolef::geo_basic< T, sequential >::coordinate_system_name
std::string coordinate_system_name() const
Definition: geo.h:1154
dump
verbose clean transpose logscale grid shrink ball stereo iso volume skipvtk deformation fastfieldload lattice reader_on_stdin color format format format format format format format format format format format format format format format format format format dump
Definition: iorheo-members.h:119
rheolef::geo_basic< T, sequential >::rep_geo_rep
geo_rep< T, sequential > rep_geo_rep
Definition: geo.h:1115
rheolef::geo_base_rep::dis_locate
size_type dis_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
Definition: geo_locate.cc:408
rheolef::geo_abstract_base_rep::xmin
virtual const node_type & xmin() const =0
rheolef::geo_abstract_base_rep::neighbour
virtual size_type neighbour(size_type ie, size_type loc_isid) const =0
rheolef::geo_basic< T, sequential >::familyname
std::string familyname() const
Definition: geo.h:1147
rheolef::geo_basic< T, distributed >::comm
const communicator & comm() const
Definition: geo.h:1529
rheolef::geo_base_rep::_name
std::string _name
Definition: geo.h:674
rheolef::geo_rep< T, sequential >::begin
iterator begin(size_type dim)
Definition: geo.h:851
rheolef::geo_base_rep::dis_inod2dis_iv
size_type dis_inod2dis_iv(size_type dis_inod) const
Definition: geo.cc:565
rheolef::geo_base_rep::ownership
const distributor & ownership() const
Definition: geo.h:635
rheolef::geo_base_rep::reference
base::reference reference
Definition: geo.h:540
rheolef::geo_basic< T, sequential >::coordinate_system
coordinate_type coordinate_system() const
Definition: geo.h:1153
rheolef::geo_basic< T, sequential >::memory_type
sequential memory_type
Definition: geo.h:1113
rheolef::_point_put::size_type
point_basic< T >::size_type size_type
Definition: geo.h:164
rheolef::geo_base_rep::begin_by_variant
const_iterator_by_variant begin_by_variant(variant_type variant) const
Definition: geo.h:720
rheolef::geo_element_hack::size_type
geo_element::size_type size_type
Definition: geo_element.h:466
rheolef::geo_base_rep::_domains
std::vector< domain_indirect_basic< M > > _domains
Definition: geo.h:680
rheolef::geo_abstract_base_rep::put
virtual odiststream & put(odiststream &ops) const =0
rheolef::geo_rep< T, sequential >::get_domain_indirect
const domain_indirect_basic< sequential > & get_domain_indirect(size_type idom) const
Definition: geo.h:857
rheolef::geo_basic< T, sequential >::variant_type
rep::variant_type variant_type
Definition: geo.h:1119
rheolef::geo_rep< T, sequential >::is_broken
bool is_broken() const
Definition: geo.h:847
rheolef::geo_base_rep::_hmin
T _hmin
Definition: geo.h:689
rheolef::geo_rep< T, distributed >::geo_element_ownership
const distributor & geo_element_ownership(size_type dim) const
Definition: geo.h:999
rheolef::geo_base_rep::n_vertex
size_type n_vertex() const
Definition: geo.h:642
rheolef::distributor
see the distributor page for the full documentation
Definition: distributor.h:62
rheolef::geo_basic< T, sequential >::dis_inod
void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const
Definition: geo.h:1175
rheolef::geo_iterator::operator++
_self operator++(int)
Definition: geo.h:231
rheolef::geo_basic< T, sequential >::comm
const communicator & comm() const
Definition: geo.h:1208
mkgeo_ball.order
order
Definition: mkgeo_ball.sh:343
rheolef::geo_rep< T, sequential >::put
odiststream & put(odiststream &ops) const
Definition: geo.h:870
rheolef::geo_element::size
size_type size() const
Definition: geo_element.h:168
rheolef::geo_abstract_rep< T, distributed >::const_reference
base::const_reference const_reference
Definition: geo.h:465
rheolef::geo_basic< T, distributed >::size
size_type size(size_type dim) const
Definition: geo.h:1527
rheolef::geo_abstract_base_rep::bgd2dom_geo_element
virtual const geo_element & bgd2dom_geo_element(const geo_element &bgd_K) const
Definition: geo.h:311
rheolef::geo_abstract_rep< T, sequential >::~geo_abstract_rep
virtual ~geo_abstract_rep()
Definition: geo.h:424
rheolef::geo_element
see the geo_element page for the full documentation
Definition: geo_element.h:102
rheolef::geo_abstract_base_rep::node
virtual const node_type & node(size_type inod) const =0
rheolef::geo_rep
sequential mesh representation
Definition: domain_indirect.h:63
rheolef::geo_base_rep::get_geo_element
const_reference get_geo_element(size_type dim, size_type ige) const
Definition: geo.cc:533
rheolef::geo_base_rep::_serial_number
size_type _serial_number
Definition: geo.h:676
rheolef::geo_abstract_base_rep::const_iterator
geo_iterator< geo_element, const geo_element &, const geo_element *, const_iterator_by_variant > const_iterator
Definition: geo.h:284
rheolef::geo_rep< T, sequential >::coordinate_type
base::coordinate_type coordinate_type
Definition: geo.h:800
rheolef::geo_base_rep::dis_trace_move
size_type dis_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
Definition: geo_trace_move.cc:83
rheolef::geo_rep< T, distributed >::geo_element_map_type
base::geo_element_map_type geo_element_map_type
Definition: geo.h:945
rheolef::geo_rep< T, distributed >::size
size_type size() const
Definition: geo.h:1015
rheolef::geo_base_rep::geo_base_rep
geo_base_rep()
Definition: geo.cc:36
rheolef::geo_basic< T, distributed >::bgd2dom_geo_element
const geo_element & bgd2dom_geo_element(const geo_element &bgd_K) const
Definition: geo.h:1430
rheolef::geo_trace_ray_boundary
Definition: geo_trace_ray_boundary.h:41
rheolef::geo_basic< T, distributed >::begin_by_variant
const_iterator_by_variant begin_by_variant(variant_type variant) const
Definition: geo.h:1542
rheolef::geo_basic< T, distributed >::familyname
std::string familyname() const
Definition: geo.h:1408
rheolef::geo_rep< T, distributed >::const_iterator
base::const_iterator const_iterator
Definition: geo.h:941
rheolef::geo_element_auto
Definition: geo_element.h:99
rheolef::geo_abstract_base_rep::seq_locate
virtual size_type seq_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const =0
rheolef::geo_basic< T, sequential >::neighbour_guard
void neighbour_guard() const
Definition: geo.h:1171
rheolef::geo_basic< T, sequential >::map_dimension
size_type map_dimension() const
Definition: geo.h:1149
rheolef::geo_load
geo_basic< T, M > geo_load(const std::string &filename)
sequential mesh with reference counting
Definition: geo.cc:177
rheolef::geo_base_rep::node_type
base::node_type node_type
Definition: geo.h:534
rheolef::geo_basic< T, distributed >::hmin
const T & hmin() const
Definition: geo.h:1420
rheolef::geo_abstract_rep< T, distributed >::node_map_type
std::map< size_type, node_type, std::less< size_type >, heap_allocator< std::pair< size_type, node_type > > > node_map_type
Definition: geo.h:467
rheolef::geo_basic< T, distributed >::have_domain_indirect
bool have_domain_indirect(const std::string &name) const
Definition: geo.h:1453
rheolef::geo_base_rep::seq_locate
size_type seq_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
Definition: geo_locate.cc:400
rheolef::geo_abstract_base_rep::geo_element_ownership
virtual const distributor & geo_element_ownership(size_type dim) const =0
rheolef::geo_basic< T, distributed >::n_vertex
size_type n_vertex() const
Definition: geo.h:1532
rheolef::geo_base_rep::end_by_variant
const_iterator_by_variant end_by_variant(variant_type variant) const
Definition: geo.h:732
rheolef::geo_base_rep::base
geo_abstract_rep< T, M > base
Definition: geo.h:532
rheolef::geo_abstract_base_rep::check
virtual bool check(bool verbose) const =0
rheolef::geo_basic< T, distributed >::reference
rep::reference reference
Definition: geo.h:1380
rheolef::geo_base_rep::coordinate_system
coordinate_type coordinate_system() const
Definition: geo.h:566
rheolef::geo_iterator::_self
geo_iterator< T, Ref, Ptr, IteratorByVariant > _self
Definition: geo.h:194
rheolef::geo_base_rep::have_domain_indirect
bool have_domain_indirect(const std::string &name) const
Definition: geo.cc:417
rheolef::reference_element::first_variant_by_dimension
static variant_type first_variant_by_dimension(size_type dim)
Definition: reference_element.h:148
rheolef::geo_basic< T, distributed >::insert_domain_indirect
void insert_domain_indirect(const domain_indirect_basic< distributed > &dom) const
Definition: geo.h:1458
rheolef::_round_point_put::size_type
point_basic< T >::size_type size_type
Definition: geo.h:172
rheolef::geo_basic< T, sequential >::reference
rep::reference reference
Definition: geo.h:1120
rheolef::geo_base_rep::iterator_by_variant
base::iterator_by_variant iterator_by_variant
Definition: geo.h:538
rheolef::geo_basic< T, distributed >::get_igev2ios_dis_igev
const std::array< disarray< size_type, distributed >, reference_element::max_variant > & get_igev2ios_dis_igev() const
Definition: geo.h:1570
rheolef::geo_basic< T, sequential >::locate
void locate(const disarray< point_basic< T >, sequential > &x, disarray< size_type, sequential > &dis_ie) const
Definition: geo.h:1253
rheolef::geo_abstract_rep< T, sequential >::iterator
base::iterator iterator
Definition: geo.h:413
rheolef::geo_base_rep::iterator
base::iterator iterator
Definition: geo.h:536
rheolef::geo_base_rep::node
const node_type & node(size_type inod) const
Definition: geo.h:588
rheolef::operator==
bool operator==(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
Definition: heap_allocator.h:167
rheolef::geo_basic< T, distributed >::base
smart_pointer_clone< rep > base
Definition: geo.h:1375
rheolef::geo_basic< T, distributed >::node_type
rep::node_type node_type
Definition: geo.h:1377
rheolef::geo_basic< T, distributed >::const_iterator
rep::const_iterator const_iterator
Definition: geo.h:1383
rheolef::geo_iterator::_variant_max
size_type _variant_max
Definition: geo.h:239
rheolef::geo_abstract_base_rep::iterator
geo_iterator< geo_element, geo_element &, geo_element *, iterator_by_variant > iterator
Definition: geo.h:275
rheolef::geo_basic< T, sequential >::trace_move
void trace_move(const disarray< point_basic< T >, sequential > &x, const disarray< point_basic< T >, sequential > &v, disarray< size_type, sequential > &dis_ie, disarray< point_basic< T >, sequential > &y) const
Definition: geo.h:1273
rheolef::_point_get::operator()
std::istream & operator()(std::istream &is, point_basic< T > &x)
Definition: geo.h:159
rheolef::geo_basic< T, distributed >::dis_trace_move
size_type dis_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
Definition: geo.h:1483
rheolef::sides_guard
void sides_guard(const geo_basic< T, M > &omega)
Definition: geo.cc:639
rheolef::geo_abstract_base_rep::begin
const_iterator begin(size_type dim) const
Definition: geo.h:760
rheolef::geo_basic< T, distributed >::node
const node_type & node(size_type inod) const
Definition: geo.h:1446
rheolef::geo_abstract_base_rep::coordinate_system
virtual coordinate_type coordinate_system() const =0
rheolef::geo_base_rep::operator[]
const_reference operator[](size_type ie) const
Definition: geo.h:651
rheolef::geo_base_rep::dis_inod
void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const
Definition: geo.cc:478
rheolef::geo_base_rep::_xmin
node_type _xmin
Definition: geo.h:687
rheolef::geo_basic::memory_type
M memory_type
Definition: geo.h:1091
rheolef::basis_basic
Definition: basis.h:206
rheolef::geo_abstract_base_rep::get_piola_basis
virtual const basis_basic< T > & get_piola_basis() const =0
rheolef::point_basic::put
std::ostream & put(std::ostream &s, int d=3) const
Definition: point.h:389
rheolef::_point_get::size_type
point_basic< T >::size_type size_type
Definition: geo.h:156
main
int main(int argc, char **argv)
Definition: csr.cc:270
rheolef::geo_abstract_base_rep
abstract base interface class
Definition: geo.h:248
rheolef::reference_element
see the reference_element page for the full documentation
Definition: reference_element.h:66
rheolef::geo_basic< T, sequential >::xmax
const node_type & xmax() const
Definition: geo.h:1158
rheolef::geo_iterator::difference_type
ptrdiff_t difference_type
Definition: geo.h:205
rheolef::geo_iterator::reference
Ref reference
Definition: geo.h:203
rheolef::geo_base_rep::serial_number
size_type serial_number() const
Definition: geo.h:562
rheolef::domain_indirect_basic< distributed >
Definition: domain_indirect.h:559
rheolef::geo_base_rep::get_domain_indirect
const domain_indirect_basic< M > & get_domain_indirect(size_type i) const
Definition: geo.h:597
mkgeo_ball.variant
variant
Definition: mkgeo_ball.sh:149
rheolef::geo_rep< T, sequential >::geo_element_map_type
base::geo_element_map_type geo_element_map_type
Definition: geo.h:801
rheolef::_point_put::d
size_type d
Definition: geo.h:166
rheolef::geo_basic< T, distributed >::dis_n_vertex
size_type dis_n_vertex() const
Definition: geo.h:1533
rheolef::geo_base_rep::vertex_ownership
const distributor & vertex_ownership() const
Definition: geo.h:636
rheolef::geo_basic< T, sequential >
Definition: geo.h:1108
rheolef::geo_base_rep::_loaded_map
static loaded_map_t _loaded_map
Definition: geo.h:701
rheolef::geo_rep< T, distributed >::_ios_ige2dis_ige
std::array< disarray< size_type >, 4 > _ios_ige2dis_ige
Definition: geo.h:1066
rheolef::geo_basic< T, distributed >
distributed mesh with rerefence counting
Definition: geo.h:1367
rheolef::geo_iterator::geo_iterator
geo_iterator(size_type dim, size_type variant, IteratorByVariant iter, Geo &omega)
Definition: geo.h:368
rheolef::geo_element::node
size_type & node(size_type loc_inod)
Definition: geo_element.h:185
rheolef::geo_rep< T, sequential >::size_type
base::size_type size_type
Definition: geo.h:791
rheolef::geo_abstract_base_rep::hmax
virtual const T & hmax() const =0
rheolef::geo_size::map_dimension
size_type map_dimension() const
Definition: geo_size.h:41
rheolef::geo_basic< T, sequential >::seq_locate
size_type seq_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
Definition: geo.h:1245
rheolef::geo_basic< T, sequential >::iterator
rep::iterator iterator
Definition: geo.h:1122
rheolef::geo_basic< T, sequential >::iterator_by_variant
rep::iterator_by_variant iterator_by_variant
Definition: geo.h:1124
rheolef::geo_basic< T, sequential >::dis_trace_move
size_type dis_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
Definition: geo.h:1262
rheolef::geo_abstract_base_rep::dis_trace_move
virtual size_type dis_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const =0
rheolef::geo_base_rep::begin
const_iterator begin() const
Definition: geo.h:657
rheolef::geo_abstract_rep< T, distributed >::size_type
base::size_type size_type
Definition: geo.h:463
rheolef::geo_basic< T, sequential >::bgd2dom_geo_element
const geo_element & bgd2dom_geo_element(const geo_element &bgd_K) const
Definition: geo.h:1167
rheolef::geo_abstract_base_rep::dis_locate
virtual size_type dis_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const =0
rheolef::geo_basic< T, sequential >::end_by_variant
const_iterator_by_variant end_by_variant(variant_type variant) const
Definition: geo.h:1295
rheolef::geo_rep< T, distributed >::reference
base::reference reference
Definition: geo.h:938
rheolef::geo_basic< T, sequential >::const_iterator
rep::const_iterator const_iterator
Definition: geo.h:1123
rheolef::geo_rep< T, distributed >::const_iterator_by_variant
base::const_iterator_by_variant const_iterator_by_variant
Definition: geo.h:943
rheolef::geo_basic< T, distributed >::dimension
size_type dimension() const
Definition: geo.h:1409
rheolef::geo_base_rep::_locator
geo_locate< T, M > _locator
Definition: geo.h:692
rheolef::geo_basic< T, distributed >::n_node
size_type n_node() const
Definition: geo.h:1445
rheolef::geo_basic< T, sequential >::begin
const_iterator begin() const
Definition: geo.h:1218
rheolef::geo_abstract_base_rep::const_reference
const typedef geo_element & const_reference
Definition: geo.h:264
rheolef::geo_base_rep::_xmax
node_type _xmax
Definition: geo.h:688
rheolef::geo_abstract_base_rep::dis_inod
virtual void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const =0
rheolef::geo_rep< T, sequential >::const_iterator_by_variant
base::const_iterator_by_variant const_iterator_by_variant
Definition: geo.h:799
rheolef::geo_rep< T, distributed >::iterator
base::iterator iterator
Definition: geo.h:940
rheolef::geo_basic< T, sequential >::dis_get_geo_element
const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const
Definition: geo.h:1165
rheolef::geo_basic< T, sequential >::dimension
size_type dimension() const
Definition: geo.h:1148
rheolef::geo_abstract_base_rep::dom2bgd_geo_element
virtual const geo_element & dom2bgd_geo_element(const geo_element &dom_K) const
Definition: geo.h:312
rheolef::geo_rep< T, distributed >::_inod2ios_dis_inod
disarray< size_type > _inod2ios_dis_inod
Definition: geo.h:1064
rheolef::geo_base_rep::geo_element_ownership
const distributor & geo_element_ownership(size_type dim) const
Definition: geo.h:579
rheolef::geo_basic< T, sequential >::dis_size
size_type dis_size() const
Definition: geo.h:1212
rheolef::geo_abstract_base_rep::geo_rep_variant_type
geo_rep_variant_type
Definition: geo.h:253
rheolef::geo_basic< T, distributed >::get_domain_indirect
const domain_indirect_basic< distributed > & get_domain_indirect(size_type i) const
Definition: geo.h:1454
rheolef::geo_abstract_base_rep::get_external_geo_element_map
virtual const geo_element_map_type & get_external_geo_element_map(size_type variant) const =0
rheolef::geo_iterator::_first_by_var
IteratorByVariant _first_by_var[reference_element::max_variant]
Definition: geo.h:241
rheolef::reference_element::variant_type
size_type variant_type
Definition: reference_element.h:72
rheolef::geo_rep< T, distributed >::get_domain_indirect
const domain_indirect_basic< distributed > & get_domain_indirect(const std::string &name) const
Definition: geo.h:1011
rheolef::geo_rep< T, distributed >::variant_type
base::variant_type variant_type
Definition: geo.h:936
rheolef::geo_abstract_base_rep::coordinate_type
space_constant::coordinate_type coordinate_type
Definition: geo.h:265
rheolef::geo_base_rep::_dimension
size_type _dimension
Definition: geo.h:685
rheolef::_round_point_put::operator()
std::ostream & operator()(std::ostream &os, const point_basic< T > &x)
Definition: geo.h:176
rheolef::distributed
Definition: distributed.h:88
rheolef::geo
geo_basic< Float, rheo_default_memory_model > geo
Definition: geo.h:1575
rheolef::geo_basic< T, distributed >::rep
geo_abstract_rep< T, distributed > rep
Definition: geo.h:1373
rheolef::geo_abstract_rep
abstract interface class
Definition: domain_indirect.h:62
rheolef::geo_abstract_rep< T, sequential >
Definition: geo.h:404
rheolef::geo_base_rep::name
std::string name() const
Definition: geo.cc:408
rheolef::geo_base_rep::_nearestor
geo_nearest< T, M > _nearestor
Definition: geo.h:694
rheolef::geo_abstract_base_rep::serial_number
virtual size_type serial_number() const =0
mkgeo_ugrid.boundary
boundary
Definition: mkgeo_ugrid.sh:181
rheolef::geo_abstract_base_rep::map_dimension
virtual size_type map_dimension() const =0
rheolef::details::zero_dimension
Definition: geo.h:147
rheolef::geo_iterator::operator!=
bool operator!=(const _self &y) const
Definition: geo.h:234
rheolef::geo_iterator::operator==
bool operator==(const _self &y) const
Definition: geo.h:233
rheolef::geo_base_rep::dis_get_geo_element
const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const
Definition: geo.cc:582
rheolef::geo_base_rep::insert_domain_indirect
void insert_domain_indirect(const domain_indirect_basic< M > &dom) const
Definition: geo.cc:440
rheolef::geo_rep< T, distributed >::node_type
base::node_type node_type
Definition: geo.h:935
rheolef::geo_basic< T, sequential >::node
const node_type & node(size_type inod) const
Definition: geo.h:1173
rheolef::geo_basic< T, distributed >::get_nodes
const disarray< node_type, distributed > & get_nodes() const
Definition: geo.h:1450
rheolef::geo_abstract_base_rep::seq_nearest
virtual size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const =0
rheolef::geo_base_rep::size
size_type size() const
Definition: geo.h:643
rheolef::geo_basic< T, distributed >::dis_inod
void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const
Definition: geo.h:1448
rheolef::geo_base_rep::init_neighbour
void init_neighbour() const
Definition: geo_neighbour.cc:83
rheolef::geo_basic< T, sequential >::end
const_iterator end(size_type dim) const
Definition: geo.h:1217
rheolef::geo_abstract_rep< T, sequential >::variant_type
base::variant_type variant_type
Definition: geo.h:412
rheolef::geo_basic< T, sequential >::begin_by_variant
const_iterator_by_variant begin_by_variant(variant_type variant) const
Definition: geo.h:1293
rheolef::geo_base_rep::compute_bbox
void compute_bbox()
Definition: geo.cc:486
rheolef::_point_get::d
size_type d
Definition: geo.h:158
rheolef::geo_basic< T, distributed >::locate
void locate(const disarray< point_basic< T >, distributed > &x, disarray< size_type, distributed > &dis_ie) const
Definition: geo.h:1476
rheolef::geo_basic< T, sequential >::variant
size_type variant() const
Definition: geo.h:1152
rheolef::geo_rep< T, sequential >::reference
base::reference reference
Definition: geo.h:794
rheolef::geo_basic< T, distributed >::end
const_iterator end(size_type dim) const
Definition: geo.h:1538
rheolef::geo_rep< T, distributed >::get_geo_element
reference get_geo_element(size_type dim, size_type ige)
Definition: geo.h:1001
rheolef::smart_pointer_clone
Definition: smart_pointer.h:370
rheolef::boundary_guard
void boundary_guard(const geo_basic< T, M > &omega)
Definition: geo.cc:600
rheolef::geo_basic< T, distributed >::map_dimension
size_type map_dimension() const
Definition: geo.h:1410
rheolef::geo_basic< T, distributed >::begin
const_iterator begin(size_type dim) const
Definition: geo.h:1537
rheolef::geo_basic< T, sequential >::dis_n_vertex
size_type dis_n_vertex() const
Definition: geo.h:1214
rheolef::geo_basic< T, sequential >::rep
geo_abstract_rep< T, sequential > rep
Definition: geo.h:1114
rheolef::geo_base_rep::seq_trace_move
size_type seq_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
Definition: geo_trace_move.cc:45
rheolef::geo_rep< T, sequential >::base
geo_base_rep< T, sequential > base
Definition: geo.h:790
rheolef::geo_basic< T, distributed >::trace_move
void trace_move(const disarray< point_basic< T >, distributed > &x, const disarray< point_basic< T >, distributed > &v, disarray< size_type, distributed > &dis_ie, disarray< point_basic< T >, distributed > &y) const
Definition: geo.h:1494
rheolef::geo_rep< T, distributed >::node_map_type
base::node_map_type node_map_type
Definition: geo.h:937
rheolef::environment
see the environment page for the full documentation
Definition: environment.h:115
rheolef::geo_basic< T, sequential >::dis_nearest
size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition: geo.h:1283
rheolef::geo_basic< T, distributed >::dis_ige2ios_dis_ige
size_type dis_ige2ios_dis_ige(size_type dim, size_type dis_ige) const
Definition: geo.h:1441
rheolef::geo_basic< T, distributed >::geo_basic
geo_basic(const geo_basic< T, distributed > &lambda, const disarray< point_basic< T >, distributed > &node_list, const std::array< disarray< geo_element_auto< heap_allocator< size_type > >, distributed >, reference_element::max_variant > &elt_list)
Definition: geo.h:1398
rheolef::geo_rep< T, distributed >::_ios_inod2dis_inod
disarray< size_type > _ios_inod2dis_inod
Definition: geo.h:1065
rheolef::geo_abstract_base_rep::dis_inod2dis_iv
virtual size_type dis_inod2dis_iv(size_type dis_inod) const =0
rheolef::geo_basic< T, sequential >::get_nodes
const disarray< node_type, sequential > & get_nodes() const
Definition: geo.h:1177
rheolef::geo_rep< T, sequential >::begin
const_iterator begin(size_type dim) const
Definition: geo.h:853
rheolef::geo_abstract_rep< T, distributed >::geo_abstract_rep
geo_abstract_rep()
Definition: geo.h:471
rheolef::geo_rep< T, distributed >::get_domain_indirect
const domain_indirect_basic< distributed > & get_domain_indirect(size_type idom) const
Definition: geo.h:1010
rheolef::geo_basic< T, sequential >::geo_basic
geo_basic(const geo_basic< T, sequential > &lambda, const disarray< point_basic< T >, sequential > &node_list, const std::array< disarray< geo_element_auto< heap_allocator< size_type > >, sequential >, reference_element::max_variant > &elt_list)
Definition: geo.h:1137
rheolef::geo_basic< T, distributed >::get_geo_element
const_reference get_geo_element(size_type dim, size_type ige) const
Definition: geo.h:1426
rheolef::geo_basic< T, sequential >::const_reference
rep::const_reference const_reference
Definition: geo.h:1121
rheolef::geo_basic< T, sequential >::nearest
void nearest(const disarray< point_basic< T >, sequential > &x, disarray< point_basic< T >, sequential > &x_nearest, disarray< size_type, sequential > &dis_ie) const
Definition: geo.h:1287
rheolef::geo_base_rep::loaded_map
static loaded_map_t & loaded_map()
Definition: geo.cc:151
rheolef::geo_rep< T, sequential >::variant_type
base::variant_type variant_type
Definition: geo.h:793
rheolef::geo_basic< T, sequential >::neighbour
size_type neighbour(size_type ie, size_type loc_isid) const
Definition: geo.h:1169
rheolef::geo_basic< T, distributed >::dis_size
size_type dis_size(size_type dim) const
Definition: geo.h:1528
rheolef::geo_rep< T, sequential >::get_domain_indirect
const domain_indirect_basic< sequential > & get_domain_indirect(const std::string &name) const
Definition: geo.h:858
rheolef::geo_base_rep::sizes
const geo_size & sizes() const
Definition: geo.h:576
rheolef::geo_base_rep::dis_n_edge
size_type dis_n_edge() const
Definition: geo.h:646
rheolef::geo_abstract_base_rep::hmin
virtual const T & hmin() const =0
rheolef::geo_basic< T, distributed >::n_domain
size_type n_domain() const
Definition: geo.h:1461
mkgeo_sector.m
m
Definition: mkgeo_sector.sh:118
rheolef::geo_base_rep::_tracer_ray_boundary
geo_trace_ray_boundary< T, M > _tracer_ray_boundary
Definition: geo.h:693
rheolef::geo_iterator
geo iterator
Definition: geo.h:193
rheolef::geo_rep< T, distributed >::get_geo_element
const_reference get_geo_element(size_type dim, size_type ige) const
Definition: geo.h:1000
rheolef::geo_basic< T, sequential >::set_coordinate_system
void set_coordinate_system(std::string sys_coord_name)
Definition: geo.h:1203
rheolef::geo_base_rep::begin
const_iterator begin(size_type dim) const
Definition: geo.h:654
rheolef::geo_basic< T, sequential >::ios_ige2dis_ige
size_type ios_ige2dis_ige(size_type dim, size_type ios_ige) const
Definition: geo.h:1306
rheolef::operator>>
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition: catchmark.h:88
rheolef::geo_abstract_rep< T, distributed >::~geo_abstract_rep
virtual ~geo_abstract_rep()
Definition: geo.h:473
rheolef::geo_base_rep::neighbour_guard
void neighbour_guard() const
Definition: geo.h:706
rheolef::geo_abstract_base_rep::get_geo_element
virtual const_reference get_geo_element(size_type dim, size_type ige) const =0
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
rheolef::geo_iterator::_reset_to_next_or_last
void _reset_to_next_or_last()
Definition: geo.h:223
rheolef::geo_base_rep::xmax
const node_type & xmax() const
Definition: geo.h:573
rheolef::_round_point_put::d
size_type d
Definition: geo.h:174
rheolef::geo_basic< T, distributed >::ios_ige2dis_ige
size_type ios_ige2dis_ige(size_type dim, size_type ios_ige) const
Definition: geo.h:1443
rheolef::geo_abstract_rep< T, sequential >::base
geo_abstract_base_rep< T > base
Definition: geo.h:409
rheolef::geo_abstract_rep< T, sequential >::geo_abstract_rep
geo_abstract_rep()
Definition: geo.h:422
rheolef::geo_base_rep::end
const_iterator end(size_type dim) const
Definition: geo.h:655
rheolef::geo_basic< T, distributed >::variant
size_type variant() const
Definition: geo.h:1413
rheolef::geo_rep< T, distributed >::get_external_geo_element_map
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
Definition: geo.h:1007
rheolef::geo_basic< T, distributed >::const_iterator_by_variant
rep::const_iterator_by_variant const_iterator_by_variant
Definition: geo.h:1385
rheolef::internal_sides_guard
void internal_sides_guard(const geo_basic< T, M > &omega)
Definition: geo.cc:619
rheolef::geo_base_rep::loaded_map_t
std::unordered_map< std::string, void * > loaded_map_t
Definition: geo.h:698
rheolef::geo_base_rep::begin_edge
const_iterator begin_edge() const
Definition: geo.h:660
rheolef::geo_basic< T, distributed >::seq_trace_move
size_type seq_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
Definition: geo.h:1478
rheolef::geo_base_rep::get_nodes
const disarray< node_type, M > & get_nodes() const
Definition: geo.h:592
rheolef::geo_basic< T, sequential >::base
smart_pointer_clone< rep > base
Definition: geo.h:1116
rheolef::geo_base_rep::dis_node
const node_type & dis_node(size_type dis_inod) const
Definition: geo.h:589
rheolef::geo_base_rep::end_face
const_iterator end_face() const
Definition: geo.h:663
rheolef::odiststream
odiststream: see the diststream page for the full documentation
Definition: diststream.h:126
rheolef::space_numbering::dis_inod
void dis_inod(const basis_basic< T > &b, const geo_size &gs, const geo_element &K, typename std::vector< size_type >::iterator dis_inod_tab)
Definition: space_numbering.cc:177
rheolef::geo_basic< T, sequential >::n_domain
size_type n_domain() const
Definition: geo.h:1189
rheolef::geo_basic< T, sequential >::ige2ios_dis_ige
size_type ige2ios_dis_ige(size_type dim, size_type ige) const
Definition: geo.h:1304
rheolef::geo_build_by_subdividing
void geo_build_by_subdividing(geo_rep< T, M > &new_omega, const geo_basic< T, M > &old_omega, typename geo_rep< T, M >::size_type k)
Definition: geo_subdivide.cc:129
rheolef::geo_basic< T, distributed >::dis_inod2dis_iv
size_type dis_inod2dis_iv(size_type dis_inod) const
Definition: geo.h:1517
rheolef::geo_rep< T, distributed >::vertex_ownership
const distributor & vertex_ownership() const
Definition: geo.h:1016
rheolef::geo_abstract_rep< T, sequential >::node_type
base::node_type node_type
Definition: geo.h:411
rheolef::geo_basic< T, distributed >::set_ios_permutation
void set_ios_permutation(disarray< size_type, distributed > &idof2ios_dis_idof) const
Definition: geo.h:1565
rheolef::geo_basic< T, sequential >::get_external_geo_element_map
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
Definition: geo.h:1297
rheolef::geo_base_rep::comm
const communicator & comm() const
Definition: geo.h:637
rheolef::geo_base_rep::map_dimension
size_type map_dimension() const
Definition: geo.h:564
rheolef::geo_basic< T, sequential >::size
size_type size(size_type dim) const
Definition: geo.h:1209
rheolef::reference_element::max_variant
static const variant_type max_variant
Definition: reference_element.h:82
rheolef::geo_abstract_rep< T, sequential >::size_type
base::size_type size_type
Definition: geo.h:410
rheolef::geo_iterator::value_type
T value_type
Definition: geo.h:201
rheolef::geo_abstract_base_rep::neighbour_guard
virtual void neighbour_guard() const =0
rheolef::geo_base_rep::coordinate_type
base::coordinate_type coordinate_type
Definition: geo.h:542
rheolef::geo_abstract_rep< T, sequential >::reference
base::reference reference
Definition: geo.h:417
rheolef::disarray< node_type, sequential >
rheolef::geo_basic< T, distributed >::set_coordinate_system
void set_coordinate_system(std::string sys_coord_name)
Definition: geo.h:1519
rheolef::geo_basic< T, distributed >::node_map_type
rep::node_map_type node_map_type
Definition: geo.h:1379
mkgeo_grid.sys_coord
sys_coord
Definition: mkgeo_grid.sh:171
rheolef::geo_basic< T, distributed >::geo_element_ios_ownership
distributor geo_element_ios_ownership(size_type dim) const
Definition: geo.h:1437
rheolef::geo_abstract_rep< T, sequential >::const_iterator_by_variant
base::const_iterator_by_variant const_iterator_by_variant
Definition: geo.h:416
rheolef::domain_indirect_basic< sequential >
Definition: domain_indirect.h:342
rheolef::geo_basic< T, sequential >::dis_ige2ios_dis_ige
size_type dis_ige2ios_dis_ige(size_type dim, size_type dis_ige) const
Definition: geo.h:1305
rheolef::geo_iterator::size_type
T::size_type size_type
Definition: geo.h:204
rheolef::geo_abstract_base_rep::sizes
virtual const geo_size & sizes() const =0
rheolef::geo_base_rep::_have_neighbour
bool _have_neighbour
Definition: geo.h:682
rheolef::geo_basic< T, sequential >::sizes
const geo_size & sizes() const
Definition: geo.h:1162
rheolef::geo_basic< T, sequential >::serial_number
size_type serial_number() const
Definition: geo.h:1151
mkgeo_ball.verbose
verbose
Definition: mkgeo_ball.sh:133
rheolef::geo_abstract_base_rep::geo_domain
@ geo_domain
Definition: geo.h:255
rheolef::geo_base_rep::begin_face
const_iterator begin_face() const
Definition: geo.h:662
rheolef::geo_rep< T, distributed >::_igev2ios_dis_igev
std::array< disarray< size_type, distributed >, reference_element::max_variant > _igev2ios_dis_igev
Definition: geo.h:1068
rheolef::geo_base_rep::const_reference
base::const_reference const_reference
Definition: geo.h:541
rheolef::geo_iterator::pointer
Ptr pointer
Definition: geo.h:202
rheolef::geo_basic< T, distributed >::get_external_geo_element_map
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
Definition: geo.h:1546
rheolef::geo_basic< T, distributed >::hmax
const T & hmax() const
Definition: geo.h:1421
rheolef::geo_base_rep::hmin
const T & hmin() const
Definition: geo.h:574
rheolef::domain_indirect_rep< distributed >
Definition: domain_indirect.h:229
rheolef::const_iterator
Definition: field_expr_recursive.h:552
rheolef::geo_abstract_rep< T, distributed >::base
geo_abstract_base_rep< T > base
Definition: geo.h:462
rheolef::_point_put::operator()
std::ostream & operator()(std::ostream &os, const point_basic< T > &x)
Definition: geo.h:167
rheolef::geo_basic< T, sequential >::ios_sizes
const geo_size & ios_sizes() const
Definition: geo.h:1163
rheolef::geo_abstract_base_rep::geo_abstract_base_rep
geo_abstract_base_rep()
Definition: geo.h:288
rheolef::geo_basic< T, sequential >::have_domain_indirect
bool have_domain_indirect(const std::string &name) const
Definition: geo.h:1181
rheolef::_point_get
point input helper
Definition: geo.h:155
rheolef::geo_basic< T, distributed >::begin
const_iterator begin() const
Definition: geo.h:1539
rheolef::geo_rep< T, sequential >::end
iterator end(size_type dim)
Definition: geo.h:852
load
void load(idiststream &in, Float &p, field &uh)
Definition: p_laplacian_post.cc:64
rheolef::geo_abstract_base_rep::dis_nearest
virtual size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const =0
rheolef::geo_basic< T, sequential >::n_node
size_type n_node() const
Definition: geo.h:1172
rheolef::_point_put
point output helper
Definition: geo.h:163
rheolef::geo_abstract_rep< T, distributed >
Definition: geo.h:457
rheolef::geo_basic< T, sequential >::dis_node
const node_type & dis_node(size_type dis_inod) const
Definition: geo.h:1174
rheolef::geo_basic< T, distributed >::get_piola_basis
const basis_basic< T > & get_piola_basis() const
Definition: geo.h:1416
mkgeo_ball.n
n
Definition: mkgeo_ball.sh:150
rheolef::geo_rep< T, distributed >::_ios_gs
geo_size _ios_gs
Definition: geo.h:1067
rheolef::geo_basic< T, distributed >::dis_get_geo_element
const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const
Definition: geo.h:1428
mkgeo_ugrid.sides
sides
Definition: mkgeo_ugrid.sh:180
rheolef::geo_base_rep::variant
size_type variant() const
Definition: geo.h:559
rheolef::geo_rep< T, sequential >::iterator
base::iterator iterator
Definition: geo.h:796
rheolef::geo_rep< T, sequential >::iterator_by_variant
base::iterator_by_variant iterator_by_variant
Definition: geo.h:798
rheolef::geo_basic< T, distributed >::coordinate_type
rep::coordinate_type coordinate_type
Definition: geo.h:1386
rheolef::geo_rep< T, distributed >::end
iterator end(size_type dim)
Definition: geo.h:1006
rheolef::geo_basic< T, sequential >::name
std::string name() const
Definition: geo.h:1146
rheolef::geo_iterator::_nonconst_iterator
geo_iterator< T, T &, T *, typename hack_array< T >::iterator > _nonconst_iterator
Definition: geo.h:195
rheolef::geo_basic< T, distributed >::coordinate_system
coordinate_type coordinate_system() const
Definition: geo.h:1414
size_type
field::size_type size_type
Definition: branch.cc:425
rheolef::geo_base_rep::_piola_basis
basis_basic< T > _piola_basis
Definition: geo.h:691
rheolef::geo_basic< T, distributed >::size_type
rep::size_type size_type
Definition: geo.h:1376
rheolef::geo_rep< T, sequential >::map_dimension
size_type map_dimension() const
Definition: geo.h:846
rheolef::geo_basic< T, distributed >::end
const_iterator end() const
Definition: geo.h:1540
rheolef::geo_basic< T, sequential >::is_broken
bool is_broken() const
Definition: geo.h:1150
rheolef::rounder_type
Definition: rounder.h:29
rheolef::geo_rep< T, distributed >::coordinate_type
base::coordinate_type coordinate_type
Definition: geo.h:944
rheolef::geo_element::name
char name() const
Definition: geo_element.h:169
rheolef::geo_abstract_base_rep::reference
geo_element & reference
Definition: geo.h:263
rheolef::geo_basic< T, sequential >::dis_inod2dis_iv
size_type dis_inod2dis_iv(size_type dis_inod) const
Definition: geo.h:1178
rheolef::domain_indirect_rep< sequential >
Definition: domain_indirect.h:151
rheolef::geo_basic< T, sequential >::size
size_type size() const
Definition: geo.h:1211
rheolef::geo_rep< T, distributed >::size_type
base::size_type size_type
Definition: geo.h:934
check
void check(Float p, const field &uh)
Definition: p_laplacian_post.cc:49
rheolef::geo_basic< T, distributed >::check
bool check(bool verbose=true) const
Definition: geo.h:1561
rheolef::geo_abstract_base_rep::xmax
virtual const node_type & xmax() const =0
rheolef::_round_point_put
point output helper, with rounding feature
Definition: geo.h:171
rheolef::geo_basic< T, distributed >::n_domain_indirect
size_type n_domain_indirect() const
Definition: geo.h:1452
rheolef::geo_basic< T, sequential >::seq_trace_move
size_type seq_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
Definition: geo.h:1257
rheolef::geo_rep< T, sequential >::end
const_iterator end(size_type dim) const
Definition: geo.h:854
rheolef::geo_basic< T, sequential >::seq_nearest
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition: geo.h:1279
rheolef::geo_iterator::operator*
reference operator*() const
Definition: geo.h:215
rheolef::geo_base_rep::_have_connectivity
bool _have_connectivity
Definition: geo.h:681
rheolef::geo_rep< T, distributed >::size
size_type size(size_type dim) const
Definition: geo.h:998
rheolef::geo_basic< T, sequential >::get_piola_basis
const basis_basic< T > & get_piola_basis() const
Definition: geo.h:1155
rheolef::geo_basic< T, distributed >::variant_type
rep::variant_type variant_type
Definition: geo.h:1378
rheolef::geo_base_rep::build_from_list
void build_from_list(const geo_basic< T, M > &lambda, const disarray< point_basic< T >, M > &node_list, const std::array< disarray< geo_element_auto< heap_allocator< size_type > >, M >, reference_element::max_variant > &elt_list)
Definition: geo_build_from_list.cc:36
rheolef::geo_abstract_base_rep::~geo_abstract_base_rep
virtual ~geo_abstract_base_rep()
Definition: geo.h:289
rheolef::geo_rep< T, distributed >::end
const_iterator end(size_type dim) const
Definition: geo.h:1004
rheolef::geo_basic< T, sequential >::get_domain_indirect
const domain_indirect_basic< sequential > & get_domain_indirect(size_type i) const
Definition: geo.h:1182
rheolef::geo_rep< T, distributed >::const_reference
base::const_reference const_reference
Definition: geo.h:939
rheolef::geo_basic< T, sequential >::hmin
const T & hmin() const
Definition: geo.h:1159
rheolef::geo_base_rep::_hmax
T _hmax
Definition: geo.h:690
rheolef::geo_rep< T, sequential >::build_external_entities
void build_external_entities()
Definition: geo.h:915
rheolef::geo_basic< T, distributed >::ige2ios_dis_ige
size_type ige2ios_dis_ige(size_type dim, size_type ige) const
Definition: geo.h:1439
rheolef::geo_iterator::iterator_category
std::random_access_iterator_tag iterator_category
Definition: geo.h:200
rheolef::geo_basic< T, distributed >::get_domain_indirect
const domain_indirect_basic< distributed > & get_domain_indirect(const std::string &name) const
Definition: geo.h:1456
rheolef::geo_nearest
Definition: geo_nearest.h:41
rheolef::geo_rep< T, distributed >::ios_sizes
const geo_size & ios_sizes() const
Definition: geo.h:973
mkgeo_ball.tmp
tmp
Definition: mkgeo_ball.sh:380
rheolef::geo_abstract_base_rep::operator==
bool operator==(const geo_abstract_base_rep< T > &omega2) const
Definition: geo.h:363
rheolef::geo_base_rep::dis_n_node
size_type dis_n_node() const
Definition: geo.h:641
rheolef::geo_abstract_base_rep::begin_by_variant
virtual const_iterator_by_variant begin_by_variant(variant_type variant) const =0
rheolef::operator<<
std::ostream & operator<<(std::ostream &os, const catchmark &m)
Definition: catchmark.h:99
rheolef::geo_abstract_base_rep::geo_element_map_type
std::map< size_type, geo_element_auto<> > geo_element_map_type
Definition: geo.h:266
rheolef::geo_base_rep::variant_type
base::variant_type variant_type
Definition: geo.h:535
rheolef::geo_abstract_base_rep::iterator_by_variant
hack_array< geo_element_hack >::iterator iterator_by_variant
Definition: geo.h:269
rheolef::geo_base_rep::order
size_type order() const
Definition: geo.h:638
rheolef::geo_size::ownership_by_dimension
distributor ownership_by_dimension[4]
Definition: geo_size.h:63
rheolef::geo_basic< T, distributed >::neighbour
size_type neighbour(size_type ie, size_type loc_isid) const
Definition: geo.h:1434
rheolef::geo_abstract_rep< T, sequential >::const_iterator
base::const_iterator const_iterator
Definition: geo.h:414
mkgeo_ball.dim
dim
Definition: mkgeo_ball.sh:307
rheolef::geo_basic< T, sequential >::geo_element_map_type
rep::geo_element_map_type geo_element_map_type
Definition: geo.h:1127
rheolef::geo_basic< T, sequential >::size_type
rep::size_type size_type
Definition: geo.h:1117
rheolef::geo_abstract_base_rep::variant_type
reference_element::variant_type variant_type
Definition: geo.h:262
rheolef::geo_basic< T, sequential >::node_type
rep::node_type node_type
Definition: geo.h:1118
rheolef::geo_base_rep::_version
size_type _version
Definition: geo.h:675
rheolef::geo_basic< T, sequential >::n_domain_indirect
size_type n_domain_indirect() const
Definition: geo.h:1180
rheolef::geo_rep< T, sequential >::get_geo_element
const_reference get_geo_element(size_type dim, size_type ige) const
Definition: geo.h:849
rheolef::geo_basic< T, sequential >::n_vertex
size_type n_vertex() const
Definition: geo.h:1213
rheolef::geo_basic< T, sequential >::set_ios_permutation
void set_ios_permutation(disarray< size_type, sequential > &idof2ios_dis_idof) const
Definition: geo.h:1307
rheolef::domain_indirect_basic
the finite element boundary domain
Definition: domain_indirect.h:335
rheolef::space_constant::coordinate_type
coordinate_type
Definition: space_constant.h:121
rheolef::geo_basic< T, distributed >::end_by_variant
const_iterator_by_variant end_by_variant(variant_type variant) const
Definition: geo.h:1544
rheolef::geo_basic< T, distributed >::seq_nearest
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition: geo.h:1500
rheolef::space_constant::coordinate_system
coordinate_type coordinate_system(std::string sys_coord)
Definition: space_constant.cc:75
rheolef::geo_rep< T, sequential >::get_geo_element
reference get_geo_element(size_type dim, size_type ige)
Definition: geo.h:850
rheolef::geo_base_rep::set_nodes
void set_nodes(const disarray< node_type, M > &x)
Definition: geo.h:594
rheolef::geo_base_rep::dis_n_face
size_type dis_n_face() const
Definition: geo.h:647
rheolef::geo_base_rep::end_edge
const_iterator end_edge() const
Definition: geo.h:661
rheolef::geo_basic< T, sequential >::xmin
const node_type & xmin() const
Definition: geo.h:1157
rheolef::geo_basic< T, distributed >::put
odiststream & put(odiststream &ops) const
Definition: geo.h:1558
rheolef::std
Definition: vec_expr_v2.h:391
rheolef::geo_basic< T, sequential >::coordinate_type
rep::coordinate_type coordinate_type
Definition: geo.h:1126
rheolef::geo_rep< T, distributed >::begin
const_iterator begin(size_type dim) const
Definition: geo.h:1003
rheolef::geo_rep< T, sequential >::geo_element_ownership
const distributor & geo_element_ownership(size_type dim) const
Definition: geo.h:848
rheolef::geo_header
Definition: geo_header.h:32
mkgeo_contraction.name
name
Definition: mkgeo_contraction.sh:133
geo
see the geo page for the full documentation
rheolef::geo_abstract_base_rep::geo_domain_indirect
@ geo_domain_indirect
Definition: geo.h:256
rheolef::geo_base_rep::neighbour
size_type neighbour(size_type ie, size_type loc_isid) const
Definition: geo_neighbour.cc:234
rheolef::geo_abstract_base_rep::seq_trace_move
virtual size_type seq_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const =0
M
Expr1::memory_type M
Definition: vec_expr_v2.h:385
rheolef::geo_basic< T, distributed >::seq_locate
size_type seq_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
Definition: geo.h:1468
rheolef::geo_abstract_base_rep::reset_order
virtual void reset_order(size_type order)=0
rheolef::geo_abstract_base_rep::node_type
point_basic< T > node_type
Definition: geo.h:261
rheolef::geo_base_rep::const_iterator_by_variant
base::const_iterator_by_variant const_iterator_by_variant
Definition: geo.h:539
rheolef::geo_rep< T, sequential >::const_iterator
base::const_iterator const_iterator
Definition: geo.h:797
rheolef::geo_rep< T, distributed >::get
idiststream & get(idiststream &)
Definition: geo_mpi_get.cc:637
rheolef::geo_base_rep::dis_nearest
size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition: geo_nearest.cc:339
rheolef::geo_basic< T, distributed >::xmin
const node_type & xmin() const
Definition: geo.h:1418
rheolef::geo_abstract_rep< T, sequential >::const_reference
base::const_reference const_reference
Definition: geo.h:418
rheolef::geo_abstract_base_rep::variant
virtual size_type variant() const =0
rheolef::geo_base_rep::_node
disarray< node_type, M > _node
Definition: geo.h:684
rheolef::geo_abstract_rep< T, sequential >::iterator_by_variant
base::iterator_by_variant iterator_by_variant
Definition: geo.h:415
rheolef::geo_base_rep::n_node
size_type n_node() const
Definition: geo.h:640
rheolef::geo_abstract_base_rep::dis_node
virtual const node_type & dis_node(size_type dis_inod) const =0
rheolef::geo_abstract_base_rep::n_domain_indirect
virtual size_type n_domain_indirect() const =0
rheolef::geo_basic< T, distributed >::neighbour_guard
void neighbour_guard() const
Definition: geo.h:1436
T
Expr1::float_type T
Definition: field_expr.h:218
rheolef::heap_allocator
Definition: heap_allocator.h:69
lambda
Definition: yield_slip_circle.h:34
rheolef::geo_base_rep::add_ball_externals
friend void add_ball_externals(const geo_base_rep< U, M > &, const disarray< index_set, M > &)
rheolef::_point_get::_point_get
_point_get(size_type d1)
Definition: geo.h:157
rheolef::geo_rep< T, distributed >::is_broken
bool is_broken() const
Definition: geo.h:997
rheolef::geo_basic< T, distributed >::xmax
const node_type & xmax() const
Definition: geo.h:1419
rheolef::geo_abstract_base_rep::ios_sizes
virtual const geo_size & ios_sizes() const =0
rheolef::geo_basic< T, sequential >::order
size_type order() const
Definition: geo.h:1156
rheolef::geo_basic< T, sequential >::get_domain_indirect
const domain_indirect_basic< sequential > & get_domain_indirect(const std::string &name) const
Definition: geo.h:1184
rheolef::geo_base_rep::dimension
size_type dimension() const
Definition: geo.h:563
rheolef::geo_abstract_rep< T, distributed >::node_type
base::node_type node_type
Definition: geo.h:464