geo_domain_indirect.h
Go to the documentation of this file.
#ifndef _RHEOLEF_DOMAIN_H
#define _RHEOLEF_DOMAIN_H
/*Class:domain
NAME: @code{geo_domain_indirect_rep} - a named part of a finite element mesh
@cindex mesh boundary
@clindex geo_domain_indirect_rep
DESCRIPTION:
@noindent
The @code{geo_domain_indirect_rep} class defines a container for a part of a
finite element mesh.
This describes the connectivity of edges or faces.
This class is useful for boundary condition setting.
IMPLEMENTATION NOTE:
The @code{geo_domain_indirect_rep} class is split into two parts.
The first one is the @code{domain_indirect} class, that contains the main
renumbering features: it acts as an indirection on a @code{geo} class(@pxref{geo class}).
The second one is the @code{geo} class itself, named here the background geo.
Thus, the @code{geo_domain_indirect} class develops a complete @code{geo}-like interface,
via the @code{geo_abstract_rep} pure virtual class derivation,
and can be used by the @code{space} class (@pxref{space class}).
The split between @code{domain_indirect} and @code{geo_domain_indirect} is necessary,
because the @code{geo} class contains a list of domain_indirect.
The @code{geo} class cannot contains a list of @code{geo_domain_indirect} classes, that refers
to the @code{geo} class itself: a loop in reference counting
leads to a blocking situation in the automatic deallocation.
DATE: 20 february 2011
End:
*/
#include "rheolef/geo.h"
#include "rheolef/domain_indirect.h"
namespace rheolef {
typedef geo domain;
// ========================================================================
// shared by seq & mpi rep
// ========================================================================
template <class T, class M>
class geo_domain_indirect_base_rep : public geo_abstract_rep<T,M> {
public:
// typedefs:
typedef geo_abstract_rep<T,M> base;
typedef typename base::size_type size_type;
typedef typename base::node_type node_type;
typedef typename base::variant_type variant_type;
typedef typename base::const_reference const_reference;
typedef typename base::const_iterator const_iterator;
typedef typename base::const_iterator_by_variant const_iterator_by_variant;
typedef typename base::iterator_by_variant iterator_by_variant;
typedef typename base::coordinate_type coordinate_type;
typedef typename base::geo_element_map_type geo_element_map_type;
// allocators:
geo_domain_indirect_base_rep ();
geo_domain_indirect_base_rep (const geo_domain_indirect_base_rep<T,M>&);
geo_domain_indirect_base_rep (const domain_indirect_basic<M>& indirect, const geo_basic<T,M>& omega);
// accessors:
const domain_indirect_basic<M>& get_indirect() const { return _indirect; }
const geo_basic<T,M>& get_background_geo() const { return _omega; }
// implemented geo_abstract interface:
size_type variant() const { return geo_abstract_base_rep<T>::geo_domain_indirect; }
std::string name() const { return _indirect.name(); }
std::string familyname() const { return _indirect.name(); }
size_type serial_number() const { return _omega.serial_number(); }
size_type dimension() const { return _omega.dimension(); }
size_type map_dimension() const { return _indirect.map_dimension(); }
bool is_broken() const { return _indirect.is_broken(); }
coordinate_type coordinate_system() const { return _omega.coordinate_system(); }
const basis_basic<T>& get_piola_basis() const { return _omega.get_piola_basis(); }
size_type n_node() const { return _omega.n_node(); }
const node_type& node (size_type inod) const { return _omega.node (inod); }
const disarray<node_type,M>& get_nodes() const { return _omega.get_nodes(); }
const node_type& xmin () const { return _omega.xmin (); }
const node_type& xmax () const { return _omega.xmax (); }
const T& hmin () const { return _omega.hmin (); }
const T& hmax () const { return _omega.hmax (); }
// partially implemented geo_abstract interface:
const distributor& geo_element_ownership (size_type dim) const;
const_reference get_geo_element (size_type dim, size_type ige) const;
size_type neighbour (size_type ie, size_type loc_iside) const;
void neighbour_guard() const;
// unimplemented geo_abstract interface:
size_type n_domain_indirect() const;
bool have_domain_indirect(const std::string& name) const;
const domain_indirect_basic<M>& get_domain_indirect (size_type i) const;
const domain_indirect_basic<M>& get_domain_indirect (const std::string& name) const;
void insert_domain_indirect (const domain_indirect_basic<M>& dom) const;
const_iterator_by_variant begin_by_variant (variant_type variant) const;
const_iterator_by_variant end_by_variant (variant_type variant) const;
const geo_element_map_type& get_external_geo_element_map (size_type variant) const;
const node_type& dis_node (size_type dis_inod) const;
size_type dis_inod2dis_iv (size_type dis_inod) const;
void dis_inod (const geo_element& K, std::vector<size_type>& dis_inod) const;
const geo_size& sizes() const;
const geo_size& ios_sizes() const;
odiststream& put (odiststream& ops) const;
void set_nodes (const disarray<node_type,M>&);
void reset_order (size_type order);
bool check(bool verbose) const;
size_type seq_locate(
const point_basic<T>& x,
size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const;
size_type dis_locate(
const point_basic<T>& x,
size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const;
void locate (
const disarray<point_basic<T>,M>& x,
disarray<size_type,M>& dis_ie,
bool do_check = false) const;
size_type seq_trace_move (
const point_basic<T>& x,
const point_basic<T>& v,
point_basic<T>& y) const;
size_type dis_trace_move (
const point_basic<T>& x,
const point_basic<T>& v,
point_basic<T>& y) const;
void trace_move (
const disarray<point_basic<T>,M>& x,
const disarray<point_basic<T>,M>& v,
disarray<size_type, M>& dis_ie,
disarray<point_basic<T>,M>& y) const;
void trace_ray_boundary (
const disarray<point_basic<T>,M>& x,
const disarray<point_basic<T>,M>& v,
disarray<size_type, M>& dis_ie,
disarray<point_basic<T>,M>& y,
bool do_check = false) const;
size_type seq_nearest (
const point_basic<T>& x,
point_basic<T>& x_nearest) const;
size_type dis_nearest (
const point_basic<T>& x,
point_basic<T>& x_nearest) const;
void nearest (
const disarray<point_basic<T>,M>& x,
disarray<point_basic<T>,M>& x_nearest,
disarray<size_type, M>& dis_ie) const;
protected:
// data:
domain_indirect_basic<M> _indirect;
geo_basic<T,M> _omega;
};
template <class T, class M>
inline
geo_domain_indirect_base_rep<T,M>::geo_domain_indirect_base_rep()
: geo_abstract_rep<T,M>(),
_indirect(),
_omega()
{
}
template <class T, class M>
inline
geo_domain_indirect_base_rep<T,M>::geo_domain_indirect_base_rep(
const geo_domain_indirect_base_rep<T,M>& dom)
: geo_abstract_rep<T,M>(dom),
_indirect(dom._indirect),
_omega(dom._omega)
{
}
template <class T, class M>
inline
geo_domain_indirect_base_rep<T,M>::geo_domain_indirect_base_rep (const domain_indirect_basic<M>& indirect, const geo_basic<T,M>& omega)
: geo_abstract_rep<T,M>(),
_indirect (indirect),
_omega (omega)
{
}
// ========================================================================
// sequential rep
// ========================================================================
template <class T, class M>
class geo_domain_indirect_rep {};
template <class T>
class geo_domain_indirect_rep<T,sequential> : public geo_domain_indirect_base_rep<T,sequential> {
public:
typedef geo_domain_indirect_base_rep<T,sequential> base;
typedef typename base::size_type size_type;
typedef typename base::node_type node_type;
geo_domain_indirect_rep ();
geo_domain_indirect_rep (const geo_domain_indirect_rep<T,sequential>& x);
geo_domain_indirect_rep (const domain_indirect_basic<sequential>& indirect, const geo_basic<T,sequential>& omega);
geo_abstract_rep<T,sequential>* clone() const;
};
// ========================================================================
// distributed rep
// ========================================================================
#ifdef _RHEOLEF_HAVE_MPI
template <class T>
class geo_domain_indirect_rep<T,distributed> : public geo_domain_indirect_base_rep<T,distributed> {
public:
typedef geo_domain_indirect_base_rep<T,distributed> base;
typedef typename base::size_type size_type;
typedef typename base::node_type node_type;
typedef typename base::const_reference const_reference;
geo_domain_indirect_rep();
geo_domain_indirect_rep (const geo_domain_indirect_rep<T,distributed>& x);
geo_domain_indirect_rep (const domain_indirect_basic<distributed>& indirect, const geo_basic<T,distributed>& omega);
geo_abstract_rep<T,distributed>* clone() const;
// accessors: the geo_abstract mpi interface is defined here
distributor geo_element_ios_ownership (size_type dim) const;
const_reference dis_get_geo_element (size_type map_dim, size_type dis_ige) const;
size_type ige2ios_dis_ige (size_type dim, size_type ige) const;
size_type dis_ige2ios_dis_ige (size_type dim, size_type dis_ige) const;
size_type ios_ige2dis_ige (size_type dim, size_type ios_ige) const;
void set_ios_permutation (disarray<size_type,distributed>& idof2ios_dis_idof) const;
// used by space_constritution for ios numbering
const std::array<disarray<size_type,distributed>,reference_element::max_variant>&
get_igev2ios_dis_igev() const;
};
#endif // _RHEOLEF_HAVE_MPI
// ========================================================================
// geo_basic allocator and accessor related to domains
// ========================================================================
#define _RHEOLEF_geo_domain(M) \
template<class T> \
inline \
geo_basic<T,M>::geo_basic ( \
const domain_indirect_basic<M>& dom, \
const geo_basic<T,M>& omega) \
: base (new_macro((geo_domain_indirect_rep<T,M>)(dom,omega))) \
{ \
} \
template<class T> \
inline \
geo_basic<T,M> \
geo_basic<T,M>::get_domain (size_type i) const \
{ \
const domain_indirect_basic<M>& dm = base::data().get_domain_indirect (i); \
return geo_basic<T,M> (dm, *this); \
} \
template<class T> \
inline \
geo_basic<T,M> \
geo_basic<T,M>::operator[] (const std::string& name) const \
{ \
if (name == "boundary") boundary_guard (*this); \
if (name == "sides") sides_guard (*this); \
if (name == "internal_sides") internal_sides_guard (*this); \
const domain_indirect_basic<M>& dm \
= base::data().get_domain_indirect (name); \
return geo_basic<T,M> (dm, *this); \
} \
template<class T> \
inline \
geo_basic<T,M> \
operator+ (const geo_basic<T,M>& a, const geo_basic<T,M>& b) \
{ \
check_macro (a.variant() == geo_abstract_base_rep<T>::geo_domain_indirect && \
b.variant() == geo_abstract_base_rep<T>::geo_domain_indirect, \
"union of geo may be domains of a mesh (was " \
<<a.name()<<" and "<<b.name()<<")"); \
check_macro (a.get_background_geo().name() == b.get_background_geo().name(), \
"union of domains between incompatible meshes (was " \
<<a.get_background_geo().name()<<" and "<<b.get_background_geo().name()<<")"); \
const geo_domain_indirect_rep<T,M>& a_dom \
= dynamic_cast<const geo_domain_indirect_rep<T,M>&>(a.data()); \
const geo_domain_indirect_rep<T,M>& b_dom \
= dynamic_cast<const geo_domain_indirect_rep<T,M>&>(b.data()); \
domain_indirect_basic<M> c_dom \
= build_union (a.get_background_geo(), a_dom.get_indirect(), b_dom.get_indirect()); \
return geo_basic<T,M> (c_dom, a.get_background_geo()); \
}
_RHEOLEF_geo_domain(sequential)
#ifdef _RHEOLEF_HAVE_MPI
_RHEOLEF_geo_domain(distributed)
#endif // _RHEOLEF_HAVE_MPI
#undef _RHEOLEF_domain
} // namespace rheolef
#endif // _RHEOLEF_DOMAIN_H
rheolef::geo_domain_indirect_rep
Definition: geo.h:187
rheolef::geo_domain_indirect_base_rep::dis_trace_move
size_type dis_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
Definition: geo_domain_indirect_seq.cc:178
rheolef::geo_domain_indirect_base_rep::trace_move
void trace_move(const disarray< point_basic< T >, M > &x, const disarray< point_basic< T >, M > &v, disarray< size_type, M > &dis_ie, disarray< point_basic< T >, M > &y) const
Definition: geo_domain_indirect_seq.cc:208
rheolef::geo_basic
generic mesh with rerefence counting
Definition: domain_indirect.h:64
rheolef::domain
geo domain
Definition: geo_domain_indirect.h:58
rheolef::geo_domain_indirect_base_rep::const_reference
base::const_reference const_reference
Definition: geo_domain_indirect.h:71
rheolef::geo_domain_indirect_base_rep::n_domain_indirect
size_type n_domain_indirect() const
Definition: geo_domain_indirect_seq.cc:66
rheolef::geo_abstract_base_rep::const_iterator_by_variant
hack_array< geo_element_hack >::const_iterator const_iterator_by_variant
Definition: geo.h:278
rheolef::geo_domain_indirect_base_rep::get_background_geo
const geo_basic< T, M > & get_background_geo() const
Definition: geo_domain_indirect.h:87
rheolef::geo_domain_indirect_base_rep::put
odiststream & put(odiststream &ops) const
Definition: geo_domain_indirect_seq.cc:98
rheolef::geo_size
Definition: geo_size.h:29
rheolef::point_basic
Definition: point.h:87
rheolef::geo_domain_indirect_base_rep
Definition: geo_domain_indirect.h:64
rheolef::geo_domain_indirect_base_rep::_omega
geo_basic< T, M > _omega
Definition: geo_domain_indirect.h:177
rheolef::geo_domain_indirect_base_rep::set_nodes
void set_nodes(const disarray< node_type, M > &)
Definition: geo_domain_indirect_seq.cc:136
rheolef::geo_domain_indirect_base_rep::dis_inod
void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const
Definition: geo_domain_indirect_seq.cc:124
rheolef::geo_domain_indirect_base_rep::coordinate_system
coordinate_type coordinate_system() const
Definition: geo_domain_indirect.h:98
rheolef::geo_domain_indirect_base_rep::is_broken
bool is_broken() const
Definition: geo_domain_indirect.h:97
rheolef::geo_abstract_base_rep::size_type
geo_element_hack::size_type size_type
Definition: geo.h:260
rheolef::sequential
Definition: distributed.h:28
rheolef::geo_domain_indirect_base_rep::dis_locate
size_type dis_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
Definition: geo_domain_indirect_seq.cc:161
rheolef::geo_domain_indirect_base_rep::get_external_geo_element_map
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
Definition: geo_domain_indirect_seq.cc:58
rheolef::geo_domain_indirect_base_rep::dimension
size_type dimension() const
Definition: geo_domain_indirect.h:95
rheolef::geo_domain_indirect_base_rep::hmax
const T & hmax() const
Definition: geo_domain_indirect.h:107
rheolef::geo_domain_indirect_rep< T, distributed >::base
geo_domain_indirect_base_rep< T, distributed > base
Definition: geo_domain_indirect.h:229
rheolef::geo_domain_indirect_base_rep::map_dimension
size_type map_dimension() const
Definition: geo_domain_indirect.h:96
rheolef::geo_domain_indirect_base_rep::name
std::string name() const
Definition: geo_domain_indirect.h:92
rheolef::distributor
see the distributor page for the full documentation
Definition: distributor.h:62
mkgeo_ball.order
order
Definition: mkgeo_ball.sh:343
rheolef::geo_abstract_rep< T, distributed >::const_reference
base::const_reference const_reference
Definition: geo.h:465
rheolef::geo_element
see the geo_element page for the full documentation
Definition: geo_element.h:102
rheolef::geo_domain_indirect_rep< T, distributed >::size_type
base::size_type size_type
Definition: geo_domain_indirect.h:230
rheolef::geo_domain_indirect_base_rep::variant
size_type variant() const
Definition: geo_domain_indirect.h:91
rheolef::geo_domain_indirect_base_rep::dis_node
const node_type & dis_node(size_type dis_inod) const
Definition: geo_domain_indirect_seq.cc:118
rheolef::geo_domain_indirect_base_rep::dis_inod2dis_iv
size_type dis_inod2dis_iv(size_type dis_inod) const
Definition: geo_domain_indirect_seq.cc:130
rheolef::geo_domain_indirect_rep< T, sequential >::size_type
base::size_type size_type
Definition: geo_domain_indirect.h:214
rheolef::geo_domain_indirect_base_rep::_indirect
domain_indirect_basic< M > _indirect
Definition: geo_domain_indirect.h:176
rheolef::geo_domain_indirect_rep< T, sequential >::node_type
base::node_type node_type
Definition: geo_domain_indirect.h:215
rheolef::geo_domain_indirect_base_rep::node_type
base::node_type node_type
Definition: geo_domain_indirect.h:69
rheolef::geo_domain_indirect_base_rep::serial_number
size_type serial_number() const
Definition: geo_domain_indirect.h:94
rheolef::basis_basic
Definition: basis.h:206
rheolef::geo_domain_indirect_base_rep::neighbour
size_type neighbour(size_type ie, size_type loc_iside) const
Definition: geo_domain_indirect_seq.cc:245
rheolef::geo_abstract_base_rep
abstract base interface class
Definition: geo.h:248
rheolef::geo_domain_indirect_base_rep::insert_domain_indirect
void insert_domain_indirect(const domain_indirect_basic< M > &dom) const
Definition: geo_domain_indirect_seq.cc:92
rheolef::domain_indirect_basic< distributed >
Definition: domain_indirect.h:559
rheolef::geo_domain_indirect_base_rep::reset_order
void reset_order(size_type order)
Definition: geo_domain_indirect_seq.cc:148
rheolef::geo_basic< T, sequential >
Definition: geo.h:1108
rheolef::geo_basic< T, distributed >
distributed mesh with rerefence counting
Definition: geo.h:1367
rheolef::geo_domain_indirect_base_rep::end_by_variant
const_iterator_by_variant end_by_variant(variant_type variant) const
Definition: geo_domain_indirect_seq.cc:50
rheolef::geo_domain_indirect_base_rep::base
geo_abstract_rep< T, M > base
Definition: geo_domain_indirect.h:67
rheolef::geo_domain_indirect_base_rep::const_iterator_by_variant
base::const_iterator_by_variant const_iterator_by_variant
Definition: geo_domain_indirect.h:73
rheolef::geo_domain_indirect_base_rep::sizes
const geo_size & sizes() const
Definition: geo_domain_indirect_seq.cc:105
rheolef::geo_domain_indirect_base_rep::geo_element_map_type
base::geo_element_map_type geo_element_map_type
Definition: geo_domain_indirect.h:76
rheolef::geo_domain_indirect_base_rep::seq_trace_move
size_type seq_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
Definition: geo_domain_indirect_seq.cc:168
rheolef::geo_domain_indirect_base_rep::locate
void locate(const disarray< point_basic< T >, M > &x, disarray< size_type, M > &dis_ie, bool do_check=false) const
Definition: geo_domain_indirect_seq.cc:188
rheolef::distributed
Definition: distributed.h:88
rheolef::geo_domain_indirect_rep< T, sequential >::base
geo_domain_indirect_base_rep< T, sequential > base
Definition: geo_domain_indirect.h:213
rheolef::geo_domain_indirect_rep< T, distributed >
Definition: geo_domain_indirect.h:227
rheolef::geo_abstract_rep
abstract interface class
Definition: domain_indirect.h:62
rheolef::geo_abstract_rep< T, sequential >
Definition: geo.h:404
rheolef::geo_iterator
geo iterator
Definition: geo.h:193
rheolef::geo_domain_indirect_base_rep::get_indirect
const domain_indirect_basic< M > & get_indirect() const
Definition: geo_domain_indirect.h:86
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
rheolef::geo_domain_indirect_base_rep::seq_nearest
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition: geo_domain_indirect_seq.cc:218
rheolef::geo_domain_indirect_base_rep::iterator_by_variant
base::iterator_by_variant iterator_by_variant
Definition: geo_domain_indirect.h:74
rheolef::geo_domain_indirect_base_rep::n_node
size_type n_node() const
Definition: geo_domain_indirect.h:101
rheolef::geo_domain_indirect_base_rep::xmax
const node_type & xmax() const
Definition: geo_domain_indirect.h:105
rheolef::odiststream
odiststream: see the diststream page for the full documentation
Definition: diststream.h:126
rheolef::geo_domain_indirect_base_rep::nearest
void nearest(const disarray< point_basic< T >, M > &x, disarray< point_basic< T >, M > &x_nearest, disarray< size_type, M > &dis_ie) const
Definition: geo_domain_indirect_seq.cc:236
rheolef::disarray< node_type, M >
rheolef::geo_domain_indirect_base_rep::get_geo_element
const_reference get_geo_element(size_type dim, size_type ige) const
Definition: geo_domain_indirect_seq.cc:35
rheolef::geo_domain_indirect_base_rep::trace_ray_boundary
void trace_ray_boundary(const disarray< point_basic< T >, M > &x, const disarray< point_basic< T >, M > &v, disarray< size_type, M > &dis_ie, disarray< point_basic< T >, M > &y, bool do_check=false) const
Definition: geo_domain_indirect_seq.cc:197
rheolef::domain_indirect_basic< sequential >
Definition: domain_indirect.h:342
rheolef::geo_domain_indirect_base_rep::geo_domain_indirect_base_rep
geo_domain_indirect_base_rep()
Definition: geo_domain_indirect.h:181
rheolef::geo_domain_indirect_base_rep::ios_sizes
const geo_size & ios_sizes() const
Definition: geo_domain_indirect_seq.cc:111
rheolef::geo_domain_indirect_base_rep::get_piola_basis
const basis_basic< T > & get_piola_basis() const
Definition: geo_domain_indirect.h:99
mkgeo_ball.verbose
verbose
Definition: mkgeo_ball.sh:133
rheolef::geo_domain_indirect_base_rep::have_domain_indirect
bool have_domain_indirect(const std::string &name) const
Definition: geo_domain_indirect_seq.cc:72
rheolef::geo_domain_indirect_base_rep::begin_by_variant
const_iterator_by_variant begin_by_variant(variant_type variant) const
Definition: geo_domain_indirect_seq.cc:42
rheolef::geo_domain_indirect_base_rep::xmin
const node_type & xmin() const
Definition: geo_domain_indirect.h:104
rheolef::geo_domain_indirect_base_rep::check
bool check(bool verbose) const
Definition: geo_domain_indirect_seq.cc:142
rheolef::geo_domain_indirect_base_rep::geo_element_ownership
const distributor & geo_element_ownership(size_type dim) const
Definition: geo_domain_indirect_seq.cc:27
rheolef::geo_abstract_rep< T, distributed >
Definition: geo.h:457
rheolef::geo_domain_indirect_base_rep::variant_type
base::variant_type variant_type
Definition: geo_domain_indirect.h:70
size_type
field::size_type size_type
Definition: branch.cc:425
rheolef::geo_domain_indirect_base_rep::hmin
const T & hmin() const
Definition: geo_domain_indirect.h:106
rheolef::geo_domain_indirect_rep< T, distributed >::node_type
base::node_type node_type
Definition: geo_domain_indirect.h:231
rheolef::geo_domain_indirect_base_rep::coordinate_type
base::coordinate_type coordinate_type
Definition: geo_domain_indirect.h:75
rheolef::geo_domain_indirect_rep< T, distributed >::const_reference
base::const_reference const_reference
Definition: geo_domain_indirect.h:232
rheolef::geo_domain_indirect_base_rep::node
const node_type & node(size_type inod) const
Definition: geo_domain_indirect.h:102
mkgeo_ball.map_dim
map_dim
Definition: mkgeo_ball.sh:337
rheolef::geo_domain_indirect_base_rep::dis_nearest
size_type dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
Definition: geo_domain_indirect_seq.cc:227
rheolef::geo_domain_indirect_base_rep::get_domain_indirect
const domain_indirect_basic< M > & get_domain_indirect(size_type i) const
Definition: geo_domain_indirect_seq.cc:78
rheolef::geo_domain_indirect_base_rep::seq_locate
size_type seq_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
Definition: geo_domain_indirect_seq.cc:154
rheolef::geo_domain_indirect_base_rep::size_type
base::size_type size_type
Definition: geo_domain_indirect.h:68
rheolef::geo_abstract_base_rep::geo_element_map_type
std::map< size_type, geo_element_auto<> > geo_element_map_type
Definition: geo.h:266
rheolef::geo_abstract_base_rep::iterator_by_variant
hack_array< geo_element_hack >::iterator iterator_by_variant
Definition: geo.h:269
mkgeo_ball.dim
dim
Definition: mkgeo_ball.sh:307
rheolef::geo_abstract_base_rep::variant_type
reference_element::variant_type variant_type
Definition: geo.h:262
rheolef::domain_indirect_basic
the finite element boundary domain
Definition: domain_indirect.h:335
rheolef::space_constant::coordinate_type
coordinate_type
Definition: space_constant.h:121
rheolef::geo_domain_indirect_base_rep::neighbour_guard
void neighbour_guard() const
Definition: geo_domain_indirect_seq.cc:252
rheolef::geo_domain_indirect_base_rep::const_iterator
base::const_iterator const_iterator
Definition: geo_domain_indirect.h:72
rheolef::geo_domain_indirect_base_rep::get_nodes
const disarray< node_type, M > & get_nodes() const
Definition: geo_domain_indirect.h:103
M
Expr1::memory_type M
Definition: vec_expr_v2.h:385
rheolef::geo_domain_indirect_rep< T, sequential >
Definition: geo_domain_indirect.h:211
T
Expr1::float_type T
Definition: field_expr.h:218
rheolef::geo_domain_indirect_base_rep::familyname
std::string familyname() const
Definition: geo_domain_indirect.h:93