Rheolef  7.1
an efficient C++ finite element environment
geo_domain_indirect_seq.cc
Go to the documentation of this file.
1 #include "rheolef/geo_domain_indirect.h"
22 
23 namespace rheolef {
24 
25 template <class T, class M>
26 const 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 }
33 template <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 }
40 template <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 }
48 template <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 }
56 template <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 }
64 template <class T, class M>
67 {
68  return 0;
69 }
70 template <class T, class M>
71 bool
73 {
74  return false;
75 }
76 template <class T, class M>
79 {
80  error_macro ("domain[domain] aka sub-sub-domain: not yet");
81  return _indirect; // not reached
82 }
83 template <class T, class M>
86 {
87  error_macro ("domain[domain] aka sub-sub-domain: not yet");
88  return _indirect; // not reached
89 }
90 template <class T, class M>
91 void
93 {
94  error_macro ("insert_domain_indirect: cannot insert inside another domain");
95 }
96 template <class T, class M>
99 {
100  error_macro ("domain.put_geo: not yet");
101  return ops;
102 }
103 template <class T, class M>
104 const geo_size&
106 {
107  return _omega.sizes();
108 }
109 template <class T, class M>
110 const geo_size&
112 {
113  error_macro ("domain.ios_sizes: not yet");
114  return _omega.ios_sizes();
115 }
116 template <class T, class M>
119 {
120  return _omega.dis_node (dis_inod);
121 }
122 template <class T, class M>
123 void
124 geo_domain_indirect_base_rep<T,M>::dis_inod (const geo_element& K, std::vector<size_type>& dis_inod) const
125 {
126  _omega.dis_inod (K, dis_inod);
127 }
128 template <class T, class M>
131 {
132  return _omega.dis_inod2dis_iv (dis_inod);
133 }
134 template <class T, class M>
135 void
137 {
138  error_macro ("domain.set_node: cannot do that");
139 }
140 template <class T, class M>
141 bool
143 {
144  return true;
145 }
146 template <class T, class M>
147 void
149 {
150  error_macro ("domain.reset_order: cannot do that");
151 }
152 template <class T, class M>
155 {
156  error_macro ("domain.seq_locate: no implemented");
157  return std::numeric_limits<size_type>::max();
158 }
159 template <class T, class M>
162 {
163  error_macro ("domain.dis_locate: no implemented");
164  return std::numeric_limits<size_type>::max();
165 }
166 template <class T, class M>
169  const point_basic<T>& x,
170  const point_basic<T>& v,
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 }
176 template <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 }
186 template <class T, class M>
187 void
189  const disarray<point_basic<T>, M>& x,
190  disarray<size_type, M>& dis_ie,
191  bool do_check) const
192 {
193  error_macro ("domain.locate: no implemented");
194 }
195 template <class T, class M>
196 void
198  const disarray<point_basic<T>,M>& x,
199  const disarray<point_basic<T>,M>& v,
200  disarray<size_type, M>& dis_ie,
202  bool do_check) const
203 {
204  error_macro ("domain.trace_ray_boundary: no implemented");
205 }
206 template <class T, class M>
207 void
209  const disarray<point_basic<T>,M>& x,
210  const disarray<point_basic<T>,M>& v,
211  disarray<size_type, M>& dis_ie,
212  disarray<point_basic<T>,M>& y) const
213 {
214  error_macro ("domain.trace_move: no implemented");
215 }
216 template <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 }
225 template <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 }
234 template <class T, class M>
235 void
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 }
243 template <class T, class M>
246 {
247  error_macro ("domain.neighbour: no implemented");
248  return std::numeric_limits<size_type>::max();
249 }
250 template <class T, class M>
251 void
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
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
Definition: geo_element.h:102
odiststream: see the diststream page for the full documentation
Definition: diststream.h:126
static iorheo::force_initialization dummy
Definition: iorheo.cc:147
#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)")
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.
Expr1::memory_type M
Definition: vec_expr_v2.h:416