Rheolef  7.2
an efficient C++ finite element environment
 
Loading...
Searching...
No Matches
geo_domain_indirect_seq.cc
Go to the documentation of this file.
1
21#include "rheolef/geo_domain_indirect.h"
22
23namespace rheolef {
24
25template <class T, class M>
26const distributor&
28{
29 if (dim == map_dimension()) return _indirect.ownership();
30 check_macro (dim < map_dimension(), "unexpected dimension = " << dim << " > domain dimension = " << map_dimension());
31 return _omega.geo_element_ownership(dim);
32}
33template <class T, class M>
36{
37 if (dim == map_dimension()) return _omega.get_geo_element (dim, _indirect.oige(ige).index());
38 return _omega.get_geo_element (dim, ige);
39}
40template <class T, class M>
43{
44 error_macro ("domain.begin: not yet");
45 return _omega.begin_by_variant (variant); // (not reached)
46 // Note: here, not valid for dim(variant)=map_dimension ; requires a proxy_reference
47}
48template <class T, class M>
51{
52 error_macro ("domain.end: not yet");
53 return _omega.end_by_variant (variant); // (not reached)
54 // Note: here, not valid for dim(variant)=map_dimension ; requires a proxy_reference
55}
56template <class T, class M>
59{
60 error_macro ("domain.get_external_geo_element_map: not yet");
61 static const geo_element_map_type dummy;
62 return dummy;
63}
64template <class T, class M>
70template <class T, class M>
71bool
73{
74 return false;
75}
76template <class T, class M>
77const domain_indirect_basic<M>&
79{
80 error_macro ("domain[domain] aka sub-sub-domain: not yet");
81 return _indirect; // not reached
82}
83template <class T, class M>
84const domain_indirect_basic<M>&
86{
87 error_macro ("domain[domain] aka sub-sub-domain: not yet");
88 return _indirect; // not reached
89}
90template <class T, class M>
91void
93{
94 error_macro ("insert_domain_indirect: cannot insert inside another domain");
95}
96template <class T, class M>
99{
100 error_macro ("domain.put_geo: not yet");
101 return ops;
102}
103template <class T, class M>
104const geo_size&
106{
107 return _omega.sizes();
108}
109template <class T, class M>
110const geo_size&
113 error_macro ("domain.ios_sizes: not yet");
114 return _omega.ios_sizes();
115}
116template <class T, class M>
120 return _omega.dis_node (dis_inod);
122template <class T, class M>
123void
124geo_domain_indirect_base_rep<T,M>::dis_inod (const geo_element& K, std::vector<size_type>& dis_inod) const
126 _omega.dis_inod (K, dis_inod);
128template <class T, class M>
132 return _omega.dis_inod2dis_iv (dis_inod);
134template <class T, class M>
135void
137{
138 error_macro ("domain.set_node: cannot do that");
139}
140template <class T, class M>
141bool
143{
144 return true;
146template <class T, class M>
147void
150 error_macro ("domain.reset_order: cannot do that");
151}
152template <class T, class M>
155{
156 error_macro ("domain.seq_locate: no implemented");
157 return std::numeric_limits<size_type>::max();
159template <class T, class M>
162{
163 error_macro ("domain.dis_locate: no implemented");
164 return std::numeric_limits<size_type>::max();
165}
166template <class T, class M>
169 const point_basic<T>& x,
171 point_basic<T>& y) const
172{
173 error_macro ("domain.seq_trace_move: no implemented");
174 return std::numeric_limits<size_type>::max();
175}
176template <class T, class M>
179 const point_basic<T>& x,
180 const point_basic<T>& v,
181 point_basic<T>& y) const
182{
183 error_macro ("domain.dis_trace_move: no implemented");
184 return std::numeric_limits<size_type>::max();
185}
186template <class T, class M>
187void
189 const disarray<point_basic<T>, M>& x,
191 bool do_check) const
192{
193 error_macro ("domain.locate: no implemented");
194}
195template <class T, class M>
196void
198 const disarray<point_basic<T>,M>& x,
199 const disarray<point_basic<T>,M>& v,
202 bool do_check) const
203{
204 error_macro ("domain.trace_ray_boundary: no implemented");
205}
206template <class T, class M>
207void
209 const disarray<point_basic<T>,M>& x,
210 const disarray<point_basic<T>,M>& v,
212 disarray<point_basic<T>,M>& y) const
213{
214 error_macro ("domain.trace_move: no implemented");
215}
216template <class T, class M>
219 const point_basic<T>& x,
220 point_basic<T>& x_nearest) const
221{
222 error_macro ("domain.seq_nearest: no implemented");
223 return std::numeric_limits<size_type>::max();
224}
225template <class T, class M>
228 const point_basic<T>& x,
229 point_basic<T>& x_nearest) const
230{
231 error_macro ("domain.dis_nearest: no implemented");
232 return std::numeric_limits<size_type>::max();
233}
234template <class T, class M>
235void
237 const disarray<point_basic<T>,M>& x,
238 disarray<point_basic<T>,M>& x_nearest,
239 disarray<size_type, M>& dis_ie) const
240{
241 error_macro ("domain.nearest: no implemented");
242}
243template <class T, class M>
246{
247 error_macro ("domain.neighbour: no implemented");
248 return std::numeric_limits<size_type>::max();
249}
250template <class T, class M>
251void
253{
254 error_macro ("domain.neighbour_guard: no implemented");
255}
256// ----------------------------------------------------------------------------
257// instanciation in library
258// ----------------------------------------------------------------------------
260#ifdef _RHEOLEF_HAVE_MPI
262#endif // _RHEOLEF_HAVE_MPI
264
265} // namespace rheolef
see the disarray page for the full documentation
Definition disarray.h:497
the finite element boundary domain
base::const_iterator_by_variant const_iterator_by_variant
const distributor & geo_element_ownership(size_type dim) const
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
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
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
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
see the geo_element page for the full documentation
odiststream: see the diststream page for the full documentation
Definition diststream.h:137
#define error_macro(message)
Definition dis_macros.h:49
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
This file is part of Rheolef.
Expr1::memory_type M