Rheolef  7.2
an efficient C++ finite element environment
 
Loading...
Searching...
No Matches
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
26namespace 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/iorheo.h"
129#include "rheolef/diststream.h"
130#include "rheolef/linalg.h"
131#include "rheolef/basis.h"
132#include "rheolef/hack_array.h"
133#include "rheolef/geo_size.h"
134#include "rheolef/domain_indirect.h"
135#include "rheolef/geo_header.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
143namespace rheolef {
144
145namespace details {
146
147struct zero_dimension {}; // used by space IR
148
149} // namespace details
150// =========================================================================
151// point io helpers
152// =========================================================================
154template <class T>
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};
162template <class T>
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};
170template <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:
186template <class T, class M> class geo_basic;
187template <class T, class M> class geo_domain_indirect_rep;
188
189// =========================================================================
191// =========================================================================
192template<class T, class Ref, class Ptr, class IteratorByVariant>
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// =========================================================================
247template <class T>
249public:
250
251// typedefs
252
259
266 typedef std::map<size_type,geo_element_auto<>> geo_element_map_type;
267
270 typedef geo_iterator<
276
279 typedef geo_iterator<
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;
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
320 const_iterator begin (size_type dim) const;
321 const_iterator end (size_type dim) const;
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};
366template<class T, class Ref, class Ptr, class IteratorByVariant>
367template<class Geo>
369 size_type dim,
370 size_type variant,
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{
380 variant < reference_element::last_variant_by_dimension(dim); variant++) {
381 _first_by_var [variant] = omega.begin_by_variant (variant);
382 _last_by_var [variant] = omega. end_by_variant (variant);
383 }
385}
386template<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// =========================================================================
400template <class T, class M>
402
403template <class T>
405public:
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
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;
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 (
453 disarray<size_type, sequential>& dis_ie) const = 0;
454};
455#ifdef _RHEOLEF_HAVE_MPI
456template <class T>
458public:
459
460// typedefs
461
463 typedef typename base::size_type size_type;
464 typedef typename base::node_type node_type;
466 typedef std::map <size_type, node_type, std::less<size_type>,
468
469// allocators:
470
473 virtual ~geo_abstract_rep () {}
474
475// abstract accessors:
476
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
484 virtual const domain_indirect_basic<distributed>& get_domain_indirect (const std::string& name) const = 0;
486
487 virtual const disarray<node_type,distributed>& get_nodes() const = 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 (
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>&
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.
527template <class T, class M>
528class geo_base_rep : public geo_abstract_rep<T,M> {
529public:
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;
542 typedef typename base::coordinate_type coordinate_type;
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,
554
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; }
565 bool is_broken() const { return false; }
567 void set_coordinate_system (coordinate_type sys_coord) { _sys_coord = sys_coord; }
568 void set_name (std::string name) { _name = name; }
569 void set_dimension (size_type dim) { _dimension = dim; }
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;
634 size_type dis_size(size_type dim) const;
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
665protected:
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
697public:
698 typedef std::unordered_map<std::string,void*> loaded_map_t;
699 static loaded_map_t& loaded_map();
700protected:
702};
703template <class T, class M>
704inline
705void
707{
708 if (_have_neighbour) return;
709 _have_neighbour = true;
710 init_neighbour();
711}
712template <class T, class M>
715{
716 return _geo_element [variant].begin();
717}
718template <class T, class M>
721{
722 return _geo_element [variant].begin();
723}
724template <class T, class M>
727{
728 return _geo_element [variant].end();
729}
730template <class T, class M>
733{
734 return _geo_element [variant].end();
735}
737template <class T, class M>
738inline
741{
743 iterator_by_variant iter = begin_by_variant (variant);
744 iterator res = iterator (dim, variant, iter, *this);
745 return res;
746}
747template <class T, class M>
748inline
751{
753 iterator_by_variant iter = end_by_variant (variant - 1);
754 iterator res = iterator (dim, variant, iter, *this);
755 return res;
756}
757template <class T>
758inline
761{
763 const_iterator_by_variant iter = begin_by_variant (variant);
764 return const_iterator (dim, variant, iter, *this);
765}
766template <class T>
767inline
770{
772 const_iterator_by_variant iter = end_by_variant (variant - 1);
773 return const_iterator (dim, variant, iter, *this);
774}
775// =========================================================================
777// =========================================================================
778template <class T, class M> class geo_rep {};
779template <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
785template <class T>
786class geo_rep<T,sequential> : public geo_base_rep<T,sequential> {
787public:
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;
801 typedef typename base::geo_element_map_type geo_element_map_type;
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,
815
816 void build_from_domain (
817 const domain_indirect_rep<sequential>& indirect,
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 (
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);
880 void build_from_data (
881 const geo_header& hdr,
884 tmp_geo_element,
885 bool do_upgrade);
886
887// internal:
888protected:
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// =========================================================================
928template <class T>
929class geo_rep<T,distributed> : public geo_base_rep<T,distributed> {
930public:
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;
940 typedef typename base::iterator iterator;
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,
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,
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 (
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
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
1039protected:
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:
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
1071public:
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// =========================================================================
1088template <class T, class M = rheo_default_memory_model>
1090public:
1092};
1093// =========================================================================
1095// =========================================================================
1096// handler for complex geo names as "square[boundary]"
1097template<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()
1100template<class T, class M> void boundary_guard (const geo_basic<T,M>&);
1101template<class T, class M> void internal_sides_guard (const geo_basic<T,M>&);
1102template<class T, class M> void sides_guard (const geo_basic<T,M>&);
1103
1104// [verbatim_geo_basic]
1107template <class T>
1108class geo_basic<T,sequential> : public smart_pointer_clone<geo_abstract_rep<T,sequential> > {
1109public:
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,
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(); }
1154 std::string coordinate_system_name() const { return space_constant::coordinate_system_name(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); }
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;
1192 geo_basic<T,sequential> boundary() const;
1193 geo_basic<T,sequential> internal_sides() const;
1194 geo_basic<T,sequential> 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:
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
1238 const geo_header& hdr,
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 (
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); }
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 (
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};
1311template <class T, class M>
1312idiststream& operator>> (idiststream& ips, geo_basic<T,M>& omega);
1313
1314template <class T, class M>
1315odiststream& operator<< (odiststream& ops, const geo_basic<T,M>& omega);
1316// [verbatim_geo_basic_cont]
1317
1318template <class T>
1319inline
1321 : base (new_macro((geo_rep<T,sequential>)))
1322{
1323}
1324template <class T>
1325inline
1326geo_basic<T,sequential>::geo_basic (std::string name, const communicator& comm)
1327 : base (0)
1328{
1329 base::operator= (geo_load<T,sequential>(name));
1330}
1331template <class T>
1332inline
1333void
1334geo_basic<T,sequential>::load (std::string name, const communicator& comm)
1335{
1336 base::operator= (geo_load<T,sequential>(name));
1337}
1338template <class T>
1339inline
1342{
1343 boundary_guard (*this);
1344 return operator[] ("boundary");
1345}
1346template <class T>
1347inline
1350{
1351 internal_sides_guard (*this);
1352 return operator[] ("internal_sides");
1353}
1354template <class T>
1355inline
1358{
1359 sides_guard (*this);
1360 return operator[] ("sides");
1361}
1362#ifdef _RHEOLEF_HAVE_MPI
1363// =========================================================================
1365// =========================================================================
1366template <class T>
1367class geo_basic<T,distributed> : public smart_pointer_clone<geo_abstract_rep<T,distributed> > {
1368public:
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,
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(); }
1415 std::string coordinate_system_name() const { return space_constant::coordinate_system_name(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); }
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); }
1456 const domain_indirect_basic<distributed>& get_domain_indirect (const std::string& name) const {
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 (); }
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
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); }
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 (
1512 { base::data().nearest (x, x_nearest, dis_ie); }
1513// modifiers:
1514
1517 size_type dis_inod2dis_iv (size_type dis_inod) const { return base::data().dis_inod2dis_iv(dis_inod); }
1519 void set_coordinate_system (std::string sys_coord_name) { set_coordinate_system (space_constant::coordinate_system(sys_coord_name)); }
1522 void set_name (std::string name);
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
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
1582template <class T>
1583inline
1585 : base (new_macro((geo_rep<T,distributed>)))
1586{
1587}
1588template <class T>
1589inline
1590geo_basic<T,distributed>::geo_basic (std::string name, const communicator& comm)
1591 : base (0)
1592{
1593 base::operator= (geo_load<T,distributed>(name));
1594}
1595template <class T>
1596inline
1597void
1598geo_basic<T,distributed>::load (std::string name, const communicator& comm)
1599{
1600 base::operator= (geo_load<T,distributed>(name));
1601}
1602template <class T>
1603inline
1606{
1607 // allocate a new geo_rep object (TODO: do a dynamic_cast ?)
1609 ptr->get (ips);
1610 base::operator= (ptr);
1611 return ips;
1612}
1613template <class T>
1614inline
1617{
1618 boundary_guard (*this);
1619 return operator[] ("boundary");
1620}
1621template <class T>
1622inline
1625{
1626 internal_sides_guard (*this);
1627 return operator[] ("internal_sides");
1628}
1629template <class T>
1630inline
1633{
1634 sides_guard (*this);
1635 return operator[] ("sides");
1636}
1637#endif // _RHEOLEF_HAVE_MPI
1638
1639// ==============================================================================
1640// inlined: geo<T,M>
1641// ==============================================================================
1642template <class T, class M>
1643inline
1646{
1647 return omega.get (ips);
1648}
1649template <class T, class M>
1650inline
1652operator<< (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#include "rheolef/environment.h"
1663using namespace rheolef;
1664using namespace std;
1665int main(int argc, char**argv) {
1666 environment rheolef (argc, argv);
1667 geo omega (argv[1]);
1668 // [verbatim_geo_demo_tst]
1669 cout << omega.size() << " " << omega.n_node() << endl;
1670 for (size_t i = 0, n = omega.size(); i < n; ++i) {
1671 const geo_element& K = omega[i];
1672 cout << K.name();
1673 for (size_t j = 0, m = K.size(); j < m; ++j)
1674 cout << " " << K[j];
1675 cout << endl;
1676 }
1677 for (size_t jv = 0, nv = omega.n_node(); jv < nv; ++jv)
1678 cout << omega.node(jv) << endl;
1679 // [verbatim_geo_demo_tst]
1680}
1681#endif // _RHEOLEF_GEO_DEMO_TST_CC
field::size_type size_type
Definition branch.cc:430
see the geo page for the full documentation
see the disarray page for the full documentation
Definition disarray.h:497
see the distributor page for the full documentation
Definition distributor.h:69
const communicator_type & comm() const
the finite element boundary domain
see the environment page for the full documentation
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 node_type & xmin() const =0
virtual const node_type & node(size_type inod) const =0
virtual const geo_element & dom2bgd_geo_element(const geo_element &dom_K) const
Definition geo.h:312
virtual const T & hmax() const =0
geo_iterator< geo_element, const geo_element &, const geo_element *, const_iterator_by_variant > const_iterator
Definition geo.h:284
virtual const basis_basic< T > & get_piola_basis() const =0
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 const distributor & geo_element_ownership(size_type dim) const =0
virtual bool check(bool verbose) const =0
const_iterator end(size_type dim) const
Definition geo.h:769
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
virtual const node_type & dis_node(size_type dis_inod) const =0
const_iterator begin(size_type dim) const
Definition geo.h:760
virtual size_type variant() const =0
virtual std::string name() const =0
geo_element_hack::size_type size_type
Definition geo.h:260
virtual void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const =0
virtual size_type n_node() const =0
virtual size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const =0
virtual const_reference get_geo_element(size_type dim, size_type ige) 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
virtual const geo_element & bgd2dom_geo_element(const geo_element &bgd_K) const
Definition geo.h:311
geo_element & reference
Definition geo.h:263
virtual const geo_size & sizes() const =0
virtual const geo_element_map_type & get_external_geo_element_map(size_type variant) 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 odiststream & put(odiststream &ops) const =0
virtual ~geo_abstract_base_rep()
Definition geo.h:289
virtual size_type map_dimension() const =0
virtual const node_type & xmax() const =0
virtual size_type dimension() const =0
virtual const geo_size & ios_sizes() const =0
virtual coordinate_type coordinate_system() const =0
hack_array< geo_element_hack >::iterator iterator_by_variant
Definition geo.h:269
virtual const T & hmin() const =0
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 size_type serial_number() const =0
virtual size_type ios_ige2dis_ige(size_type dim, size_type ios_ige) const =0
virtual const domain_indirect_basic< distributed > & get_domain_indirect(size_type i) const =0
geo_abstract_base_rep< T > base
Definition geo.h:462
virtual geo_abstract_rep< T, distributed > * clone() const =0
virtual void set_ios_permutation(disarray< size_type, distributed > &idof2ios_dis_idof) const =0
virtual distributor geo_element_ios_ownership(size_type dim) const =0
virtual 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, bool do_check=false) const =0
virtual void insert_domain_indirect(const domain_indirect_basic< distributed > &dom) const =0
virtual 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 =0
virtual const std::array< disarray< size_type, distributed >, reference_element::max_variant > & get_igev2ios_dis_igev() const =0
base::const_reference const_reference
Definition geo.h:465
virtual const domain_indirect_basic< distributed > & get_domain_indirect(const std::string &name) const =0
virtual void locate(const disarray< point_basic< T >, distributed > &x, disarray< size_type, distributed > &dis_ie, bool do_check=true) const =0
virtual size_type ige2ios_dis_ige(size_type dim, size_type ige) const =0
virtual const disarray< node_type, distributed > & get_nodes() const =0
virtual size_type dis_ige2ios_dis_ige(size_type dim, size_type dis_ige) const =0
virtual const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const =0
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
virtual void set_nodes(const disarray< node_type, distributed > &)=0
virtual void nearest(const disarray< point_basic< T >, distributed > &x, disarray< point_basic< T >, distributed > &x_nearest, disarray< size_type, distributed > &dis_ie) const =0
virtual const disarray< node_type, sequential > & get_nodes() const =0
base::const_iterator_by_variant const_iterator_by_variant
Definition geo.h:416
virtual const domain_indirect_basic< sequential > & get_domain_indirect(const std::string &name) const =0
virtual geo_abstract_rep< T, sequential > * clone() const =0
geo_abstract_base_rep< T > base
Definition geo.h:409
virtual const domain_indirect_basic< sequential > & get_domain_indirect(size_type i) const =0
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
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 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_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
const disarray< node_type, M > & get_nodes() const
Definition geo.h:592
base::variant_type variant_type
Definition geo.h:535
base::const_iterator_by_variant const_iterator_by_variant
Definition geo.h:539
const node_type & node(size_type inod) const
Definition geo.h:588
coordinate_type coordinate_system() const
Definition geo.h:566
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
size_type n_vertex() const
Definition geo.h:642
const distributor & geo_element_ownership(size_type dim) const
Definition geo.h:579
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
const node_type & node(const geo_element &K, size_type loc_inod) const
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
const node_type & dis_node(size_type dis_inod) const
Definition geo.h:589
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
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
const domain_indirect_basic< M > & get_domain_indirect(size_type i) const
Definition geo.h:597
size_type map_dimension() const
Definition geo.h:564
const node_type & xmin() const
Definition geo.h:572
size_type seq_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
const T & hmin() const
Definition geo.h:574
const basis_basic< T > & get_piola_basis() const
Definition geo.h:571
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
const geo_size & ios_sizes() const
Definition geo.h:577
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 distributor & vertex_ownership() const
Definition geo.h:636
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
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
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
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
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
const T & hmax() const
Definition geo.h:575
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
const node_type & xmax() const
Definition geo.h:573
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
size_type dis_n_node() const
Definition geo.h:641
const geo_size & sizes() const
Definition geo.h:576
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
const distributor & ownership() const
Definition geo.h:635
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
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
const communicator & comm() const
Definition geo.h:637
base::node_type node_type
Definition geo.h:534
distributor geo_element_ios_ownership(size_type dim) const
Definition geo.h:1437
const_iterator end(size_type dim) const
Definition geo.h:1538
rep::variant_type variant_type
Definition geo.h:1378
rep::const_iterator const_iterator
Definition geo.h:1383
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
void save(std::string filename="") const
const node_type & node(size_type inod) const
Definition geo.h:1446
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition geo.h:1500
coordinate_type coordinate_system() const
Definition geo.h:1414
void set_coordinate_system(std::string sys_coord_name)
Definition geo.h:1519
std::string name() const
Definition geo.h:1407
size_type neighbour(size_type ie, size_type loc_isid) const
Definition geo.h:1434
const distributor & geo_element_ownership(size_type dim) const
Definition geo.h:1422
const_iterator begin() const
Definition geo.h:1539
geo_basic(details::zero_dimension, const communicator &comm=communicator())
void set_nodes(const disarray< node_type, distributed > &x)
const geo_basic< T, distributed > & get_background_geo() const
size_type size(size_type dim) const
Definition geo.h:1527
rep::geo_element_map_type geo_element_map_type
Definition geo.h:1387
void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const
Definition geo.h:1448
geo_basic(const domain_indirect_basic< distributed > &dom, const geo_basic< T, distributed > &omega)
size_type ige2ios_dis_ige(size_type dim, size_type ige) const
Definition geo.h:1439
const geo_element & dom2bgd_geo_element(const geo_element &dom_K) const
Definition geo.h:1432
const node_type & dis_node(size_type dis_inod) const
Definition geo.h:1447
geo_abstract_rep< T, distributed > rep
Definition geo.h:1373
size_type serial_number() const
Definition geo.h:1412
void set_ios_permutation(disarray< size_type, distributed > &idof2ios_dis_idof) const
Definition geo.h:1565
size_type seq_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
Definition geo.h:1478
size_type map_dimension() const
Definition geo.h:1410
const node_type & xmin() const
Definition geo.h:1418
const domain_indirect_basic< distributed > & get_domain_indirect(const std::string &name) const
Definition geo.h:1456
const basis_basic< T > & get_piola_basis() const
Definition geo.h:1416
void locate(const disarray< point_basic< T >, distributed > &x, disarray< size_type, distributed > &dis_ie) const
Definition geo.h:1476
const geo_size & ios_sizes() const
Definition geo.h:1425
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
std::string familyname() const
Definition geo.h:1408
odiststream & put(odiststream &ops) const
Definition geo.h:1558
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
Definition geo.h:1546
void set_name(std::string name)
const_iterator_by_variant begin_by_variant(variant_type variant) const
Definition geo.h:1542
rep::coordinate_type coordinate_type
Definition geo.h:1386
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
size_type dis_inod2dis_iv(size_type dis_inod) const
Definition geo.h:1517
const_iterator_by_variant end_by_variant(variant_type variant) const
Definition geo.h:1544
size_type dimension() const
Definition geo.h:1409
size_type ios_ige2dis_ige(size_type dim, size_type ios_ige) const
Definition geo.h:1443
bool check(bool verbose=true) const
Definition geo.h:1561
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
rep::const_reference const_reference
Definition geo.h:1381
size_type n_domain_indirect() const
Definition geo.h:1452
size_type dis_n_vertex() const
Definition geo.h:1533
size_type dis_ige2ios_dis_ige(size_type dim, size_type dis_ige) const
Definition geo.h:1441
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
const node_type & xmax() const
Definition geo.h:1419
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
rep::const_iterator_by_variant const_iterator_by_variant
Definition geo.h:1385
const geo_element & bgd2dom_geo_element(const geo_element &bgd_K) const
Definition geo.h:1430
const disarray< node_type, distributed > & get_nodes() const
Definition geo.h:1450
geo_rep< T, distributed > rep_geo_rep
Definition geo.h:1374
void insert_domain_indirect(const domain_indirect_basic< distributed > &dom) const
Definition geo.h:1458
const_iterator end() const
Definition geo.h:1540
size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition geo.h:1504
geo_basic< T, distributed > get_domain(size_type i) const
const_reference get_geo_element(size_type dim, size_type ige) const
Definition geo.h:1426
const domain_indirect_basic< distributed > & get_domain_indirect(size_type i) const
Definition geo.h:1454
geo_basic< T, distributed > get_background_domain() const
rep::node_map_type node_map_type
Definition geo.h:1379
const geo_size & sizes() const
Definition geo.h:1424
const std::array< disarray< size_type, distributed >, reference_element::max_variant > & get_igev2ios_dis_igev() const
Definition geo.h:1570
void reset_order(size_type order)
rep::iterator_by_variant iterator_by_variant
Definition geo.h:1384
size_type dis_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
Definition geo.h:1483
std::string coordinate_system_name() const
Definition geo.h:1415
void set_coordinate_system(coordinate_type sys_coord)
bool have_domain_indirect(const std::string &name) const
Definition geo.h:1453
const_iterator begin(size_type dim) const
Definition geo.h:1537
smart_pointer_clone< rep > base
Definition geo.h:1375
const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const
Definition geo.h:1428
void build_by_subdividing(const geo_basic< T, distributed > &omega, size_type k)
size_type dis_size(size_type dim) const
Definition geo.h:1528
const communicator & comm() const
Definition geo.h:1529
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
void save(std::string filename="") const
const node_type & node(size_type inod) const
Definition geo.h:1173
const disarray< node_type, sequential > & get_nodes() const
Definition geo.h:1177
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
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
size_type n_vertex() const
Definition geo.h:1213
const distributor & geo_element_ownership(size_type dim) const
Definition geo.h:1161
geo_basic< T, sequential > get_domain(size_type i) const
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
const geo_element & dom2bgd_geo_element(const geo_element &dom_K) const
Definition geo.h:1168
const node_type & dis_node(size_type dis_inod) const
Definition geo.h:1174
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
size_type map_dimension() const
Definition geo.h:1149
const node_type & xmin() const
Definition geo.h:1157
const basis_basic< T > & get_piola_basis() const
Definition geo.h:1155
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
const geo_size & ios_sizes() const
Definition geo.h:1163
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
geo_basic< T, sequential > get_background_domain() const
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
Definition geo.h:1297
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
const domain_indirect_basic< sequential > & get_domain_indirect(size_type i) const
Definition geo.h:1182
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
rep::const_reference const_reference
Definition geo.h:1121
size_type n_domain_indirect() const
Definition geo.h:1180
size_type dis_n_vertex() const
Definition geo.h:1214
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
const node_type & xmax() const
Definition geo.h:1158
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
const geo_basic< T, sequential > & get_background_geo() const
rep::const_iterator_by_variant const_iterator_by_variant
Definition geo.h:1125
const geo_element & bgd2dom_geo_element(const geo_element &bgd_K) const
Definition geo.h:1167
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
geo_rep< T, sequential > rep_geo_rep
Definition geo.h:1115
const_reference get_geo_element(size_type dim, size_type ige) const
Definition geo.h:1164
const geo_size & sizes() const
Definition geo.h:1162
const domain_indirect_basic< sequential > & get_domain_indirect(const std::string &name) const
Definition geo.h:1184
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
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
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
const communicator & comm() const
Definition geo.h:1208
generic mesh with rerefence counting
Definition geo.h:1089
geo_element::size_type size_type
see the geo_element page for the full documentation
size_type size() const
distributed mesh representation
Definition geo.h:929
const_iterator end(size_type dim) const
Definition geo.h:1004
base::variant_type variant_type
Definition geo.h:936
base::const_iterator_by_variant const_iterator_by_variant
Definition geo.h:943
const distributor & geo_element_ownership(size_type dim) const
Definition geo.h:999
size_type size(size_type dim) const
Definition geo.h:998
base::iterator_by_variant iterator_by_variant
Definition geo.h:942
size_type map_dimension() const
Definition geo.h:996
const domain_indirect_basic< distributed > & get_domain_indirect(const std::string &name) const
Definition geo.h:1011
std::array< disarray< size_type, distributed >, reference_element::max_variant > _ios_igev2dis_igev
Definition geo.h:1069
geo_base_rep< T, distributed > base
Definition geo.h:933
std::array< disarray< size_type >, 4 > _ios_ige2dis_ige
Definition geo.h:1066
const geo_size & ios_sizes() const
Definition geo.h:973
std::array< disarray< size_type, distributed >, reference_element::max_variant > _igev2ios_dis_igev
Definition geo.h:1068
base::size_type size_type
Definition geo.h:934
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
Definition geo.h:1007
const distributor & vertex_ownership() const
Definition geo.h:1016
disarray< size_type > _ios_inod2dis_inod
Definition geo.h:1065
base::const_reference const_reference
Definition geo.h:939
disarray< size_type > _inod2ios_dis_inod
Definition geo.h:1064
base::const_iterator const_iterator
Definition geo.h:941
iterator end(size_type dim)
Definition geo.h:1006
base::node_map_type node_map_type
Definition geo.h:937
base::coordinate_type coordinate_type
Definition geo.h:944
base::geo_element_map_type geo_element_map_type
Definition geo.h:945
const_reference get_geo_element(size_type dim, size_type ige) const
Definition geo.h:1000
iterator begin(size_type dim)
Definition geo.h:1005
const std::array< disarray< size_type, distributed >, reference_element::max_variant > & get_igev2ios_dis_igev() const
Definition geo.h:1074
void reset_order(size_type order)
base::reference reference
Definition geo.h:938
reference get_geo_element(size_type dim, size_type ige)
Definition geo.h:1001
const_iterator begin(size_type dim) const
Definition geo.h:1003
void build_by_subdividing(const geo_basic< T, distributed > &omega, size_type k)
base::node_type node_type
Definition geo.h:935
const domain_indirect_basic< distributed > & get_domain_indirect(size_type idom) const
Definition geo.h:1010
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
base::iterator_by_variant iterator_by_variant
Definition geo.h:798
size_type map_dimension() const
Definition geo.h:846
void build_by_subdividing(const geo_basic< T, sequential > &omega, size_type k)
odiststream & put(odiststream &ops) const
Definition geo.h:870
base::size_type size_type
Definition geo.h:791
const distributor & vertex_ownership() const
Definition geo.h:862
base::const_reference const_reference
Definition geo.h:795
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_reference get_geo_element(size_type dim, size_type ige) const
Definition geo.h:849
iterator begin(size_type dim)
Definition geo.h:851
const domain_indirect_basic< sequential > & get_domain_indirect(const std::string &name) const
Definition geo.h:858
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
const domain_indirect_basic< sequential > & get_domain_indirect(size_type idom) const
Definition geo.h:857
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
idiststream: see the diststream page for the full documentation
Definition diststream.h:336
odiststream: see the diststream page for the full documentation
Definition diststream.h:137
std::istream & get(std::istream &s, int d=3)
Definition point.h:376
std::ostream & put(std::ostream &s, int d=3) const
Definition point.h:388
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)
geo_basic< Float, rheo_default_memory_model > geo
Definition geo.h:1575
int main()
Definition field2bb.cc:58
Expr1::float_type T
Definition field_expr.h:230
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
coordinate_type coordinate_system(std::string sys_coord)
std::string coordinate_system_name(coordinate_type i)
This file is part of Rheolef.
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 boundary_guard(const geo_basic< T, M > &omega)
Definition geo.cc:600
bool operator==(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
std::ostream & operator<<(std::ostream &os, const catchmark &m)
Definition catchmark.h:99
void sides_guard(const geo_basic< T, M > &omega)
Definition geo.cc:639
void put(std::ostream &out, std::string name, const tiny_matrix< T > &a)
Definition tiny_lu.h:155
geo_basic< T, M > geo_load(const std::string &filename)
sequential mesh with reference counting
Definition geo.cc:177
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition catchmark.h:88
void internal_sides_guard(const geo_basic< T, M > &omega)
Definition geo.cc:619
STL namespace.
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
std::istream & operator()(std::istream &is, point_basic< T > &x)
Definition geo.h:159
point_basic< T >::size_type size_type
Definition geo.h:156
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++(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
_self & operator++()
Definition geo.h:218
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
Expr1::memory_type M