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>
177 for (
size_t i = 0; i <
d; ++i) {
179 if (i+1 !=
d) os <<
" ";
186template <
class T,
class M>
class geo_basic;
187template <
class T,
class M>
class geo_domain_indirect_rep;
192template<
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;
359 virtual bool check(
bool verbose)
const = 0;
366template<
class T,
class Ref,
class Ptr,
class IteratorByVariant>
371 IteratorByVariant iter,
373 : _variant (variant),
382 _last_by_var [variant] = omega. end_by_variant (variant);
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),
400template <
class T,
class M>
438 bool do_check =
false)
const = 0;
444 bool do_check =
false)
const = 0;
455#ifdef _RHEOLEF_HAVE_MPI
466 typedef std::map <size_type, node_type, std::less<size_type>,
493 bool do_check =
true)
const = 0;
499 bool do_check =
false)
const = 0;
527template <
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;
703template <
class T,
class M>
708 if (_have_neighbour)
return;
709 _have_neighbour =
true;
712template <
class T,
class M>
716 return _geo_element [variant].begin();
718template <
class T,
class M>
722 return _geo_element [variant].begin();
724template <
class T,
class M>
728 return _geo_element [variant].end();
730template <
class T,
class M>
734 return _geo_element [variant].end();
737template <
class T,
class M>
747template <
class T,
class M>
779template <
class T,
class M>
781 geo_rep <T,M>& new_omega,
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;
872 void dump (std::string name)
const;
873 void load (std::string name,
const communicator& = communicator());
874 bool check(
bool verbose)
const;
880 void build_from_data (
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
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);
977 bool do_check =
false)
const;
978 void trace_ray_boundary (
983 bool do_check =
false)
const;
1008 {
return base::_geo_element[variant].get_dis_map_entries(); }
1019 reference operator[] (
size_type ie) {
return get_geo_element (map_dimension(), ie); }
1031 void dump (std::string name)
const;
1032 void load (std::string name,
const communicator& comm);
1033 bool check(
bool verbose)
const;
1041 void build_external_entities ();
1042 void set_element_side_index (
size_type side_dim);
1043 void domain_set_side_part1 (
1051 void domain_set_side_part2 (
1061 void node_renumbering (
const distributor& ios_node_ownership);
1078 friend void geo_build_by_subdividing<> (
1088template <
class T,
class M = rheo_default_memory_model>
1132 geo_basic (std::string name,
const communicator& comm = communicator());
1133 void load (std::string name,
const communicator& comm = communicator());
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); }
1208 const communicator&
comm()
const {
return geo_element_ownership (0).comm(); }
1227 void save (std::string filename =
"")
const;
1232 bool check (
bool verbose =
true)
const {
return base::data().check(verbose); }
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); }
1311template <
class T,
class M>
1312idiststream&
operator>> (idiststream& ips, geo_basic<T,M>& omega);
1314template <
class T,
class M>
1315odiststream&
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
1392 geo_basic (std::string name,
const communicator& comm = communicator());
1393 void load (std::string name,
const communicator& comm = communicator());
1407 std::string
name()
const {
return base::data().name(); }
1408 std::string
familyname()
const {
return base::data().familyname(); }
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); }
1427 {
return base::data().get_geo_element (dim, ige); }
1429 {
return base::data().dis_get_geo_element (dim, dis_ige); }
1431 {
return base::data().bgd2dom_geo_element (bgd_K); }
1433 {
return base::data().dom2bgd_geo_element (dom_K); }
1435 return base::data().neighbour (ie, loc_isid); }
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); }
1449 return base::data().dis_inod(K,dis_inod); }
1455 return base::data().get_domain_indirect (i); }
1457 return base::data().get_domain_indirect (name); }
1459 base::data().insert_domain_indirect (dom); }
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); }
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); }
1493 {
return base::data().trace_ray_boundary (x,v,dis_ie,y); }
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); }
1512 { base::data().nearest (x, x_nearest, dis_ie); }
1529 const communicator&
comm()
const {
return geo_element_ownership (0).comm(); }
1535 {
return get_geo_element (map_dimension(), ie); }
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); }
1560 void save (std::string filename =
"")
const;
1561 bool check (
bool verbose =
true)
const {
return base::data().check(verbose); }
1566 { base::data().set_ios_permutation (idof2ios_dis_idof); }
1581#ifdef _RHEOLEF_HAVE_MPI
1593 base::operator= (geo_load<T,distributed>(name));
1600 base::operator= (geo_load<T,distributed>(name));
1610 base::operator= (ptr);
1619 return operator[] (
"boundary");
1627 return operator[] (
"internal_sides");
1635 return operator[] (
"sides");
1642template <
class T,
class M>
1647 return omega.get (ips);
1649template <
class T,
class M>
1654 return omega.put (ops);
1660#ifdef _RHEOLEF_GEO_DEMO_TST_CC
1662#include "rheolef/environment.h"
1665int main(
int argc,
char**argv) {
1667 geo omega (argv[1]);
1669 cout << omega.size() <<
" " << omega.n_node() << endl;
1670 for (
size_t i = 0, n = omega.size(); i <
n; ++i) {
1673 for (
size_t j = 0, m = K.
size(); j <
m; ++j)
1674 cout <<
" " << K[j];
1677 for (
size_t jv = 0, nv = omega.n_node(); jv < nv; ++jv)
1678 cout << omega.node(jv) << endl;
field::size_type size_type
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
the finite element boundary domain
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 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
virtual const T & hmax() const =0
geo_iterator< geo_element, const geo_element &, const geo_element *, const_iterator_by_variant > const_iterator
virtual const basis_basic< T > & get_piola_basis() const =0
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 const distributor & geo_element_ownership(size_type dim) const =0
virtual bool check(bool verbose) const =0
const_iterator end(size_type dim) const
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
virtual const node_type & dis_node(size_type dis_inod) const =0
const_iterator begin(size_type dim) const
virtual size_type variant() const =0
virtual std::string name() const =0
geo_element_hack::size_type size_type
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
virtual bool have_domain_indirect(const std::string &name) const =0
const geo_element & const_reference
virtual const geo_element & bgd2dom_geo_element(const geo_element &bgd_K) const
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
virtual size_type dis_inod2dis_iv(size_type dis_inod) const =0
virtual odiststream & put(odiststream &ops) const =0
virtual ~geo_abstract_base_rep()
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
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
virtual size_type neighbour(size_type ie, size_type loc_isid) const =0
reference_element::variant_type variant_type
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
virtual geo_abstract_rep< T, distributed > * clone() const =0
virtual void set_ios_permutation(disarray< size_type, distributed > &idof2ios_dis_idof) const =0
virtual ~geo_abstract_rep()
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
base::size_type size_type
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
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
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
base::node_type node_type
virtual const disarray< node_type, sequential > & get_nodes() 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(const std::string &name) const =0
virtual geo_abstract_rep< T, sequential > * clone() const =0
geo_abstract_base_rep< T > base
virtual const domain_indirect_basic< sequential > & get_domain_indirect(size_type i) const =0
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
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 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
const disarray< node_type, M > & get_nodes() const
base::variant_type variant_type
base::const_iterator_by_variant const_iterator_by_variant
const node_type & node(size_type inod) const
coordinate_type coordinate_system() const
const_iterator begin_face() const
const_iterator_by_variant end_by_variant(variant_type variant) const
size_type n_vertex() const
const distributor & geo_element_ownership(size_type dim) const
iterator_by_variant begin_by_variant(variant_type variant)
const_iterator begin() const
size_type dis_size() const
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
size_type dis_iv2dis_inod(size_type dis_iv) const
geo_locate< T, M > _locator
size_type dis_n_edge() const
const node_type & dis_node(size_type dis_inod) 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
geo_trace_ray_boundary< T, M > _tracer_ray_boundary
void insert_domain_indirect(const domain_indirect_basic< M > &dom) const
const domain_indirect_basic< M > & get_domain_indirect(size_type i) const
size_type map_dimension() const
const node_type & xmin() const
size_type seq_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
const basis_basic< T > & get_piola_basis() 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
const geo_size & ios_sizes() 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 distributor & vertex_ownership() const
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
size_type dimension() const
size_type neighbour(size_type ie, size_type loc_isid) const
const_iterator end_edge() 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
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 node_type & xmax() const
base::coordinate_type coordinate_type
iterator_by_variant end_by_variant(variant_type variant)
const_iterator end() const
size_type dis_n_node() const
const geo_size & sizes() 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
const distributor & ownership() 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
const communicator & comm() const
base::node_type node_type
distributor geo_element_ios_ownership(size_type dim) const
const_iterator end(size_type dim) const
rep::variant_type variant_type
rep::const_iterator const_iterator
void nearest(const disarray< point_basic< T >, distributed > &x, disarray< point_basic< T >, distributed > &x_nearest, disarray< size_type, distributed > &dis_ie) const
void save(std::string filename="") const
const node_type & node(size_type inod) const
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
coordinate_type coordinate_system() const
void set_coordinate_system(std::string sys_coord_name)
size_type neighbour(size_type ie, size_type loc_isid) const
size_type n_vertex() const
const distributor & geo_element_ownership(size_type dim) const
const_iterator begin() const
geo_basic(details::zero_dimension, const communicator &comm=communicator())
void set_nodes(const disarray< node_type, distributed > &x)
size_type dis_size() const
const geo_basic< T, distributed > & get_background_geo() 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
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
const geo_element & dom2bgd_geo_element(const geo_element &dom_K) const
const node_type & dis_node(size_type dis_inod) const
geo_abstract_rep< T, distributed > rep
size_type serial_number() const
void set_ios_permutation(disarray< size_type, distributed > &idof2ios_dis_idof) 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
size_type map_dimension() const
const node_type & xmin() const
const domain_indirect_basic< distributed > & get_domain_indirect(const std::string &name) const
const basis_basic< T > & get_piola_basis() const
void locate(const disarray< point_basic< T >, distributed > &x, disarray< size_type, distributed > &dis_ie) const
const geo_size & ios_sizes() const
size_type seq_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
std::string familyname() const
odiststream & put(odiststream &ops) const
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
void set_name(std::string name)
size_type n_domain() const
const_iterator_by_variant begin_by_variant(variant_type variant) const
rep::coordinate_type coordinate_type
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
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
size_type ios_ige2dis_ige(size_type dim, size_type ios_ige) const
bool check(bool verbose=true) const
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
rep::const_reference const_reference
size_type n_domain_indirect() const
size_type dis_n_vertex() const
size_type dis_ige2ios_dis_ige(size_type dim, size_type dis_ige) const
size_type variant() const
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)
void set_serial_number(size_type i)
const node_type & xmax() const
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
const geo_element & bgd2dom_geo_element(const geo_element &bgd_K) const
const disarray< node_type, distributed > & get_nodes() const
geo_rep< T, distributed > rep_geo_rep
void insert_domain_indirect(const domain_indirect_basic< distributed > &dom) const
const_iterator end() const
size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
geo_basic< T, distributed > get_domain(size_type i) const
const_reference get_geo_element(size_type dim, size_type ige) const
const domain_indirect_basic< distributed > & get_domain_indirect(size_type i) const
geo_basic< T, distributed > get_background_domain() const
rep::node_map_type node_map_type
const geo_size & sizes() const
const std::array< disarray< size_type, distributed >, reference_element::max_variant > & get_igev2ios_dis_igev() 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
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
const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const
void build_by_subdividing(const geo_basic< T, distributed > &omega, size_type k)
size_type dis_size(size_type dim) const
void neighbour_guard() const
const communicator & comm() const
const_iterator end(size_type dim) const
rep::variant_type variant_type
rep::const_iterator const_iterator
void save(std::string filename="") const
const node_type & node(size_type inod) const
const disarray< node_type, sequential > & get_nodes() const
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
coordinate_type coordinate_system() const
void set_coordinate_system(std::string sys_coord_name)
size_type neighbour(size_type ie, size_type loc_isid) const
size_type n_vertex() const
const distributor & geo_element_ownership(size_type dim) const
geo_basic< T, sequential > get_domain(size_type i) 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
const geo_element & dom2bgd_geo_element(const geo_element &dom_K) const
const node_type & dis_node(size_type dis_inod) 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
size_type map_dimension() const
const node_type & xmin() const
const basis_basic< T > & get_piola_basis() 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
const geo_size & ios_sizes() 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
geo_basic< T, sequential > get_background_domain() const
const geo_element_map_type & get_external_geo_element_map(size_type variant) 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
const domain_indirect_basic< sequential > & get_domain_indirect(size_type i) 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
rep::const_reference const_reference
size_type n_domain_indirect() const
size_type dis_n_vertex() 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)
const node_type & xmax() const
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
const geo_basic< T, sequential > & get_background_geo() const
rep::const_iterator_by_variant const_iterator_by_variant
const geo_element & bgd2dom_geo_element(const geo_element &bgd_K) const
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
geo_rep< T, sequential > rep_geo_rep
const_reference get_geo_element(size_type dim, size_type ige) const
const geo_size & sizes() const
const domain_indirect_basic< sequential > & get_domain_indirect(const std::string &name) 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
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
const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const
size_type dis_size(size_type dim) const
void neighbour_guard() const
const communicator & comm() const
generic mesh with rerefence counting
geo_element::size_type size_type
see the geo_element page for the full documentation
distributed mesh representation
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
size_type size(size_type dim) const
base::iterator_by_variant iterator_by_variant
size_type map_dimension() const
const domain_indirect_basic< distributed > & get_domain_indirect(const std::string &name) const
std::array< disarray< size_type, distributed >, reference_element::max_variant > _ios_igev2dis_igev
geo_base_rep< T, distributed > base
std::array< disarray< size_type >, 4 > _ios_ige2dis_ige
const geo_size & ios_sizes() const
std::array< disarray< size_type, distributed >, reference_element::max_variant > _igev2ios_dis_igev
base::size_type size_type
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
const distributor & vertex_ownership() const
disarray< size_type > _ios_inod2dis_inod
base::const_reference const_reference
disarray< size_type > _inod2ios_dis_inod
base::const_iterator const_iterator
iterator end(size_type dim)
base::node_map_type node_map_type
base::coordinate_type coordinate_type
base::geo_element_map_type geo_element_map_type
const_reference get_geo_element(size_type dim, size_type ige) const
iterator begin(size_type dim)
const std::array< disarray< size_type, distributed >, reference_element::max_variant > & get_igev2ios_dis_igev() const
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
void build_by_subdividing(const geo_basic< T, distributed > &omega, size_type k)
base::node_type node_type
const domain_indirect_basic< distributed > & get_domain_indirect(size_type idom) const
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
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)
odiststream & put(odiststream &ops) const
base::size_type size_type
const distributor & vertex_ownership() const
base::const_reference const_reference
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_reference get_geo_element(size_type dim, size_type ige) const
iterator begin(size_type dim)
const domain_indirect_basic< sequential > & get_domain_indirect(const std::string &name) const
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
const domain_indirect_basic< sequential > & get_domain_indirect(size_type idom) 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
idiststream: see the diststream page for the full documentation
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)
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)
bool operator==(const heap_allocator< T1 > &lhs, const heap_allocator< T1 > &rhs)
std::ostream & operator<<(std::ostream &os, const catchmark &m)
void sides_guard(const geo_basic< T, M > &omega)
void put(std::ostream &out, std::string name, const tiny_matrix< T > &a)
geo_basic< T, M > geo_load(const std::string &filename)
sequential mesh with reference counting
std::istream & operator>>(std::istream &is, const catchmark &m)
void internal_sides_guard(const geo_basic< T, M > &omega)
void check(Float p, const field &uh)
void load(idiststream &in, Float &p, field &uh)
std::istream & operator()(std::istream &is, point_basic< T > &x)
point_basic< T >::size_type size_type
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]