Rheolef  7.2
an efficient C++ finite element environment
 
Loading...
Searching...
No Matches
geo_domain_indirect.h
Go to the documentation of this file.
1#ifndef _RHEOLEF_DOMAIN_H
2#define _RHEOLEF_DOMAIN_H
23
24/*Class:domain
25NAME: @code{geo_domain_indirect_rep} - a named part of a finite element mesh
26@cindex mesh boundary
27@clindex geo_domain_indirect_rep
28DESCRIPTION:
29 @noindent
30 The @code{geo_domain_indirect_rep} class defines a container for a part of a
31 finite element mesh.
32 This describes the connectivity of edges or faces.
33 This class is useful for boundary condition setting.
34IMPLEMENTATION NOTE:
35 The @code{geo_domain_indirect_rep} class is split into two parts.
36 The first one is the @code{domain_indirect} class, that contains the main
37 renumbering features: it acts as an indirection on a @code{geo} class(@pxref{geo class}).
38 The second one is the @code{geo} class itself, named here the background geo.
39 Thus, the @code{geo_domain_indirect} class develops a complete @code{geo}-like interface,
40 via the @code{geo_abstract_rep} pure virtual class derivation,
41 and can be used by the @code{space} class (@pxref{space class}).
42
43 The split between @code{domain_indirect} and @code{geo_domain_indirect} is necessary,
44 because the @code{geo} class contains a list of domain_indirect.
45 The @code{geo} class cannot contains a list of @code{geo_domain_indirect} classes, that refers
46 to the @code{geo} class itself: a loop in reference counting
47 leads to a blocking situation in the automatic deallocation.
48
49DATE: 20 february 2011
50End:
51*/
52
53#include "rheolef/geo.h"
54#include "rheolef/domain_indirect.h"
55
56namespace rheolef {
57
58typedef geo domain;
59
60// ========================================================================
61// shared by seq & mpi rep
62// ========================================================================
63template <class T, class M>
65public:
66// typedefs:
68 typedef typename base::size_type size_type;
69 typedef typename base::node_type node_type;
70 typedef typename base::variant_type variant_type;
71 typedef typename base::const_reference const_reference;
72 typedef typename base::const_iterator const_iterator;
73 typedef typename base::const_iterator_by_variant const_iterator_by_variant;
74 typedef typename base::iterator_by_variant iterator_by_variant;
75 typedef typename base::coordinate_type coordinate_type;
76 typedef typename base::geo_element_map_type geo_element_map_type;
77
78// allocators:
79
83
84// accessors:
85
87 const geo_basic<T,M>& get_background_geo() const { return _omega; }
88
89// implemented geo_abstract interface:
90
92 std::string name() const { return _indirect.name(); }
93 std::string familyname() const { return _indirect.name(); }
94 size_type serial_number() const { return _omega.serial_number(); }
95 size_type dimension() const { return _omega.dimension(); }
96 size_type map_dimension() const { return _indirect.map_dimension(); }
97 bool is_broken() const { return _indirect.is_broken(); }
98 coordinate_type coordinate_system() const { return _omega.coordinate_system(); }
99 const basis_basic<T>& get_piola_basis() const { return _omega.get_piola_basis(); }
100
101 size_type n_node() const { return _omega.n_node(); }
102 const node_type& node (size_type inod) const { return _omega.node (inod); }
103 const disarray<node_type,M>& get_nodes() const { return _omega.get_nodes(); }
104 const node_type& xmin () const { return _omega.xmin (); }
105 const node_type& xmax () const { return _omega.xmax (); }
106 const T& hmin () const { return _omega.hmin (); }
107 const T& hmax () const { return _omega.hmax (); }
108
109// partially implemented geo_abstract interface:
110
113 size_type neighbour (size_type ie, size_type loc_iside) const;
114 void neighbour_guard() const;
115
116// unimplemented geo_abstract interface:
117
119 bool have_domain_indirect(const std::string& name) const;
120 const domain_indirect_basic<M>& get_domain_indirect (size_type i) const;
121 const domain_indirect_basic<M>& get_domain_indirect (const std::string& name) const;
122 void insert_domain_indirect (const domain_indirect_basic<M>& dom) const;
126 const node_type& dis_node (size_type dis_inod) const;
128 void dis_inod (const geo_element& K, std::vector<size_type>& dis_inod) const;
129 const geo_size& sizes() const;
130 const geo_size& ios_sizes() const;
131 odiststream& put (odiststream& ops) const;
132 void set_nodes (const disarray<node_type,M>&);
133 void reset_order (size_type order);
134 bool check(bool verbose) const;
136 const point_basic<T>& x,
137 size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const;
139 const point_basic<T>& x,
140 size_type dis_ie_guest = std::numeric_limits<size_type>::max()) const;
141 void locate (
142 const disarray<point_basic<T>,M>& x,
143 disarray<size_type,M>& dis_ie,
144 bool do_check = false) const;
146 const point_basic<T>& x,
147 const point_basic<T>& v,
148 point_basic<T>& y) const;
150 const point_basic<T>& x,
151 const point_basic<T>& v,
152 point_basic<T>& y) const;
153 void trace_move (
154 const disarray<point_basic<T>,M>& x,
155 const disarray<point_basic<T>,M>& v,
157 disarray<point_basic<T>,M>& y) const;
158 void trace_ray_boundary (
159 const disarray<point_basic<T>,M>& x,
160 const disarray<point_basic<T>,M>& v,
163 bool do_check = false) const;
165 const point_basic<T>& x,
166 point_basic<T>& x_nearest) const;
168 const point_basic<T>& x,
169 point_basic<T>& x_nearest) const;
170 void nearest (
171 const disarray<point_basic<T>,M>& x,
172 disarray<point_basic<T>,M>& x_nearest,
173 disarray<size_type, M>& dis_ie) const;
174protected:
175// data:
178};
179template <class T, class M>
180inline
187template <class T, class M>
188inline
191 : geo_abstract_rep<T,M>(dom),
192 _indirect(dom._indirect),
193 _omega(dom._omega)
194{
195}
196template <class T, class M>
197inline
199 : geo_abstract_rep<T,M>(),
200 _indirect (indirect),
201 _omega (omega)
202{
203}
204// ========================================================================
205// sequential rep
206// ========================================================================
207template <class T, class M>
209
210template <class T>
222// ========================================================================
223// distributed rep
224// ========================================================================
225#ifdef _RHEOLEF_HAVE_MPI
226template <class T>
228public:
230 typedef typename base::size_type size_type;
231 typedef typename base::node_type node_type;
233
238
239// accessors: the geo_abstract mpi interface is defined here
240
241 distributor geo_element_ios_ownership (size_type dim) const;
242 const_reference dis_get_geo_element (size_type map_dim, size_type dis_ige) const;
243 size_type ige2ios_dis_ige (size_type dim, size_type ige) const;
244 size_type dis_ige2ios_dis_ige (size_type dim, size_type dis_ige) const;
245 size_type ios_ige2dis_ige (size_type dim, size_type ios_ige) const;
246 void set_ios_permutation (disarray<size_type,distributed>& idof2ios_dis_idof) const;
247 // used by space_constritution for ios numbering
248 const std::array<disarray<size_type,distributed>,reference_element::max_variant>&
249 get_igev2ios_dis_igev() const;
250};
251#endif // _RHEOLEF_HAVE_MPI
252// ========================================================================
253// geo_basic allocator and accessor related to domains
254// ========================================================================
255#define _RHEOLEF_geo_domain(M) \
256template<class T> \
257inline \
258geo_basic<T,M>::geo_basic ( \
259 const domain_indirect_basic<M>& dom, \
260 const geo_basic<T,M>& omega) \
261 : base (new_macro((geo_domain_indirect_rep<T,M>)(dom,omega))) \
262{ \
263} \
264template<class T> \
265inline \
266geo_basic<T,M> \
267geo_basic<T,M>::get_domain (size_type i) const \
268{ \
269 const domain_indirect_basic<M>& dm = base::data().get_domain_indirect (i); \
270 return geo_basic<T,M> (dm, *this); \
271} \
272template<class T> \
273inline \
274geo_basic<T,M> \
275geo_basic<T,M>::operator[] (const std::string& name) const \
276{ \
277 if (name == "boundary") boundary_guard (*this); \
278 if (name == "sides") sides_guard (*this); \
279 if (name == "internal_sides") internal_sides_guard (*this); \
280 const domain_indirect_basic<M>& dm \
281 = base::data().get_domain_indirect (name); \
282 return geo_basic<T,M> (dm, *this); \
283} \
284template<class T> \
285inline \
286geo_basic<T,M> \
287operator+ (const geo_basic<T,M>& a, const geo_basic<T,M>& b) \
288{ \
289 check_macro (a.variant() == geo_abstract_base_rep<T>::geo_domain_indirect && \
290 b.variant() == geo_abstract_base_rep<T>::geo_domain_indirect, \
291 "union of geo may be domains of a mesh (was " \
292 <<a.name()<<" and "<<b.name()<<")"); \
293 check_macro (a.get_background_geo().name() == b.get_background_geo().name(), \
294 "union of domains between incompatible meshes (was " \
295 <<a.get_background_geo().name()<<" and "<<b.get_background_geo().name()<<")"); \
296 const geo_domain_indirect_rep<T,M>& a_dom \
297 = dynamic_cast<const geo_domain_indirect_rep<T,M>&>(a.data()); \
298 const geo_domain_indirect_rep<T,M>& b_dom \
299 = dynamic_cast<const geo_domain_indirect_rep<T,M>&>(b.data()); \
300 domain_indirect_basic<M> c_dom \
301 = build_union (a.get_background_geo(), a_dom.get_indirect(), b_dom.get_indirect()); \
302 return geo_basic<T,M> (c_dom, a.get_background_geo()); \
303}
304
305_RHEOLEF_geo_domain(sequential)
306#ifdef _RHEOLEF_HAVE_MPI
307_RHEOLEF_geo_domain(distributed)
308#endif // _RHEOLEF_HAVE_MPI
309#undef _RHEOLEF_domain
310
311} // namespace rheolef
312#endif // _RHEOLEF_DOMAIN_H
field::size_type size_type
Definition branch.cc:430
see the disarray page for the full documentation
Definition disarray.h:497
see the distributor page for the full documentation
Definition distributor.h:69
the finite element boundary domain
abstract base interface class
Definition geo.h:248
abstract interface class
Definition geo.h:401
generic mesh with rerefence counting
Definition geo.h:1089
const disarray< node_type, M > & get_nodes() const
base::const_iterator_by_variant const_iterator_by_variant
const node_type & node(size_type inod) const
const distributor & geo_element_ownership(size_type dim) const
const geo_basic< T, M > & get_background_geo() const
geo_domain_indirect_base_rep(const geo_domain_indirect_base_rep< T, M > &)
void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const
const_iterator_by_variant end_by_variant(variant_type variant) const
const_iterator_by_variant begin_by_variant(variant_type variant) const
const node_type & dis_node(size_type dis_inod) const
base::iterator_by_variant iterator_by_variant
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 dis_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) const
size_type dis_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
const basis_basic< T > & get_piola_basis() const
size_type dis_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
odiststream & put(odiststream &ops) const
void set_nodes(const disarray< node_type, M > &)
size_type seq_locate(const point_basic< T > &x, size_type dis_ie_guest=std::numeric_limits< size_type >::max()) const
geo_domain_indirect_base_rep(const domain_indirect_basic< M > &indirect, const geo_basic< T, M > &omega)
size_type seq_nearest(const point_basic< T > &x, point_basic< T > &x_nearest) 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
size_type neighbour(size_type ie, size_type loc_iside) const
size_type dis_inod2dis_iv(size_type dis_inod) const
base::geo_element_map_type geo_element_map_type
const_reference get_geo_element(size_type dim, size_type ige) 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_trace_move(const point_basic< T > &x, const point_basic< T > &v, point_basic< T > &y) const
bool have_domain_indirect(const std::string &name) const
void nearest(const disarray< point_basic< T >, M > &x, disarray< point_basic< T >, M > &x_nearest, disarray< size_type, M > &dis_ie) const
void locate(const disarray< point_basic< T >, M > &x, disarray< size_type, M > &dis_ie, bool do_check=false) const
const geo_element_map_type & get_external_geo_element_map(size_type variant) const
const domain_indirect_basic< M > & get_indirect() const
geo_domain_indirect_base_rep< T, distributed > base
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
geo_abstract_rep< T, sequential > * clone() const
geo_domain_indirect_rep(const geo_domain_indirect_rep< T, sequential > &x)
geo_domain_indirect_base_rep< T, sequential > base
geo_domain_indirect_rep(const domain_indirect_basic< sequential > &indirect, const geo_basic< T, sequential > &omega)
see the geo_element page for the full documentation
odiststream: see the diststream page for the full documentation
Definition diststream.h:137
static const variant_type max_variant
Expr1::float_type T
Definition field_expr.h:230
This file is part of Rheolef.
Expr1::memory_type M