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,
257  max_variant = 3
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;
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;
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 
334  const point_basic<T>& x,
335  size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const = 0;
337  const point_basic<T>& x,
338  size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const = 0;
339 
341  const point_basic<T>& x,
342  const point_basic<T>& v,
343  point_basic<T>& y) const = 0;
345  const point_basic<T>& x,
346  const point_basic<T>& v,
347  point_basic<T>& y) const = 0;
348 
350  const point_basic<T>& x,
351  point_basic<T>& x_nearest) const = 0;
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>
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;
419 
420 // allocators:
421 
423  virtual geo_abstract_rep<T,sequential>* clone() const = 0;
424  virtual ~geo_abstract_rep () {}
425 
426 // abstract accessors:
427 
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>
457 class geo_abstract_rep<T,distributed> : public geo_abstract_base_rep<T> {
458 public:
459 
460 // typedefs
461 
462  typedef geo_abstract_base_rep<T> base;
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 
471  geo_abstract_rep () {}
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 (
491  const disarray<point_basic<T>,distributed>& x,
492  disarray<size_type, distributed>& dis_ie,
493  bool do_check = true) const = 0;
494  virtual void trace_ray_boundary (
495  const disarray<point_basic<T>,distributed>& x,
496  const disarray<point_basic<T>,distributed>& v,
497  disarray<size_type, distributed>& dis_ie,
498  disarray<point_basic<T>,distributed>& y,
499  bool do_check = false) const = 0;
500  virtual void trace_move (
501  const disarray<point_basic<T>,distributed>& x,
502  const disarray<point_basic<T>,distributed>& v,
503  disarray<size_type, distributed>& dis_ie,
504  disarray<point_basic<T>,distributed>& y) const = 0;
505  virtual void nearest (
506  const disarray<point_basic<T>,distributed>& x,
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;
535  typedef typename base::variant_type variant_type;
536  typedef typename base::iterator iterator;
537  typedef typename base::const_iterator const_iterator;
538  typedef typename base::iterator_by_variant iterator_by_variant;
539  typedef typename base::const_iterator_by_variant const_iterator_by_variant;
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;
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 
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 
933  typedef geo_base_rep<T,distributed> base;
934  typedef typename base::size_type size_type;
935  typedef typename base::node_type node_type;
936  typedef typename base::variant_type variant_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;
941  typedef typename base::const_iterator const_iterator;
942  typedef typename base::iterator_by_variant iterator_by_variant;
943  typedef typename base::const_iterator_by_variant const_iterator_by_variant;
944  typedef typename base::coordinate_type coordinate_type;
945  typedef typename base::geo_element_map_type geo_element_map_type;
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,
963  const std::array<disarray<geo_element_auto<heap_allocator<size_type> >,distributed>,
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 (
975  const disarray<point_basic<T>,distributed>& x,
976  disarray<size_type, distributed>& dis_ie,
977  bool do_check = false) const;
978  void trace_ray_boundary (
979  const disarray<point_basic<T>,distributed>& x,
980  const disarray<point_basic<T>,distributed>& v,
981  disarray<size_type, distributed>& dis_ie,
982  disarray<point_basic<T>,distributed>& y,
983  bool do_check = false) const;
984  void trace_move (
985  const disarray<point_basic<T>,distributed>& x,
986  const disarray<point_basic<T>,distributed>& v,
987  disarray<size_type, distributed>& dis_ie,
988  disarray<point_basic<T>,distributed>& y) const;
989  void nearest (
990  const disarray<point_basic<T>,distributed>& x,
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); }
1007  const geo_element_map_type& get_external_geo_element_map (size_type variant) const
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]
1067  geo_size _ios_gs;
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 (); }
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);
1203  void set_coordinate_system (std::string sys_coord_name) { set_coordinate_system (space_constant::coordinate_system(sys_coord_name)); }
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:
1232  bool check (bool verbose = true) const { return base::data().check(verbose); }
1233  idiststream& get (idiststream& ips);
1234  odiststream& put (odiststream& ops) const;
1235 
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
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
1327  : base (0)
1328 {
1329  base::operator= (geo_load<T,sequential>(name));
1330 }
1331 template <class T>
1332 inline
1333 void
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 
1372  typedef distributed memory_type;
1373  typedef geo_abstract_rep<T,distributed> rep;
1374  typedef geo_rep<T,distributed> rep_geo_rep;
1375  typedef smart_pointer_clone<rep> base;
1376  typedef typename rep::size_type size_type;
1377  typedef typename rep::node_type node_type;
1378  typedef typename rep::variant_type variant_type;
1379  typedef typename rep::node_map_type node_map_type;
1380  typedef typename rep::reference reference;
1381  typedef typename rep::const_reference const_reference;
1382  typedef typename rep::iterator iterator;
1383  typedef typename rep::const_iterator const_iterator;
1384  typedef typename rep::iterator_by_variant iterator_by_variant;
1385  typedef typename rep::const_iterator_by_variant const_iterator_by_variant;
1386  typedef typename rep::coordinate_type coordinate_type;
1387  typedef typename rep::geo_element_map_type geo_element_map_type;
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)
1398  geo_basic (
1400  const disarray<point_basic<T>,distributed>& node_list,
1401  const std::array<disarray<geo_element_auto<heap_allocator<size_type> >,distributed>,
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(); }
1422  const distributor& geo_element_ownership(size_type dim) const
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(); }
1426  const_reference get_geo_element (size_type dim, size_type ige) const
1427  { return base::data().get_geo_element (dim, ige); }
1428  const_reference dis_get_geo_element (size_type dim, size_type dis_ige) const
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(); }
1437  distributor geo_element_ios_ownership (size_type dim) const {
1438  return base::data().geo_element_ios_ownership (dim); }
1439  size_type ige2ios_dis_ige (size_type dim, size_type ige) const {
1440  return base::data().ige2ios_dis_ige (dim,ige); }
1441  size_type dis_ige2ios_dis_ige (size_type dim, size_type dis_ige) const {
1442  return base::data().dis_ige2ios_dis_ige (dim,dis_ige); }
1443  size_type ios_ige2dis_ige (size_type dim, size_type ios_ige) const {
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); }
1454  const domain_indirect_basic<distributed>& get_domain_indirect (size_type i) const {
1455  return base::data().get_domain_indirect (i); }
1456  const domain_indirect_basic<distributed>& get_domain_indirect (const std::string& name) const {
1457  return base::data().get_domain_indirect (name); }
1458  void insert_domain_indirect (const domain_indirect_basic<distributed>& dom) const {
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;
1464  geo_basic<T,distributed> boundary() const;
1465  geo_basic<T,distributed> internal_sides() const;
1466  geo_basic<T,distributed> sides() const;
1467 
1468  size_type seq_locate (
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); }
1472  size_type dis_locate (
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); }
1476  void locate (const disarray<point_basic<T>, distributed>& x, disarray<size_type, distributed>& dis_ie) const
1477  { return base::data().locate (x, dis_ie); }
1478  size_type seq_trace_move (
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); }
1483  size_type dis_trace_move (
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); }
1488  void trace_ray_boundary (
1489  const disarray<point_basic<T>,distributed>& x,
1490  const disarray<point_basic<T>,distributed>& v,
1491  disarray<size_type, distributed>& dis_ie,
1492  disarray<point_basic<T>,distributed>& y) const
1493  { return base::data().trace_ray_boundary (x,v,dis_ie,y); }
1494  void trace_move (
1495  const disarray<point_basic<T>,distributed>& x,
1496  const disarray<point_basic<T>,distributed>& v,
1497  disarray<size_type, distributed>& dis_ie,
1498  disarray<point_basic<T>,distributed>& y) const
1499  { return base::data().trace_move (x,v,dis_ie,y); }
1500  size_type seq_nearest (
1501  const point_basic<T>& x,
1502  point_basic<T>& x_nearest) const
1503  { return base::data().seq_nearest (x, x_nearest); }
1504  size_type dis_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 (
1509  const disarray<point_basic<T>,distributed>& x,
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 
1542  const_iterator_by_variant begin_by_variant (variant_type variant) const
1543  { return base::data().begin_by_variant (variant); }
1544  const_iterator_by_variant end_by_variant (variant_type variant) const
1545  { return base::data(). end_by_variant (variant); }
1546  const geo_element_map_type& get_external_geo_element_map (size_type variant) const
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 
1565  void set_ios_permutation (disarray<size_type,distributed>& idof2ios_dis_idof) const
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&
1605 geo_basic<T,distributed>::get (idiststream& ips)
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
1615 geo_basic<T,distributed>
1617 {
1618  boundary_guard (*this);
1619  return operator[] ("boundary");
1620 }
1621 template <class T>
1622 inline
1623 geo_basic<T,distributed>
1624 geo_basic<T,distributed>::internal_sides() const
1625 {
1626  internal_sides_guard (*this);
1627  return operator[] ("internal_sides");
1628 }
1629 template <class T>
1630 inline
1631 geo_basic<T,distributed>
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
1652 operator<< (odiststream& ops, const geo_basic<T,M>& omega)
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
field::size_type size_type
Definition: branch.cc:425
int main(int argc, char **argv)
Definition: csr.cc:270
see the geo page for the full documentation
see the disarray page for the full documentation
Definition: disarray.h:459
see the distributor page for the full documentation
Definition: distributor.h:62
const communicator_type & comm() const
Definition: distributor.h:145
see the environment page for the full documentation
Definition: environment.h:104
abstract base interface class
Definition: geo.h:248
virtual const_iterator_by_variant begin_by_variant(variant_type variant) const =0
space_constant::coordinate_type coordinate_type
Definition: geo.h:265
virtual std::string familyname() const =0
virtual const geo_size & ios_sizes() const =0
virtual const geo_size & sizes() const =0
geo_iterator< geo_element, const geo_element &, const geo_element *, const_iterator_by_variant > const_iterator
Definition: geo.h:284
std::map< size_type, geo_element_auto<> > geo_element_map_type
Definition: geo.h:266
virtual size_type seq_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const =0
virtual void neighbour_guard() const =0
virtual size_type n_domain_indirect() const =0
virtual size_type dis_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const =0
virtual bool check(bool verbose) const =0
const_iterator end(size_type dim) const
Definition: geo.h:769
virtual const T & hmax() const =0
virtual void reset_order(size_type order)=0
virtual const_iterator_by_variant end_by_variant(variant_type variant) const =0
virtual size_type seq_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const =0
point_basic< T > node_type
Definition: geo.h:261
virtual bool is_broken() const =0
virtual size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const =0
const_iterator begin(size_type dim) const
Definition: geo.h:760
virtual size_type variant() const =0
virtual const node_type & node(size_type inod) const =0
virtual std::string name() const =0
geo_element_hack::size_type size_type
Definition: geo.h:260
virtual const node_type & xmax() const =0
virtual void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const =0
virtual size_type n_node() const =0
virtual const geo_element & dom2bgd_geo_element(const geo_element &dom_K) const
Definition: geo.h:312
virtual size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const =0
virtual const geo_element_map_type & get_external_geo_element_map(size_type variant) const =0
virtual const_reference get_geo_element(size_type dim, size_type ige) const =0
virtual const T & hmin() const =0
virtual const node_type & dis_node(size_type dis_inod) const =0
geo_iterator< geo_element, geo_element &, geo_element *, iterator_by_variant > iterator
Definition: geo.h:275
virtual bool have_domain_indirect(const std::string &name) const =0
const geo_element & const_reference
Definition: geo.h:264
geo_element & reference
Definition: geo.h:263
virtual const distributor & geo_element_ownership(size_type dim) const =0
bool operator==(const geo_abstract_base_rep< T > &omega2) const
Definition: geo.h:363
virtual size_type dis_inod2dis_iv(size_type dis_inod) const =0
virtual const node_type & xmin() const =0
virtual ~geo_abstract_base_rep()
Definition: geo.h:289
virtual size_type map_dimension() const =0
virtual size_type dimension() const =0
virtual coordinate_type coordinate_system() const =0
virtual const geo_element & bgd2dom_geo_element(const geo_element &bgd_K) const
Definition: geo.h:311
hack_array< geo_element_hack >::iterator iterator_by_variant
Definition: geo.h:269
virtual size_type dis_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const =0
hack_array< geo_element_hack >::const_iterator const_iterator_by_variant
Definition: geo.h:278
virtual size_type neighbour(size_type ie, size_type loc_isid) const =0
reference_element::variant_type variant_type
Definition: geo.h:262
virtual const basis_basic< T > & get_piola_basis() const =0
virtual odiststream & put(odiststream &ops) const =0
virtual size_type serial_number() const =0
base::const_iterator_by_variant const_iterator_by_variant
Definition: geo.h:416
virtual const domain_indirect_basic< sequential > & get_domain_indirect(size_type i) const =0
geo_abstract_base_rep< T > base
Definition: geo.h:409
virtual void set_nodes(const disarray< node_type, sequential > &)=0
base::iterator_by_variant iterator_by_variant
Definition: geo.h:415
virtual 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 =0
virtual geo_abstract_rep< T, sequential > * clone() const =0
base::const_reference const_reference
Definition: geo.h:418
virtual void locate(const disarray< point_basic< T >, sequential > &x, disarray< size_type, sequential > &dis_ie, bool do_check=false) const =0
base::const_iterator const_iterator
Definition: geo.h:414
virtual const disarray< node_type, sequential > & get_nodes() const =0
virtual const domain_indirect_basic< sequential > & get_domain_indirect(const std::string &name) const =0
virtual void insert_domain_indirect(const domain_indirect_basic< sequential > &dom) const =0
virtual void nearest(const disarray< point_basic< T >, sequential > &x, disarray< point_basic< T >, sequential > &x_nearest, disarray< size_type, sequential > &dis_ie) const =0
virtual 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, bool do_check=false) const =0
abstract interface class
Definition: geo.h:401
base class for M=sequential or distributed meshes representations
Definition: geo.h:528
const T & hmin() const
Definition: geo.h:574
const_iterator end(size_type dim) const
Definition: geo.h:655
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
base::variant_type variant_type
Definition: geo.h:535
base::const_iterator_by_variant const_iterator_by_variant
Definition: geo.h:539
const distributor & geo_element_ownership(size_type dim) const
Definition: geo.h:579
const basis_basic< T > & get_piola_basis() const
Definition: geo.h:571
coordinate_type coordinate_system() const
Definition: geo.h:566
const node_type & xmin() const
Definition: geo.h:572
const_iterator begin_face() const
Definition: geo.h:662
const_iterator_by_variant end_by_variant(variant_type variant) const
Definition: geo.h:732
std::string name() const
Definition: geo.cc:408
const T & hmax() const
Definition: geo.h:575
const disarray< node_type, M > & get_nodes() const
Definition: geo.h:592
const geo_size & ios_sizes() const
Definition: geo.h:577
size_type n_vertex() const
Definition: geo.h:642
iterator_by_variant begin_by_variant(variant_type variant)
Definition: geo.h:714
size_type _dimension
Definition: geo.h:685
const_iterator begin() const
Definition: geo.h:657
size_type dis_size() const
Definition: geo.h:645
friend void add_ball_externals(const geo_base_rep< U, M > &, const disarray< index_set, M > &)
void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const
Definition: geo.cc:478
size_type dis_iv2dis_inod(size_type dis_iv) const
Definition: geo.cc:572
size_type n_node() const
Definition: geo.h:640
geo_locate< T, M > _locator
Definition: geo.h:692
size_type dis_n_edge() const
Definition: geo.h:646
size_type _serial_number
Definition: geo.h:676
size_type serial_number() const
Definition: geo.h:562
std::vector< domain_indirect_basic< M > > _domains
Definition: geo.h:680
geo_nearest< T, M > _nearestor
Definition: geo.h:694
void set_dimension(size_type dim)
Definition: geo.h:569
base::iterator_by_variant iterator_by_variant
Definition: geo.h:538
const node_type & dis_node(size_type dis_inod) const
Definition: geo.h:589
geo_trace_ray_boundary< T, M > _tracer_ray_boundary
Definition: geo.h:693
base::iterator iterator
Definition: geo.h:536
void insert_domain_indirect(const domain_indirect_basic< M > &dom) const
Definition: geo.cc:440
size_type map_dimension() const
Definition: geo.h:564
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
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)
coordinate_type _sys_coord
Definition: geo.h:686
size_type size() const
Definition: geo.h:643
const_iterator end_face() const
Definition: geo.h:663
static loaded_map_t _loaded_map
Definition: geo.h:701
std::string familyname() const
Definition: geo.h:560
base::size_type size_type
Definition: geo.h:533
const_iterator_by_variant begin_by_variant(variant_type variant) const
Definition: geo.h:720
void set_name(std::string name)
Definition: geo.h:568
std::unordered_map< std::string, void * > loaded_map_t
Definition: geo.h:698
basis_basic< T > _piola_basis
Definition: geo.h:691
const_reference get_geo_element(size_type dim, size_type ige) const
Definition: geo.cc:533
size_type seq_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
size_type dis_n_face() const
Definition: geo.h:647
bool _have_neighbour
Definition: geo.h:682
const_iterator begin_edge() const
Definition: geo.h:660
node_type _xmax
Definition: geo.h:688
void init_neighbour() const
base::const_reference const_reference
Definition: geo.h:541
size_type _version
Definition: geo.h:675
const node_type & node(const geo_element &K, size_type loc_inod) const
size_type dimension() const
Definition: geo.h:563
size_type neighbour(size_type ie, size_type loc_isid) const
const_iterator end_edge() const
Definition: geo.h:661
const distributor & ownership() const
Definition: geo.h:635
iterator end(size_type dim)
Definition: geo.h:750
node_type _xmin
Definition: geo.h:687
const_reference operator[](size_type ie) const
Definition: geo.h:651
const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const
Definition: geo.cc:582
size_type dis_inod2dis_iv(size_type dis_inod) const
Definition: geo.cc:565
size_type n_domain_indirect() const
Definition: geo.h:595
size_type dis_n_vertex() const
Definition: geo.h:644
const node_type & xmax() const
Definition: geo.h:573
iterator begin(size_type dim)
iterator by dimension: wraps iterator by geo_element variant
Definition: geo.h:740
static loaded_map_t & loaded_map()
Definition: geo.cc:151
base::const_iterator const_iterator
Definition: geo.h:537
disarray< node_type, M > _node
Definition: geo.h:684
size_type variant() const
Definition: geo.h:559
bool is_broken() const
Definition: geo.h:565
std::string _name
Definition: geo.h:674
void set_serial_number(size_type i)
Definition: geo.h:570
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition: geo_nearest.cc:331
const domain_indirect_basic< M > & get_domain_indirect(size_type i) const
Definition: geo.h:597
bool _have_connectivity
Definition: geo.h:681
base::coordinate_type coordinate_type
Definition: geo.h:542
iterator_by_variant end_by_variant(variant_type variant)
Definition: geo.h:726
const_iterator end() const
Definition: geo.h:658
const distributor & vertex_ownership() const
Definition: geo.h:636
size_type dis_n_node() const
Definition: geo.h:641
const node_type & node(size_type inod) const
Definition: geo.h:588
const communicator & comm() const
Definition: geo.h:637
geo_size _gs
Definition: geo.h:679
std::array< hack_array< geo_element_hack, M >, reference_element::max_variant > _geo_element
Definition: geo.h:678
base::reference reference
Definition: geo.h:540
size_type dis_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
void set_coordinate_system(coordinate_type sys_coord)
Definition: geo.h:567
void compute_bbox()
Definition: geo.cc:486
bool have_domain_indirect(const std::string &name) const
Definition: geo.cc:417
const_iterator begin(size_type dim) const
Definition: geo.h:654
geo_abstract_rep< T, M > base
Definition: geo.h:532
size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition: geo_nearest.cc:339
void set_nodes(const disarray< node_type, M > &x)
Definition: geo.h:594
size_type order() const
Definition: geo.h:638
void neighbour_guard() const
Definition: geo.h:706
base::node_type node_type
Definition: geo.h:534
const geo_size & sizes() const
Definition: geo.h:576
const T & hmin() const
Definition: geo.h:1159
const_iterator end(size_type dim) const
Definition: geo.h:1217
rep::variant_type variant_type
Definition: geo.h:1119
rep::const_iterator const_iterator
Definition: geo.h:1123
const distributor & geo_element_ownership(size_type dim) const
Definition: geo.h:1161
void save(std::string filename="") const
const basis_basic< T > & get_piola_basis() const
Definition: geo.h:1155
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition: geo.h:1279
coordinate_type coordinate_system() const
Definition: geo.h:1153
const node_type & xmin() const
Definition: geo.h:1157
void set_coordinate_system(std::string sys_coord_name)
Definition: geo.h:1203
std::string name() const
Definition: geo.h:1146
size_type neighbour(size_type ie, size_type loc_isid) const
Definition: geo.h:1169
const T & hmax() const
Definition: geo.h:1160
const geo_size & ios_sizes() const
Definition: geo.h:1163
size_type n_vertex() const
Definition: geo.h:1213
const_iterator begin() const
Definition: geo.h:1218
geo_basic(details::zero_dimension, const communicator &comm=communicator())
size_type dis_size() const
Definition: geo.h:1212
size_type size(size_type dim) const
Definition: geo.h:1209
rep::geo_element_map_type geo_element_map_type
Definition: geo.h:1127
void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const
Definition: geo.h:1175
size_type ige2ios_dis_ige(size_type dim, size_type ige) const
Definition: geo.h:1304
void insert_domain_indirect(const domain_indirect_basic< sequential > &dom) const
Definition: geo.h:1186
size_type n_node() const
Definition: geo.h:1172
size_type serial_number() const
Definition: geo.h:1151
size_type seq_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
Definition: geo.h:1257
const node_type & dis_node(size_type dis_inod) const
Definition: geo.h:1174
size_type map_dimension() const
Definition: geo.h:1149
const domain_indirect_basic< sequential > & get_domain_indirect(size_type i) const
Definition: geo.h:1182
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
Definition: geo.h:1297
void build_from_data(const geo_header &hdr, const disarray< node_type, sequential > &node, std::array< disarray< geo_element_auto<>, sequential >, reference_element::max_variant > &tmp_geo_element, bool do_upgrade)
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
size_type size() const
Definition: geo.h:1211
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
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
void build_by_subdividing(const geo_basic< T, sequential > &omega, size_type k)
std::string familyname() const
Definition: geo.h:1147
void set_name(std::string name)
size_type n_domain() const
Definition: geo.h:1189
geo_basic(const domain_indirect_basic< sequential > &dom, const geo_basic< T, sequential > &omega)
const_iterator_by_variant begin_by_variant(variant_type variant) const
Definition: geo.h:1293
rep::coordinate_type coordinate_type
Definition: geo.h:1126
size_type dis_inod2dis_iv(size_type dis_inod) const
Definition: geo.h:1178
const_iterator_by_variant end_by_variant(variant_type variant) const
Definition: geo.h:1295
size_type dimension() const
Definition: geo.h:1148
void set_ios_permutation(disarray< size_type, sequential > &idof2ios_dis_idof) const
Definition: geo.h:1307
size_type ios_ige2dis_ige(size_type dim, size_type ios_ige) const
Definition: geo.h:1306
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
bool check(bool verbose=true) const
Definition: geo.h:1232
const geo_element & dom2bgd_geo_element(const geo_element &dom_K) const
Definition: geo.h:1168
const domain_indirect_basic< sequential > & get_domain_indirect(const std::string &name) const
Definition: geo.h:1184
rep::const_reference const_reference
Definition: geo.h:1121
geo_basic< T, sequential > get_background_domain() const
size_type n_domain_indirect() const
Definition: geo.h:1180
size_type dis_n_vertex() const
Definition: geo.h:1214
const node_type & xmax() const
Definition: geo.h:1158
void locate(const disarray< point_basic< T >, sequential > &x, disarray< size_type, sequential > &dis_ie) const
Definition: geo.h:1253
size_type dis_ige2ios_dis_ige(size_type dim, size_type dis_ige) const
Definition: geo.h:1305
size_type variant() const
Definition: geo.h:1152
void set_nodes(const disarray< node_type, sequential > &x)
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
rep::const_iterator_by_variant const_iterator_by_variant
Definition: geo.h:1125
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
geo_abstract_rep< T, sequential > rep
Definition: geo.h:1114
const_iterator end() const
Definition: geo.h:1219
size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition: geo.h:1283
const geo_basic< T, sequential > & get_background_geo() const
geo_rep< T, sequential > rep_geo_rep
Definition: geo.h:1115
const node_type & node(size_type inod) const
Definition: geo.h:1173
const_reference get_geo_element(size_type dim, size_type ige) const
Definition: geo.h:1164
const communicator & comm() const
Definition: geo.h:1208
void reset_order(size_type order)
rep::iterator_by_variant iterator_by_variant
Definition: geo.h:1124
size_type dis_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
Definition: geo.h:1262
const disarray< node_type, sequential > & get_nodes() const
Definition: geo.h:1177
std::string coordinate_system_name() const
Definition: geo.h:1154
void set_coordinate_system(coordinate_type sys_coord)
bool have_domain_indirect(const std::string &name) const
Definition: geo.h:1181
const_iterator begin(size_type dim) const
Definition: geo.h:1216
smart_pointer_clone< rep > base
Definition: geo.h:1116
geo_basic< T, sequential > get_domain(size_type i) const
const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const
Definition: geo.h:1165
size_type dis_size(size_type dim) const
Definition: geo.h:1210
size_type order() const
Definition: geo.h:1156
const geo_element & bgd2dom_geo_element(const geo_element &bgd_K) const
Definition: geo.h:1167
const geo_size & sizes() const
Definition: geo.h:1162
geo_element::size_type size_type
Definition: geo_element.h:466
see the geo_element page for the full documentation
Definition: geo_element.h:102
size_type size() const
Definition: geo_element.h:168
size_type & node(size_type loc_inod)
Definition: geo_element.h:185
char name() const
Definition: geo_element.h:169
const_iterator end(size_type dim) const
Definition: geo.h:854
base::variant_type variant_type
Definition: geo.h:793
base::const_iterator_by_variant const_iterator_by_variant
Definition: geo.h:799
const distributor & geo_element_ownership(size_type dim) const
Definition: geo.h:848
odiststream & put(odiststream &ops) const
Definition: geo.h:870
base::iterator_by_variant iterator_by_variant
Definition: geo.h:798
base::iterator iterator
Definition: geo.h:796
size_type map_dimension() const
Definition: geo.h:846
void build_by_subdividing(const geo_basic< T, sequential > &omega, size_type k)
base::size_type size_type
Definition: geo.h:791
base::const_reference const_reference
Definition: geo.h:795
const domain_indirect_basic< sequential > & get_domain_indirect(const std::string &name) const
Definition: geo.h:858
base::const_iterator const_iterator
Definition: geo.h:797
iterator end(size_type dim)
Definition: geo.h:852
base::coordinate_type coordinate_type
Definition: geo.h:800
base::geo_element_map_type geo_element_map_type
Definition: geo.h:801
const distributor & vertex_ownership() const
Definition: geo.h:862
const_reference get_geo_element(size_type dim, size_type ige) const
Definition: geo.h:849
const domain_indirect_basic< sequential > & get_domain_indirect(size_type idom) const
Definition: geo.h:857
iterator begin(size_type dim)
Definition: geo.h:851
void reset_order(size_type order)
base::reference reference
Definition: geo.h:794
reference get_geo_element(size_type dim, size_type ige)
Definition: geo.h:850
const_iterator begin(size_type dim) const
Definition: geo.h:853
geo_base_rep< T, sequential > base
Definition: geo.h:790
base::node_type node_type
Definition: geo.h:792
sequential mesh representation
Definition: geo.h:778
std::vector< T, A >::iterator iterator
Definition: hack_array.h:350
std::vector< T, A >::const_iterator const_iterator
Definition: hack_array.h:351
odiststream: see the diststream page for the full documentation
Definition: diststream.h:126
std::istream & get(std::istream &s, int d=3)
Definition: point.h:377
size_t size_type
Definition: point.h:92
std::ostream & put(std::ostream &s, int d=3) const
Definition: point.h:389
see the reference_element page for the full documentation
static const variant_type max_variant
static variant_type last_variant_by_dimension(size_type dim)
static variant_type first_variant_by_dimension(size_type dim)
size_t size_type
Definition: basis_get.cc:76
point_basic< T >
Definition: piola_fem.h:135
geo_basic< Float, rheo_default_memory_model > geo
Definition: geo.h:1575
const size_t dimension
Definition: edge.icc:64
const size_t n_vertex
Definition: edge.icc:66
Expr1::float_type T
Definition: field_expr.h:261
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
string sys_coord
Definition: mkgeo_grid.sh:171
coordinate_type coordinate_system(std::string sys_coord)
std::string coordinate_system_name(coordinate_type i)
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)
This file is part of Rheolef.
void put(std::ostream &out, std::string name, const tiny_matrix< T > &a)
Definition: tiny_lu.h:155
bool operator==(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition: catchmark.h:88
void boundary_guard(const geo_basic< T, M > &omega)
Definition: geo.cc:600
geo_basic< T, M > geo_load(const std::string &filename)
sequential mesh with reference counting
Definition: geo.cc:177
void sides_guard(const geo_basic< T, M > &omega)
Definition: geo.cc:639
idiststream & operator>>(idiststream &ips, geo_basic< T, M > &omega)
Definition: geo.h:1645
std::ostream & operator<<(std::ostream &os, const catchmark &m)
Definition: catchmark.h:99
void internal_sides_guard(const geo_basic< T, M > &omega)
Definition: geo.cc:619
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)
void check(Float p, const field &uh)
void load(idiststream &in, Float &p, field &uh)
point input helper
Definition: geo.h:155
size_type d
Definition: geo.h:158
_point_get(size_type d1)
Definition: geo.h:157
point_basic< T >::size_type size_type
Definition: geo.h:156
std::istream & operator()(std::istream &is, point_basic< T > &x)
Definition: geo.h:159
point output helper
Definition: geo.h:163
size_type d
Definition: geo.h:166
point_basic< T >::size_type size_type
Definition: geo.h:164
_point_put(size_type d1)
Definition: geo.h:165
std::ostream & operator()(std::ostream &os, const point_basic< T > &x)
Definition: geo.h:167
point output helper, with rounding feature
Definition: geo.h:171
rounder_type< T > round
Definition: geo.h:175
_round_point_put(size_type d1, const T &eps1)
Definition: geo.h:173
point_basic< T >::size_type size_type
Definition: geo.h:172
std::ostream & operator()(std::ostream &os, const point_basic< T > &x)
Definition: geo.h:176
geo iterator
Definition: geo.h:193
void _reset_to_next_or_last()
Definition: geo.h:223
_self & operator++()
Definition: geo.h:218
_self operator++(int)
Definition: geo.h:231
size_type _variant
Definition: geo.h:238
IteratorByVariant _first_by_var[reference_element::max_variant]
Definition: geo.h:241
geo_iterator< T, T &, T *, typename hack_array< T >::iterator > _nonconst_iterator
Definition: geo.h:195
std::random_access_iterator_tag iterator_category
Definition: geo.h:200
bool operator==(const _self &y) const
Definition: geo.h:233
bool operator!=(const _self &y) const
Definition: geo.h:234
size_type _variant_max
Definition: geo.h:239
reference operator*() const
Definition: geo.h:215
IteratorByVariant _iter_by_var
Definition: geo.h:240
geo_iterator(size_type dim, size_type variant, IteratorByVariant iter, Geo &omega)
Definition: geo.h:368
ptrdiff_t difference_type
Definition: geo.h:205
T::size_type size_type
Definition: geo.h:204
geo_iterator< T, Ref, Ptr, IteratorByVariant > _self
Definition: geo.h:194
pointer operator->() const
Definition: geo.h:216
IteratorByVariant _last_by_var[reference_element::max_variant]
Definition: geo.h:242
size_type map_dimension() const
Definition: geo_size.h:41
distributor ownership_by_dimension[4]
Definition: geo_size.h:63
ostream & operator<<(ostream &os, const tiny_element &K)
Definition: tiny_element.cc:27
Expr1::memory_type M
Definition: vec_expr_v2.h:416