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>
177 for (
size_t i = 0; i <
d; ++i) {
179 if (i+1 !=
d) os <<
" ";
186 template <
class T,
class M>
class geo_basic;
187 template <
class T,
class M>
class geo_domain_indirect_rep;
192 template<
class T,
class Ref,
class Ptr,
class IteratorByVariant>
294 virtual std::string
name()
const = 0;
335 size_type dis_ie_guest = std::numeric_limits<size_type>::max())
const = 0;
338 size_type dis_ie_guest = std::numeric_limits<size_type>::max())
const = 0;
366 template<
class T,
class Ref,
class Ptr,
class IteratorByVariant>
371 IteratorByVariant iter,
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),
400 template <
class T,
class M>
438 bool do_check =
false)
const = 0;
444 bool do_check =
false)
const = 0;
455 #ifdef _RHEOLEF_HAVE_MPI
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>,
472 virtual geo_abstract_rep<T,distributed>* clone()
const = 0;
473 virtual ~geo_abstract_rep () {}
477 virtual distributor geo_element_ios_ownership (
size_type dim)
const = 0;
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;
487 virtual const disarray<node_type,distributed>& get_nodes()
const = 0;
488 virtual void set_nodes (
const disarray<node_type,distributed>&) = 0;
490 virtual void locate (
492 disarray<size_type, distributed>& dis_ie,
493 bool do_check =
true)
const = 0;
494 virtual void trace_ray_boundary (
497 disarray<size_type, distributed>& dis_ie,
499 bool do_check =
false)
const = 0;
500 virtual void trace_move (
503 disarray<size_type, distributed>& dis_ie,
505 virtual void nearest (
508 disarray<size_type, distributed>& dis_ie)
const = 0;
512 virtual void set_ios_permutation (disarray<size_type,distributed>& idof2ios_dis_idof)
const = 0;
516 get_igev2ios_dis_igev()
const = 0;
527 template <
class T,
class M>
561 std::string
name()
const;
603 size_type dis_ie_guest = std::numeric_limits<size_type>::max())
const;
606 size_type dis_ie_guest = std::numeric_limits<size_type>::max())
const;
680 mutable std::vector<domain_indirect_basic<M> >
_domains;
703 template <
class T,
class M>
708 if (_have_neighbour)
return;
709 _have_neighbour =
true;
712 template <
class T,
class M>
716 return _geo_element [
variant].begin();
718 template <
class T,
class M>
722 return _geo_element [
variant].begin();
724 template <
class T,
class M>
728 return _geo_element [
variant].end();
730 template <
class T,
class M>
734 return _geo_element [
variant].end();
737 template <
class T,
class M>
747 template <
class T,
class M>
779 template <
class T,
class M>
816 void build_from_domain (
819 std::map<size_type,size_type>& bgd_ie2dom_ie,
820 std::map<size_type,size_type>& dis_bgd_ie2dis_dom_ie);
827 bool do_check =
false)
const;
828 void trace_ray_boundary (
833 bool do_check =
false)
const;
855 const geo_element_map_type& get_external_geo_element_map (
size_type variant)
const;
868 idiststream& get (idiststream&);
873 void load (std::string
name,
const communicator& = communicator());
880 void build_from_data (
889 idiststream& get_standard (idiststream&,
const geo_header&);
890 idiststream& get_upgrade (idiststream&,
const geo_header&);
891 void build_connectivity (
894 void build_connectivity_sides (
897 void set_element_side_index (
size_type side_dim);
898 void domain_set_side_part1 (
906 void domain_set_side_part2 (
919 friend void geo_build_by_subdividing<> (
924 #ifdef _RHEOLEF_HAVE_MPI
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;
942 typedef typename base::iterator_by_variant iterator_by_variant;
943 typedef typename base::const_iterator_by_variant const_iterator_by_variant;
945 typedef typename base::geo_element_map_type geo_element_map_type;
953 void build_from_domain (
956 std::map<size_type,size_type>& bgd_ie2dom_ie,
957 std::map<size_type,size_type>& dis_bgd_ie2dis_dom_ie);
973 const geo_size& ios_sizes()
const {
return _ios_gs; }
976 disarray<size_type, distributed>& dis_ie,
977 bool do_check =
false)
const;
978 void trace_ray_boundary (
981 disarray<size_type, distributed>& dis_ie,
983 bool do_check =
false)
const;
987 disarray<size_type, distributed>& dis_ie,
992 disarray<size_type, distributed>& dis_ie)
const;
996 size_type map_dimension ()
const {
return base::map_dimension(); }
997 bool is_broken()
const {
return base::is_broken(); }
999 const distributor& geo_element_ownership(
size_type dim)
const {
return base::geo_element_ownership (
dim); }
1003 const_iterator begin (
size_type dim)
const {
return base::begin(
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(); }
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); }
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); }
1019 reference operator[] (
size_type ie) {
return get_geo_element (map_dimension(), ie); }
1025 void build_by_subdividing (
const geo_basic<T,distributed>& omega,
size_type k);
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);
1037 void set_ios_permutation (disarray<size_type,distributed>& idof2ios_dis_idof)
const;
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,
1047 disarray<size_type>& bgd_isid2dom_dis_isid,
1048 disarray<size_type>& dom_isid2bgd_isid,
1049 disarray<size_type>& dom_isid2dom_ios_dis_isid,
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,
1056 disarray<size_type>& bgd_isid2dom_dis_isid,
1057 disarray<size_type>& dom_isid2bgd_isid,
1058 disarray<size_type>& dom_isid2dom_ios_dis_isid,
1061 void node_renumbering (
const distributor& ios_node_ownership);
1064 disarray<size_type> _inod2ios_dis_inod;
1065 disarray<size_type> _ios_inod2dis_inod;
1066 std::array<disarray<size_type>, 4> _ios_ige2dis_ige;
1074 get_igev2ios_dis_igev()
const {
return _igev2ios_dis_igev; }
1078 friend void geo_build_by_subdividing<> (
1079 geo_rep<T,distributed>& new_omega,
1080 const geo_basic<T,distributed>& old_omega,
1088 template <
class T,
class M = rheo_default_memory_model>
1146 std::string
name()
const {
return base::data().name(); }
1147 std::string
familyname()
const {
return base::data().familyname(); }
1159 const T&
hmin()
const {
return base::data().hmin(); }
1160 const T&
hmax()
const {
return base::data().hmax(); }
1166 {
return get_geo_element (
dim, dis_ige); }
1170 return base::data().neighbour (ie, loc_isid); }
1176 return base::data().dis_inod(K,
dis_inod); }
1183 return base::data().get_domain_indirect (i); }
1185 return base::data().get_domain_indirect (
name); }
1187 base::data().insert_domain_indirect (dom); }
1227 void save (std::string filename =
"")
const;
1233 idiststream& get (idiststream& ips);
1247 size_type dis_ie_guest = std::numeric_limits<size_type>::max())
const
1248 {
return base::data().seq_locate (x, dis_ie_guest); }
1251 size_type dis_ie_guest = std::numeric_limits<size_type>::max())
const
1252 {
return base::data().dis_locate (x, dis_ie_guest); }
1256 {
return base::data().locate (x, dis_ie); }
1261 {
return base::data().seq_trace_move (x,v,y); }
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); }
1282 {
return base::data().seq_nearest (x, x_nearest); }
1286 {
return base::data().dis_nearest (x, x_nearest); }
1291 { base::data().nearest (x, x_nearest, dis_ie); }
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); }
1311 template <
class T,
class M>
1312 idiststream&
operator>> (idiststream& ips, geo_basic<T,M>& omega);
1314 template <
class T,
class M>
1315 odiststream&
operator<< (odiststream& ops,
const geo_basic<T,M>& omega);
1329 base::operator= (geo_load<T,sequential>(
name));
1336 base::operator= (geo_load<T,sequential>(
name));
1344 return operator[] (
"boundary");
1352 return operator[] (
"internal_sides");
1360 return operator[] (
"sides");
1362 #ifdef _RHEOLEF_HAVE_MPI
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;
1384 typedef typename rep::iterator_by_variant iterator_by_variant;
1385 typedef typename rep::const_iterator_by_variant const_iterator_by_variant;
1387 typedef typename rep::geo_element_map_type geo_element_map_type;
1392 geo_basic (std::string
name,
const communicator& comm = communicator());
1393 void load (std::string
name,
const communicator& comm = communicator());
1403 : base (new_macro(rep_geo_rep(
lambda,node_list,elt_list))) {}
1407 std::string
name()
const {
return base::data().name(); }
1408 std::string familyname()
const {
return base::data().familyname(); }
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(); }
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(); }
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(); }
1437 distributor geo_element_ios_ownership (
size_type dim)
const {
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); }
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(); }
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); }
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;
1470 size_type dis_ie_guest = std::numeric_limits<size_type>::max())
const
1471 {
return base::data().seq_locate (x, dis_ie_guest); }
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); }
1482 {
return base::data().seq_trace_move (x,v,y); }
1487 {
return base::data().dis_trace_move (x,v,y); }
1488 void trace_ray_boundary (
1491 disarray<size_type, distributed>& dis_ie,
1493 {
return base::data().trace_ray_boundary (x,v,dis_ie,y); }
1497 disarray<size_type, distributed>& dis_ie,
1499 {
return base::data().trace_move (x,v,dis_ie,y); }
1503 {
return base::data().seq_nearest (x, x_nearest); }
1507 {
return base::data().dis_nearest (x, x_nearest); }
1511 disarray<size_type, distributed>& dis_ie)
const
1512 { base::data().nearest (x, x_nearest, dis_ie); }
1515 void set_nodes (
const disarray<node_type,distributed>& x);
1522 void set_name (std::string
name);
1523 void build_by_subdividing (
const geo_basic<T,distributed>& omega,
size_type k);
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()); }
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); }
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()); }
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); }
1549 const geo_basic<T,distributed>& get_background_geo()
const;
1550 geo_basic<T,distributed> get_background_domain()
const;
1554 bool operator== (
const geo_basic<T,distributed>& omega2)
const {
return base::data().operator== (omega2.data()); }
1558 odiststream&
put (odiststream& ops)
const {
return base::data().put (ops); }
1559 idiststream& get (idiststream& ips);
1560 void save (std::string filename =
"")
const;
1565 void set_ios_permutation (disarray<size_type,distributed>& idof2ios_dis_idof)
const
1566 { base::data().set_ios_permutation (idof2ios_dis_idof); }
1570 get_igev2ios_dis_igev()
const {
return base::data().get_igev2ios_dis_igev(); }
1581 #ifdef _RHEOLEF_HAVE_MPI
1585 : base (new_macro((
geo_rep<
T,distributed>)))
1590 geo_basic<T,distributed>::geo_basic (std::string
name,
const communicator& comm)
1593 base::operator= (geo_load<T,distributed>(
name));
1600 base::operator= (geo_load<T,distributed>(
name));
1605 geo_basic<T,distributed>::get (idiststream& ips)
1608 geo_rep<T,distributed>* ptr = new_macro((geo_rep<T,distributed>));
1610 base::operator= (ptr);
1615 geo_basic<T,distributed>
1619 return operator[] (
"boundary");
1623 geo_basic<T,distributed>
1624 geo_basic<T,distributed>::internal_sides()
const
1627 return operator[] (
"internal_sides");
1631 geo_basic<T,distributed>
1635 return operator[] (
"sides");
1642 template <
class T,
class M>
1647 return omega.get (ips);
1649 template <
class T,
class M>
1654 return omega.put (ops);
1660 #ifdef _RHEOLEF_GEO_DEMO_TST_CC
1663 using namespace std;
1664 int main(
int argc,
char**argv) {
1666 geo omega (argv[1]);
1668 cout << omega.size() <<
" " << omega.n_node() << endl;
1669 for (
size_t i = 0,
n = omega.size(); i <
n; ++i) {
1672 for (
size_t j = 0,
m = K.
size(); j <
m; ++j)
1673 cout <<
" " << K[j];
1676 for (
size_t jv = 0, nv = omega.n_node(); jv < nv; ++jv)
1677 cout << omega.
node(jv) << endl;
field::size_type size_type
int main(int argc, char **argv)
see the geo page for the full documentation
see the disarray page for the full documentation
see the distributor page for the full documentation
const communicator_type & comm() const
see the environment page for the full documentation
abstract base interface class
virtual const_iterator_by_variant begin_by_variant(variant_type variant) const =0
space_constant::coordinate_type coordinate_type
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
std::map< size_type, geo_element_auto<> > geo_element_map_type
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
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
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
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
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
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
virtual bool have_domain_indirect(const std::string &name) const =0
const geo_element & const_reference
virtual const distributor & geo_element_ownership(size_type dim) const =0
bool operator==(const geo_abstract_base_rep< T > &omega2) const
virtual size_type dis_inod2dis_iv(size_type dis_inod) const =0
virtual const node_type & xmin() const =0
virtual ~geo_abstract_base_rep()
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
hack_array< geo_element_hack >::iterator iterator_by_variant
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
virtual size_type neighbour(size_type ie, size_type loc_isid) const =0
reference_element::variant_type variant_type
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::variant_type variant_type
base::const_iterator_by_variant const_iterator_by_variant
virtual const domain_indirect_basic< sequential > & get_domain_indirect(size_type i) const =0
geo_abstract_base_rep< T > base
virtual void set_nodes(const disarray< node_type, sequential > &)=0
virtual ~geo_abstract_rep()
base::iterator_by_variant iterator_by_variant
base::size_type size_type
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
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
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
base::reference reference
base::node_type node_type
base class for M=sequential or distributed meshes representations
const_iterator end(size_type dim) const
size_type dis_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
base::variant_type variant_type
base::const_iterator_by_variant const_iterator_by_variant
const distributor & geo_element_ownership(size_type dim) const
const basis_basic< T > & get_piola_basis() const
coordinate_type coordinate_system() const
const node_type & xmin() const
const_iterator begin_face() const
const_iterator_by_variant end_by_variant(variant_type variant) const
const disarray< node_type, M > & get_nodes() const
const geo_size & ios_sizes() const
size_type n_vertex() const
iterator_by_variant begin_by_variant(variant_type variant)
const_iterator begin() const
size_type dis_size() 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
size_type dis_iv2dis_inod(size_type dis_iv) const
geo_locate< T, M > _locator
size_type dis_n_edge() const
size_type serial_number() const
std::vector< domain_indirect_basic< M > > _domains
geo_nearest< T, M > _nearestor
void set_dimension(size_type dim)
base::iterator_by_variant iterator_by_variant
const node_type & dis_node(size_type dis_inod) const
geo_trace_ray_boundary< T, M > _tracer_ray_boundary
void insert_domain_indirect(const domain_indirect_basic< M > &dom) const
size_type map_dimension() const
size_type seq_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
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
const_iterator end_face() const
static loaded_map_t _loaded_map
std::string familyname() const
base::size_type size_type
const_iterator_by_variant begin_by_variant(variant_type variant) const
void set_name(std::string name)
std::unordered_map< std::string, void * > loaded_map_t
basis_basic< T > _piola_basis
const_reference get_geo_element(size_type dim, size_type ige) const
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
const_iterator begin_edge() const
void init_neighbour() const
base::const_reference const_reference
const node_type & node(const geo_element &K, size_type loc_inod) const
size_type dimension() const
size_type neighbour(size_type ie, size_type loc_isid) const
const_iterator end_edge() const
const distributor & ownership() const
iterator end(size_type dim)
const_reference operator[](size_type ie) const
const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const
size_type dis_inod2dis_iv(size_type dis_inod) const
size_type n_domain_indirect() const
size_type dis_n_vertex() const
const node_type & xmax() const
iterator begin(size_type dim)
iterator by dimension: wraps iterator by geo_element variant
static loaded_map_t & loaded_map()
base::const_iterator const_iterator
disarray< node_type, M > _node
size_type variant() const
void set_serial_number(size_type i)
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
const domain_indirect_basic< M > & get_domain_indirect(size_type i) const
base::coordinate_type coordinate_type
iterator_by_variant end_by_variant(variant_type variant)
const_iterator end() const
const distributor & vertex_ownership() const
size_type dis_n_node() const
const node_type & node(size_type inod) const
const communicator & comm() const
std::array< hack_array< geo_element_hack, M >, reference_element::max_variant > _geo_element
base::reference reference
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)
bool have_domain_indirect(const std::string &name) const
const_iterator begin(size_type dim) const
geo_abstract_rep< T, M > base
size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
void set_nodes(const disarray< node_type, M > &x)
void neighbour_guard() const
base::node_type node_type
const geo_size & sizes() const
const_iterator end(size_type dim) const
rep::variant_type variant_type
rep::const_iterator const_iterator
const distributor & geo_element_ownership(size_type dim) const
void save(std::string filename="") const
const basis_basic< T > & get_piola_basis() const
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
coordinate_type coordinate_system() const
const node_type & xmin() const
void set_coordinate_system(std::string sys_coord_name)
size_type neighbour(size_type ie, size_type loc_isid) const
const geo_size & ios_sizes() const
size_type n_vertex() const
const_iterator begin() const
geo_basic(details::zero_dimension, const communicator &comm=communicator())
size_type dis_size() const
size_type size(size_type dim) const
rep::geo_element_map_type geo_element_map_type
void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const
size_type ige2ios_dis_ige(size_type dim, size_type ige) const
void insert_domain_indirect(const domain_indirect_basic< sequential > &dom) const
size_type serial_number() const
void set_dimension(size_type dim)
size_type seq_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
const node_type & dis_node(size_type dis_inod) const
size_type map_dimension() const
const domain_indirect_basic< sequential > & get_domain_indirect(size_type i) const
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
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
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
size_type seq_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
void build_by_subdividing(const geo_basic< T, sequential > &omega, size_type k)
std::string familyname() const
void set_name(std::string name)
size_type n_domain() const
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
rep::coordinate_type coordinate_type
size_type dis_inod2dis_iv(size_type dis_inod) const
const_iterator_by_variant end_by_variant(variant_type variant) const
size_type dimension() const
void set_ios_permutation(disarray< size_type, sequential > &idof2ios_dis_idof) const
size_type ios_ige2dis_ige(size_type dim, size_type ios_ige) const
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
bool check(bool verbose=true) const
const geo_element & dom2bgd_geo_element(const geo_element &dom_K) const
const domain_indirect_basic< sequential > & get_domain_indirect(const std::string &name) const
rep::const_reference const_reference
geo_basic< T, sequential > get_background_domain() const
size_type n_domain_indirect() const
size_type dis_n_vertex() const
const node_type & xmax() const
void locate(const disarray< point_basic< T >, sequential > &x, disarray< size_type, sequential > &dis_ie) const
size_type dis_ige2ios_dis_ige(size_type dim, size_type dis_ige) const
size_type variant() const
void set_serial_number(size_type i)
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
rep::const_iterator_by_variant const_iterator_by_variant
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)
geo_abstract_rep< T, sequential > rep
const_iterator end() const
size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
const geo_basic< T, sequential > & get_background_geo() const
geo_rep< T, sequential > rep_geo_rep
const node_type & node(size_type inod) const
const_reference get_geo_element(size_type dim, size_type ige) const
const communicator & comm() const
void reset_order(size_type order)
rep::iterator_by_variant iterator_by_variant
size_type dis_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
const disarray< node_type, sequential > & get_nodes() const
std::string coordinate_system_name() const
void set_coordinate_system(coordinate_type sys_coord)
bool have_domain_indirect(const std::string &name) const
const_iterator begin(size_type dim) const
smart_pointer_clone< rep > base
geo_basic< T, sequential > get_domain(size_type i) const
const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const
size_type dis_size(size_type dim) const
const geo_element & bgd2dom_geo_element(const geo_element &bgd_K) const
void neighbour_guard() const
const geo_size & sizes() const
geo_element::size_type size_type
see the geo_element page for the full documentation
size_type & node(size_type loc_inod)
const_iterator end(size_type dim) const
base::variant_type variant_type
base::const_iterator_by_variant const_iterator_by_variant
const distributor & geo_element_ownership(size_type dim) const
odiststream & put(odiststream &ops) const
base::iterator_by_variant iterator_by_variant
size_type map_dimension() const
void build_by_subdividing(const geo_basic< T, sequential > &omega, size_type k)
base::size_type size_type
base::const_reference const_reference
const domain_indirect_basic< sequential > & get_domain_indirect(const std::string &name) const
base::const_iterator const_iterator
iterator end(size_type dim)
base::coordinate_type coordinate_type
base::geo_element_map_type geo_element_map_type
void build_external_entities()
const distributor & vertex_ownership() const
const_reference get_geo_element(size_type dim, size_type ige) const
const domain_indirect_basic< sequential > & get_domain_indirect(size_type idom) const
iterator begin(size_type dim)
void reset_order(size_type order)
base::reference reference
reference get_geo_element(size_type dim, size_type ige)
const_iterator begin(size_type dim) const
geo_base_rep< T, sequential > base
base::node_type node_type
sequential mesh representation
std::vector< T, A >::iterator iterator
std::vector< T, A >::const_iterator const_iterator
odiststream: see the diststream page for the full documentation
std::istream & get(std::istream &s, int d=3)
std::ostream & put(std::ostream &s, int d=3) const
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
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)
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)
bool operator==(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
std::istream & operator>>(std::istream &is, const catchmark &m)
void boundary_guard(const geo_basic< T, M > &omega)
geo_basic< T, M > geo_load(const std::string &filename)
sequential mesh with reference counting
void sides_guard(const geo_basic< T, M > &omega)
idiststream & operator>>(idiststream &ips, geo_basic< T, M > &omega)
std::ostream & operator<<(std::ostream &os, const catchmark &m)
void internal_sides_guard(const geo_basic< T, M > &omega)
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_basic< T >::size_type size_type
std::istream & operator()(std::istream &is, point_basic< T > &x)
point_basic< T >::size_type size_type
std::ostream & operator()(std::ostream &os, const point_basic< T > &x)
point output helper, with rounding feature
_round_point_put(size_type d1, const T &eps1)
point_basic< T >::size_type size_type
std::ostream & operator()(std::ostream &os, const point_basic< T > &x)
void _reset_to_next_or_last()
IteratorByVariant _first_by_var[reference_element::max_variant]
geo_iterator< T, T &, T *, typename hack_array< T >::iterator > _nonconst_iterator
std::random_access_iterator_tag iterator_category
bool operator==(const _self &y) const
bool operator!=(const _self &y) const
reference operator*() const
IteratorByVariant _iter_by_var
geo_iterator(size_type dim, size_type variant, IteratorByVariant iter, Geo &omega)
ptrdiff_t difference_type
geo_iterator< T, Ref, Ptr, IteratorByVariant > _self
pointer operator->() const
IteratorByVariant _last_by_var[reference_element::max_variant]
size_type map_dimension() const
distributor ownership_by_dimension[4]
ostream & operator<<(ostream &os, const tiny_element &K)