Logo  0.95.0-final
Finite Element Embedded Library and Language in C++
Feel++ Feel++ on Github Feel++ community
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
filters.hpp
Go to the documentation of this file.
1 /* -*- mode: c++; coding: utf-8; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; show-trailing-whitespace: t -*- vim:fenc=utf-8:ft=tcl:et:sw=4:ts=4:sts=4
2 
3  This file is part of the Feel library
4 
5  Author(s): Christophe Prud'homme <christophe.prudhomme@feelpp.org>
6  Date: 2005-08-27
7 
8  Copyright (C) 2005,2006 EPFL
9  Copyright (C) 2006-2010 Universite de Grenoble 1 (Joseph Fourier)
10 
11  This library is free software; you can redistribute it and/or
12  modify it under the terms of the GNU Lesser General Public
13  License as published by the Free Software Foundation; either
14  version 3.0 of the License, or (at your option) any later version.
15 
16  This library is distributed in the hope that it will be useful,
17  but WITHOUT ANY WARRANTY; without even the implied warranty of
18  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  Lesser General Public License for more details.
20 
21  You should have received a copy of the GNU Lesser General Public
22  License along with this library; if not, write to the Free Software
23  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 */
30 #ifndef __FEELPP_FILTERS_HPP
31 #define __FEELPP_FILTERS_HPP 1
32 
33 #include <utility>
34 
36 #include <feel/feelmesh/traits.hpp>
37 
38 namespace Feel
39 {
40 
42 {
44  MESH_FACES = 1,
46  MESH_EDGES = 3,
49 };
50 
51 namespace meta
52 {
53 
54 template<typename MeshType>
55 struct elements
56 {
57  static const uint16_type nDim = MeshType::nDim;
58  typedef boost::tuple<mpl::size_t<MESH_ELEMENTS>,
59  typename MeshTraits<MeshType>::element_const_iterator,
60  typename MeshTraits<MeshType>::element_const_iterator> type;
61 };
62 
63 template<typename MeshType>
64 struct markedelements
65 {
66  static const uint16_type nDim = MeshType::nDim;
67  typedef boost::tuple<mpl::size_t<MESH_ELEMENTS>,
68  typename MeshTraits<MeshType>::marker_element_const_iterator,
69  typename MeshTraits<MeshType>::marker_element_const_iterator> type;
70 };
71 
72 template<typename MeshType>
73 struct marked2elements
74 {
75  static const uint16_type nDim = MeshType::nDim;
76  typedef boost::tuple<mpl::size_t<MESH_ELEMENTS>,
77  typename MeshTraits<MeshType>::marker2_element_const_iterator,
78  typename MeshTraits<MeshType>::marker2_element_const_iterator> type;
79 };
80 
81 template<typename MeshType>
82 struct marked3elements
83 {
84  static const uint16_type nDim = MeshType::nDim;
85  typedef boost::tuple<mpl::size_t<MESH_ELEMENTS>,
86  typename MeshTraits<MeshType>::marker3_element_const_iterator,
87  typename MeshTraits<MeshType>::marker3_element_const_iterator> type;
88 };
89 
90 } // meta
91 
93 namespace detail
94 {
95 
96 
97 template<typename MeshType>
98 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
99  typename MeshTraits<MeshType>::element_const_iterator,
100  typename MeshTraits<MeshType>::element_const_iterator>
101  allelements( MeshType const& mesh, mpl::bool_<false> )
102 {
103  return boost::make_tuple( mpl::size_t<MESH_ELEMENTS>(),
104  mesh.beginElement(),
105  mesh.endElement() );
106 }
107 
108 template<typename MeshType>
109 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
110  typename MeshTraits<MeshType>::element_const_iterator,
111  typename MeshTraits<MeshType>::element_const_iterator>
112  allelements( MeshType const& mesh,mpl::bool_<true> )
113 {
114  return allelements( *mesh, mpl::bool_<false>() );
115 }
116 
117 template<typename MeshType>
118 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
119  typename MeshTraits<MeshType>::element_const_iterator,
120  typename MeshTraits<MeshType>::element_const_iterator>
121  elements( MeshType const& mesh, flag_type flag, mpl::bool_<false> )
122 {
123 
124  return boost::make_tuple( mpl::size_t<MESH_ELEMENTS>(),
125  mesh.beginElementWithProcessId( flag ),
126  mesh.endElementWithProcessId( flag ) );
127 }
128 template<typename MeshType>
129 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
130  typename MeshTraits<MeshType>::element_const_iterator,
131  typename MeshTraits<MeshType>::element_const_iterator>
132  elements( MeshType const& mesh, flag_type flag, mpl::bool_<true> )
133 {
134  return elements( *mesh, flag, mpl::bool_<false>() );
135 }
136 
137 
138 template<typename MeshType>
139 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
140  typename MeshTraits<MeshType>::location_element_const_iterator,
141  typename MeshTraits<MeshType>::location_element_const_iterator>
142 boundaryelements( MeshType const& mesh, uint16_type entity_min_dim, uint16_type entity_max_dim, size_type pid, mpl::bool_<false> )
143 {
144  typedef typename MeshTraits<MeshType>::location_element_const_iterator iterator;
145  std::pair<iterator, iterator> p = mesh.boundaryElements( entity_min_dim, entity_max_dim, pid );
146  return boost::make_tuple( mpl::size_t<MESH_ELEMENTS>(), p.first, p.second );
147 }
148 template<typename MeshType>
149 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
150  typename MeshTraits<MeshType>::location_element_const_iterator,
151  typename MeshTraits<MeshType>::location_element_const_iterator>
152 boundaryelements( MeshType const& mesh, uint16_type entity_min_dim, uint16_type entity_max_dim, size_type pid, mpl::bool_<true> )
153 {
154  return boundaryelements( *mesh, entity_min_dim, entity_max_dim, pid, mpl::bool_<false>() );
155 }
156 
157 template<typename MeshType>
158 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
159  typename MeshTraits<MeshType>::location_element_const_iterator,
160  typename MeshTraits<MeshType>::location_element_const_iterator>
161  internalelements( MeshType const& mesh, size_type pid, mpl::bool_<false> )
162 {
163  typedef typename MeshTraits<MeshType>::location_element_const_iterator iterator;
164  std::pair<iterator, iterator> p = mesh.internalElements( pid );
165  return boost::make_tuple( mpl::size_t<MESH_ELEMENTS>(), p.first, p.second );
166 }
167 template<typename MeshType>
168 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
169  typename MeshTraits<MeshType>::location_element_const_iterator,
170  typename MeshTraits<MeshType>::location_element_const_iterator>
171  internalelements( MeshType const& mesh, size_type pid, mpl::bool_<true> )
172 {
173  return internalelements( *mesh, pid, mpl::bool_<false>() );
174 }
175 
176 template<typename MeshType>
177 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
178  typename MeshTraits<MeshType>::marker_element_const_iterator,
179  typename MeshTraits<MeshType>::marker_element_const_iterator>
180  markedelements( MeshType const& mesh, flag_type flag, size_type pid, mpl::bool_<false> )
181 {
182  typedef typename MeshTraits<MeshType>::marker_element_const_iterator iterator;
183  std::pair<iterator, iterator> p = mesh.elementsWithMarker( flag, pid );
184  return boost::make_tuple( mpl::size_t<MESH_ELEMENTS>(),
185  p.first, p.second );
186 }
187 template<typename MeshType>
188 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
189  typename MeshTraits<MeshType>::marker_element_const_iterator,
190  typename MeshTraits<MeshType>::marker_element_const_iterator>
191  markedelements( MeshType const& mesh, flag_type flag, size_type pid, mpl::bool_<true> )
192 {
193  return markedelements( *mesh, flag, pid, mpl::bool_<false>() );
194 }
195 
196 template<typename MeshType>
197 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
198  typename MeshTraits<MeshType>::marker2_element_const_iterator,
199  typename MeshTraits<MeshType>::marker2_element_const_iterator>
200  marked2elements( MeshType const& mesh, flag_type flag, size_type pid, mpl::bool_<false> )
201 {
202  typedef typename MeshTraits<MeshType>::marker2_element_const_iterator iterator;
203  std::pair<iterator, iterator> p = mesh.elementsWithMarker2( flag, pid );
204  return boost::make_tuple( mpl::size_t<MESH_ELEMENTS>(),
205  p.first, p.second );
206 }
207 template<typename MeshType>
208 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
209  typename MeshTraits<MeshType>::marker2_element_const_iterator,
210  typename MeshTraits<MeshType>::marker2_element_const_iterator>
211  marked2elements( MeshType const& mesh, flag_type flag, size_type pid, mpl::bool_<true> )
212 {
213  return marked2elements( *mesh, flag, pid, mpl::bool_<false>() );
214 }
215 
216 template<typename MeshType>
217 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
218  typename MeshTraits<MeshType>::marker3_element_const_iterator,
219  typename MeshTraits<MeshType>::marker3_element_const_iterator>
220  marked3elements( MeshType const& mesh, flag_type flag, size_type pid, mpl::bool_<false> )
221 {
222  typedef typename MeshTraits<MeshType>::marker3_element_const_iterator iterator;
223  std::pair<iterator, iterator> p = mesh.elementsWithMarker3( flag, pid );
224  return boost::make_tuple( mpl::size_t<MESH_ELEMENTS>(),
225  p.first, p.second );
226 }
227 template<typename MeshType>
228 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
229  typename MeshTraits<MeshType>::marker3_element_const_iterator,
230  typename MeshTraits<MeshType>::marker3_element_const_iterator>
231  marked3elements( MeshType const& mesh, flag_type flag, size_type pid, mpl::bool_<true> )
232 {
233  return marked3elements( *mesh, flag, pid, mpl::bool_<false>() );
234 }
235 
236 template<typename MeshType>
237 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
238  typename MeshTraits<MeshType>::element_const_iterator,
239  typename MeshTraits<MeshType>::element_const_iterator>
240  idedelements( MeshType const& mesh, flag_type flag, mpl::bool_<false> )
241 {
242  return boost::make_tuple( mpl::size_t<MESH_ELEMENTS>(),
243  mesh.beginElementWithId( flag ),
244  mesh.endElementWithId( flag ) );
245 }
246 template<typename MeshType>
247 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
248  typename MeshTraits<MeshType>::element_const_iterator,
249  typename MeshTraits<MeshType>::element_const_iterator>
250  idedelements( MeshType const& mesh, flag_type flag, mpl::bool_<true> )
251 {
252  return idedelements( *mesh, flag, mpl::bool_<false>() );
253 }
254 
255 template<typename MeshType>
256 boost::tuple<mpl::size_t<MESH_FACES>,
257  typename MeshTraits<MeshType>::pid_face_const_iterator,
258  typename MeshTraits<MeshType>::pid_face_const_iterator>
259  faces( MeshType const& mesh, size_type __pid, mpl::bool_<false> )
260 {
261  typedef typename MeshTraits<MeshType>::pid_face_const_iterator pid_face_const_iterator;
262  pid_face_const_iterator it,en;
263  boost::tie( it, en ) = mesh.facesWithProcessId( __pid );
264  return boost::make_tuple( mpl::size_t<MESH_FACES>(), it, en );
265 }
266 template<typename MeshType>
267 boost::tuple<mpl::size_t<MESH_FACES>,
268  typename MeshTraits<MeshType>::pid_face_const_iterator,
269  typename MeshTraits<MeshType>::pid_face_const_iterator>
270  faces( MeshType const& mesh, size_type __pid, mpl::bool_<true> )
271 {
272  return faces( *mesh, __pid, mpl::bool_<false>() );
273 }
274 
275 template<typename MeshType>
276 boost::tuple<mpl::size_t<MESH_FACES>,
277  typename MeshTraits<MeshType>::face_const_iterator,
278  typename MeshTraits<MeshType>::face_const_iterator>
279  idedfaces( MeshType const& mesh, size_type id, mpl::bool_<false> )
280 {
281  return boost::make_tuple( mpl::size_t<MESH_FACES>(),
282  mesh.beginFaceWithId( id ),
283  mesh.endFaceWithId( id ) );
284 }
285 template<typename MeshType>
286 boost::tuple<mpl::size_t<MESH_FACES>,
287  typename MeshTraits<MeshType>::face_const_iterator,
288  typename MeshTraits<MeshType>::face_const_iterator>
289  idedfaces( MeshType const& mesh, size_type id, mpl::bool_<true> )
290 {
291  return idedfaces( *mesh, id, mpl::bool_<false>() );
292 }
293 
294 template<typename MeshType>
295 boost::tuple<mpl::size_t<MESH_FACES>,
296  typename MeshTraits<MeshType>::marker_face_const_iterator,
297  typename MeshTraits<MeshType>::marker_face_const_iterator>
298  markedfaces( MeshType const& mesh, size_type __pid, mpl::bool_<false> )
299 {
300  typedef typename MeshTraits<MeshType>::marker_face_const_iterator iterator;
301  auto beg = mesh.beginFaceWithMarker();
302  auto end = mesh.endFaceWithMarker();
303  return boost::make_tuple( mpl::size_t<MESH_FACES>(),
304  beg, end );
305 }
306 
307 template<typename MeshType>
308 boost::tuple<mpl::size_t<MESH_FACES>,
309  typename MeshTraits<MeshType>::marker_face_const_iterator,
310  typename MeshTraits<MeshType>::marker_face_const_iterator>
311  markedfaces( MeshType const& mesh, flag_type __marker, size_type __pid, mpl::bool_<false> )
312 {
313  typedef typename MeshTraits<MeshType>::marker_face_const_iterator iterator;
314  std::pair<iterator, iterator> p = mesh.facesWithMarker( __marker, __pid );
315  return boost::make_tuple( mpl::size_t<MESH_FACES>(),
316  p.first, p.second );
317 }
318 
319 template<typename MeshType>
320 boost::tuple<mpl::size_t<MESH_FACES>,
321  typename MeshTraits<MeshType>::marker2_face_const_iterator,
322  typename MeshTraits<MeshType>::marker2_face_const_iterator>
323  marked2faces( MeshType const& mesh, size_type __pid, mpl::bool_<false> )
324 {
325  typedef typename MeshTraits<MeshType>::marker2_face_const_iterator iterator;
326  auto beg = mesh.beginFaceWithMarker2();
327  auto end = mesh.endFaceWithMarker2();
328  return boost::make_tuple( mpl::size_t<MESH_FACES>(),
329  beg, end );
330 }
331 
332 template<typename MeshType>
333 boost::tuple<mpl::size_t<MESH_FACES>,
334  typename MeshTraits<MeshType>::marker2_face_const_iterator,
335  typename MeshTraits<MeshType>::marker2_face_const_iterator>
336  marked2faces( MeshType const& mesh, flag_type __marker, size_type __pid, mpl::bool_<false> )
337 {
338  typedef typename MeshTraits<MeshType>::marker2_face_const_iterator iterator;
339  std::pair<iterator, iterator> p = mesh.facesWithMarker2( __marker, __pid );
340  return boost::make_tuple( mpl::size_t<MESH_FACES>(),
341  p.first, p.second );
342 }
343 
344 template<typename MeshType>
345 boost::tuple<mpl::size_t<MESH_FACES>,
346  typename MeshTraits<MeshType>::marker3_face_const_iterator,
347  typename MeshTraits<MeshType>::marker3_face_const_iterator>
348  marked3faces( MeshType const& mesh, size_type __pid, mpl::bool_<false> )
349 {
350  typedef typename MeshTraits<MeshType>::marker3_face_const_iterator iterator;
351  auto beg = mesh.beginFaceWithMarker3();
352  auto end = mesh.endFaceWithMarker3();
353  return boost::make_tuple( mpl::size_t<MESH_FACES>(),
354  beg, end );
355 }
356 
357 template<typename MeshType>
358 boost::tuple<mpl::size_t<MESH_FACES>,
359  typename MeshTraits<MeshType>::marker3_face_const_iterator,
360  typename MeshTraits<MeshType>::marker3_face_const_iterator>
361  marked3faces( MeshType const& mesh, flag_type __marker, size_type __pid, mpl::bool_<false> )
362 {
363  typedef typename MeshTraits<MeshType>::marker3_face_const_iterator iterator;
364  std::pair<iterator, iterator> p = mesh.facesWithMarker3( __marker, __pid );
365  return boost::make_tuple( mpl::size_t<MESH_FACES>(),
366  p.first, p.second );
367 }
368 
369 template<typename MeshType>
370 boost::tuple<mpl::size_t<MESH_FACES>,
371  typename MeshTraits<MeshType>::marker_face_const_iterator,
372  typename MeshTraits<MeshType>::marker_face_const_iterator>
373  markedfaces( MeshType const& mesh, flag_type __marker, size_type __pid, mpl::bool_<true> )
374 {
375  return markedfaces( *mesh, __marker, __pid, mpl::bool_<false>() );
376 }
377 
378 template<typename MeshType>
379 boost::tuple<mpl::size_t<MESH_FACES>,
380  typename MeshTraits<MeshType>::marker_face_const_iterator,
381  typename MeshTraits<MeshType>::marker_face_const_iterator>
382  markedfaces( MeshType const& mesh, size_type __pid, mpl::bool_<true> )
383 {
384  return markedfaces( *mesh, __pid, mpl::bool_<false>() );
385 }
386 
387 template<typename MeshType>
388 boost::tuple<mpl::size_t<MESH_FACES>,
389  typename MeshTraits<MeshType>::marker2_face_const_iterator,
390  typename MeshTraits<MeshType>::marker2_face_const_iterator>
391  marked2faces( MeshType const& mesh, flag_type __marker, size_type __pid, mpl::bool_<true> )
392 {
393  return marked2faces( *mesh, __marker, __pid, mpl::bool_<false>() );
394 }
395 
396 template<typename MeshType>
397 boost::tuple<mpl::size_t<MESH_FACES>,
398  typename MeshTraits<MeshType>::marker2_face_const_iterator,
399  typename MeshTraits<MeshType>::marker2_face_const_iterator>
400  marked2faces( MeshType const& mesh, size_type __pid, mpl::bool_<true> )
401 {
402  return marked2faces( *mesh, __pid, mpl::bool_<false>() );
403 }
404 
405 template<typename MeshType>
406 boost::tuple<mpl::size_t<MESH_FACES>,
407  typename MeshTraits<MeshType>::marker3_face_const_iterator,
408  typename MeshTraits<MeshType>::marker3_face_const_iterator>
409  marked3faces( MeshType const& mesh, flag_type __marker, size_type __pid, mpl::bool_<true> )
410 {
411  return marked3faces( *mesh, __marker, __pid, mpl::bool_<false>() );
412 }
413 
414 template<typename MeshType>
415 boost::tuple<mpl::size_t<MESH_FACES>,
416  typename MeshTraits<MeshType>::marker3_face_const_iterator,
417  typename MeshTraits<MeshType>::marker3_face_const_iterator>
418  marked3faces( MeshType const& mesh, size_type __pid, mpl::bool_<true> )
419 {
420  return marked3faces( *mesh, __pid, mpl::bool_<false>() );
421 }
422 
423 template<typename MeshType>
424 boost::tuple<mpl::size_t<MESH_FACES>,
425  typename MeshTraits<MeshType>::location_face_const_iterator,
426  typename MeshTraits<MeshType>::location_face_const_iterator>
427  boundaryfaces( MeshType const& mesh, size_type __pid, mpl::bool_<false> )
428 {
429  typedef typename MeshTraits<MeshType>::location_face_const_iterator iterator;
430  std::pair<iterator, iterator> p = mesh.facesOnBoundary( __pid );
431  return boost::make_tuple( mpl::size_t<MESH_FACES>(),
432  p.first, p.second );
433 }
434 template<typename MeshType>
435 boost::tuple<mpl::size_t<MESH_FACES>,
436  typename MeshTraits<MeshType>::location_face_const_iterator,
437  typename MeshTraits<MeshType>::location_face_const_iterator>
438  boundaryfaces( MeshType const& mesh, size_type __pid, mpl::bool_<true> )
439 {
440  return boundaryfaces( *mesh, __pid, mpl::bool_<false>() );
441 }
442 
443 template<typename MeshType>
444 boost::tuple<mpl::size_t<MESH_FACES>,
445  typename MeshTraits<MeshType>::location_face_const_iterator,
446  typename MeshTraits<MeshType>::location_face_const_iterator>
447  internalfaces( MeshType const& mesh, size_type __pid, mpl::bool_<false> )
448 {
449 
450  typedef typename MeshTraits<MeshType>::location_face_const_iterator iterator;
451  std::pair<iterator, iterator> p = mesh.internalFaces();
452  return boost::make_tuple( mpl::size_t<MESH_FACES>(),
453  p.first, p.second );
454 }
455 template<typename MeshType>
456 boost::tuple<mpl::size_t<MESH_FACES>,
457  typename MeshTraits<MeshType>::location_face_const_iterator,
458  typename MeshTraits<MeshType>::location_face_const_iterator>
459  internalfaces( MeshType const& mesh, size_type __pid, mpl::bool_<true> )
460 {
461  return internalfaces( *mesh, __pid, mpl::bool_<false>() );
462 }
463 
464 template<typename MeshType>
465 boost::tuple<mpl::size_t<MESH_FACES>,
466  typename MeshTraits<MeshType>::interprocess_face_const_iterator,
467  typename MeshTraits<MeshType>::interprocess_face_const_iterator>
468  interprocessfaces( MeshType const& mesh, size_type __pid, mpl::bool_<false> )
469 {
470 
471  typedef typename MeshTraits<MeshType>::interprocess_face_const_iterator iterator;
472  std::pair<iterator, iterator> p = mesh.interProcessFaces( /*__pid*/ );
473  return boost::make_tuple( mpl::size_t<MESH_FACES>(),
474  p.first, p.second );
475 }
476 template<typename MeshType>
477 boost::tuple<mpl::size_t<MESH_FACES>,
478  typename MeshTraits<MeshType>::interprocess_face_const_iterator,
479  typename MeshTraits<MeshType>::interprocess_face_const_iterator>
480  interprocessfaces( MeshType const& mesh, size_type __pid, mpl::bool_<true> )
481 {
482  return interprocessfaces( *mesh, __pid, mpl::bool_<false>() );
483 
484 }
485 
486 template<typename MeshType>
487 boost::tuple<mpl::size_t<MESH_EDGES>,
488  typename MeshTraits<MeshType>::pid_edge_const_iterator,
489  typename MeshTraits<MeshType>::pid_edge_const_iterator>
490  edges( MeshType const& mesh, size_type __pid, mpl::bool_<false> )
491 {
492  typedef typename MeshTraits<MeshType>::pid_edge_const_iterator pid_edge_const_iterator;
493  pid_edge_const_iterator it,en;
494  boost::tie( it, en ) = mesh.edgesWithProcessId( __pid );
495  return boost::make_tuple( mpl::size_t<MESH_EDGES>(), it, en );
496 }
497 template<typename MeshType>
498 boost::tuple<mpl::size_t<MESH_EDGES>,
499  typename MeshTraits<MeshType>::pid_edge_const_iterator,
500  typename MeshTraits<MeshType>::pid_edge_const_iterator>
501  edges( MeshType const& mesh, size_type __pid, mpl::bool_<true> )
502 {
503  return edges( *mesh, __pid, mpl::bool_<false>() );
504 }
505 
506 
507 template<typename MeshType>
508 boost::tuple<mpl::size_t<MESH_EDGES>,
509  typename MeshTraits<MeshType>::marker_edge_const_iterator,
510  typename MeshTraits<MeshType>::marker_edge_const_iterator>
511  markededges( MeshType const& mesh, flag_type __marker, size_type __pid, mpl::bool_<false> )
512 {
513  typedef typename MeshTraits<MeshType>::marker_edge_const_iterator iterator;
514  std::pair<iterator, iterator> p = mesh.edgesWithMarker( __marker, __pid );
515  return boost::make_tuple( mpl::size_t<MESH_EDGES>(),
516  p.first, p.second );
517 }
518 template<typename MeshType>
519 boost::tuple<mpl::size_t<MESH_EDGES>,
520  typename MeshTraits<MeshType>::marker_edge_const_iterator,
521  typename MeshTraits<MeshType>::marker_edge_const_iterator>
522  markededges( MeshType const& mesh, flag_type __marker, size_type __pid, mpl::bool_<true> )
523 {
524  return markededges( *mesh, __marker, __pid, mpl::bool_<false>() );
525 }
526 template<typename MeshType>
527 boost::tuple<mpl::size_t<MESH_EDGES>,
528  typename MeshTraits<MeshType>::location_edge_const_iterator,
529  typename MeshTraits<MeshType>::location_edge_const_iterator>
530  boundaryedges( MeshType const& mesh, mpl::bool_<false> )
531 {
532  return boost::make_tuple( mpl::size_t<MESH_EDGES>(),
533  mesh.beginEdgeOnBoundary(),
534  mesh.endEdgeOnBoundary() );
535 }
536 template<typename MeshType>
537 boost::tuple<mpl::size_t<MESH_EDGES>,
538  typename MeshTraits<MeshType>::location_edge_const_iterator,
539  typename MeshTraits<MeshType>::location_edge_const_iterator>
540  boundaryedges( MeshType const& mesh, mpl::bool_<true> )
541 {
542  return boundaryedges( *mesh, mpl::bool_<false>() );
543 }
544 
545 template<typename MeshType>
546 boost::tuple<mpl::size_t<MESH_EDGES>,
547  typename MeshTraits<MeshType>::location_edge_const_iterator,
548  typename MeshTraits<MeshType>::location_edge_const_iterator>
549  internaledges( MeshType const& mesh, mpl::bool_<true> )
550 {
551  return internaledges( mesh, mpl::bool_<false>() );
552 }
553 template<typename MeshType>
554 boost::tuple<mpl::size_t<MESH_EDGES>,
555  typename MeshTraits<MeshType>::location_edge_const_iterator,
556  typename MeshTraits<MeshType>::location_edge_const_iterator>
557  internaledges( MeshType const& mesh, mpl::bool_<false> )
558 {
559  return boost::make_tuple( mpl::size_t<MESH_EDGES>(),
560  mesh.beginInternalEdge(),
561  mesh.endInternalEdge() );
562 }
563 
564 template<typename MeshType>
565 boost::tuple<mpl::size_t<MESH_POINTS>,
566  typename MeshTraits<MeshType>::point_const_iterator,
567  typename MeshTraits<MeshType>::point_const_iterator>
568  points( MeshType const& mesh, mpl::bool_<true> )
569 {
570  return points( *mesh, mpl::bool_<false>() );
571 }
572 template<typename MeshType>
573 boost::tuple<mpl::size_t<MESH_POINTS>,
574  typename MeshTraits<MeshType>::point_const_iterator,
575  typename MeshTraits<MeshType>::point_const_iterator>
576  points( MeshType const& mesh, mpl::bool_<false> )
577 {
578  return boost::make_tuple( mpl::size_t<MESH_POINTS>(),
579  mesh.beginPoint(),
580  mesh.endPoint() );
581 }
582 
583 template<typename MeshType>
584 boost::tuple<mpl::size_t<MESH_POINTS>,
585  typename MeshTraits<MeshType>::marker_point_const_iterator,
586  typename MeshTraits<MeshType>::marker_point_const_iterator>
587  markedpoints( MeshType const& mesh, size_type flag, mpl::bool_<false> )
588 {
589  return boost::make_tuple( mpl::size_t<MESH_POINTS>(),
590  mesh.beginPointWithMarker( flag ),
591  mesh.endPointWithMarker( flag ) );
592 }
593 template<typename MeshType>
594 boost::tuple<mpl::size_t<MESH_POINTS>,
595  typename MeshTraits<MeshType>::marker_point_const_iterator,
596  typename MeshTraits<MeshType>::marker_point_const_iterator>
597  markedpoints( MeshType const& mesh, size_type flag, mpl::bool_<true> )
598 {
599  return markedpoints( *mesh, flag, mpl::bool_<false>() );
600 }
601 
602 template<typename MeshType>
603 boost::tuple<mpl::size_t<MESH_POINTS>,
604  typename MeshTraits<MeshType>::location_point_const_iterator,
605  typename MeshTraits<MeshType>::location_point_const_iterator>
606  boundarypoints( MeshType const& mesh, mpl::bool_<false> )
607 {
608  return boost::make_tuple( mpl::size_t<MESH_POINTS>(),
609  mesh.beginPointOnBoundary( ),
610  mesh.endPointOnBoundary() );
611 }
612 template<typename MeshType>
613 boost::tuple<mpl::size_t<MESH_POINTS>,
614  typename MeshTraits<MeshType>::location_point_const_iterator,
615  typename MeshTraits<MeshType>::location_point_const_iterator>
616  boundarypoints( MeshType const& mesh, mpl::bool_<true> )
617 {
618  return boundarypoints( *mesh, mpl::bool_<false>() );
619 }
620 
621 
622 template<typename MeshType>
623 boost::tuple<mpl::size_t<MESH_POINTS>,
624  typename MeshTraits<MeshType>::location_point_const_iterator,
625  typename MeshTraits<MeshType>::location_point_const_iterator>
626  internalpoints( MeshType const& mesh, mpl::bool_<true> )
627 {
628  return internalpoints( *mesh, mpl::bool_<false>() );
629 }
630 template<typename MeshType>
631 boost::tuple<mpl::size_t<MESH_POINTS>,
632  typename MeshTraits<MeshType>::location_point_const_iterator,
633  typename MeshTraits<MeshType>::location_point_const_iterator>
634  internalpoints( MeshType const& mesh, mpl::bool_<false> )
635 {
636  return boost::make_tuple( mpl::size_t<MESH_POINTS>(),
637  mesh.beginInternalPoint( ),
638  mesh.endInternalPoint() );
639 }
640 
641 } // detail
643 
644 template<typename MeshType>
645 size_type meshrank ( MeshType const& mesh, mpl::bool_<true> )
646 {
647  return mesh->comm().rank();
648 }
649 
650 template<typename MeshType>
651 size_type meshrank ( MeshType const& mesh, mpl::bool_<false> )
652 {
653  return mesh.comm().rank();
654 }
659 template<typename MeshType>
660 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
661  typename MeshTraits<MeshType>::element_const_iterator,
662  typename MeshTraits<MeshType>::element_const_iterator>
663  allelements( MeshType const& mesh )
664 {
665  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
666  return detail::allelements( mesh, is_ptr_or_shared_ptr() );
667 }
668 
674 template<typename MeshType>
675 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
676  typename MeshTraits<MeshType>::element_const_iterator,
677  typename MeshTraits<MeshType>::element_const_iterator>
678  elements( MeshType const& mesh )
679 {
680  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
681  return detail::elements( mesh, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
682  //return elements( mesh, flag, is_ptr_or_shared_ptr() );
683 }
684 
691 template<typename MeshType>
692 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
693  typename MeshTraits<MeshType>::location_element_const_iterator,
694  typename MeshTraits<MeshType>::location_element_const_iterator>
695 boundaryelements( MeshType const& mesh, uint16_type entity_min_dim = 0, uint16_type entity_max_dim = 2 )
696 {
697  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
698  return detail::boundaryelements( mesh, entity_min_dim, entity_max_dim, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
699 }
700 
701 
709 template<typename MeshType>
710 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
711  typename MeshTraits<MeshType>::location_element_const_iterator,
712  typename MeshTraits<MeshType>::location_element_const_iterator>
713  internalelements( MeshType const& mesh )
714 {
715  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
716  return detail::internalelements( mesh, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
717 }
718 
725 template<typename MeshType>
726 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
727  typename MeshTraits<MeshType>::marker_element_const_iterator,
728  typename MeshTraits<MeshType>::marker_element_const_iterator>
729 markedelements( MeshType const& mesh, std::string const& flag )
730 {
731  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
732  return detail::markedelements( mesh, mesh->markerName( flag ), meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
733 }
734 
741 template<typename MeshType>
742 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
743  typename MeshTraits<MeshType>::marker_element_const_iterator,
744  typename MeshTraits<MeshType>::marker_element_const_iterator>
745 markedelements( MeshType const& mesh, const char* flag )
746 {
747  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
748  return detail::markedelements( mesh, mesh->markerName( flag ), meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
749 }
750 
751 template<typename MeshType>
752 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
753  typename MeshTraits<MeshType>::marker_element_const_iterator,
754  typename MeshTraits<MeshType>::marker_element_const_iterator>
755 markedelements( MeshType const& mesh, boost::any const& flag )
756 {
757  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
758 
759  flag_type theflag = mesh->markerId( flag );
760  VLOG(2) << "[markedelements] flag: " << theflag << "\n";
761  return detail::markedelements( mesh, theflag, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
762 }
763 
764 template<typename MeshType>
765 std::list<boost::tuple<mpl::size_t<MESH_ELEMENTS>,
766  typename MeshTraits<MeshType>::marker_element_const_iterator,
767  typename MeshTraits<MeshType>::marker_element_const_iterator> >
768 markedelements( MeshType const& mesh, std::initializer_list<boost::any> const& flag )
769 {
770  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
771  std::list<boost::tuple<mpl::size_t<MESH_ELEMENTS>,
772  typename MeshTraits<MeshType>::marker_element_const_iterator,
773  typename MeshTraits<MeshType>::marker_element_const_iterator> > list_elements;
774  for( auto it = flag.begin(), en = flag.end(); it!=en; ++it )
775  {
776  flag_type theflag = mesh->markerId( *it );
777  VLOG(2) << "[markedelements] flag: " << theflag << "\n";
778  list_elements.push_back( detail::markedelements( mesh, theflag, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() ) );
779  }
780  return list_elements;
781 }
782 
783 template<typename MeshType>
784 std::list<boost::tuple<mpl::size_t<MESH_ELEMENTS>,
785  typename MeshTraits<MeshType>::marker_element_const_iterator,
786  typename MeshTraits<MeshType>::marker_element_const_iterator> >
787 markedelements( MeshType const& mesh, std::list<std::string> const& flag )
788 {
789  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
790  std::list<boost::tuple<mpl::size_t<MESH_ELEMENTS>,
791  typename MeshTraits<MeshType>::marker_element_const_iterator,
792  typename MeshTraits<MeshType>::marker_element_const_iterator> > list_elements;
793  for( auto it = flag.begin(), en = flag.end(); it!=en; ++it )
794  {
795  flag_type theflag = mesh->markerId( *it );
796  VLOG(2) << "[markedelements] flag: " << theflag << "\n";
797  list_elements.push_back( detail::markedelements( mesh, theflag, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() ) );
798  }
799  return list_elements;
800 }
801 
808 template<typename MeshType>
809 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
810  typename MeshTraits<MeshType>::marker2_element_const_iterator,
811  typename MeshTraits<MeshType>::marker2_element_const_iterator>
812  marked2elements( MeshType const& mesh, flag_type flag )
813 {
814  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
815  return detail::marked2elements( mesh, flag, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
816 }
817 
824 template<typename MeshType>
825 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
826  typename MeshTraits<MeshType>::marker2_element_const_iterator,
827  typename MeshTraits<MeshType>::marker2_element_const_iterator>
828  marked2elements( MeshType const& mesh, std::string const& flag )
829 {
830  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
831  return detail::marked2elements( mesh, mesh->markerName( flag ), meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
832 }
833 template<typename MeshType>
834 std::list<boost::tuple<mpl::size_t<MESH_ELEMENTS>,
835  typename MeshTraits<MeshType>::marker2_element_const_iterator,
836  typename MeshTraits<MeshType>::marker2_element_const_iterator> >
837 marked2elements( MeshType const& mesh, std::initializer_list<boost::any> const& flag )
838 {
839  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
840  std::list<boost::tuple<mpl::size_t<MESH_ELEMENTS>,
841  typename MeshTraits<MeshType>::marker2_element_const_iterator,
842  typename MeshTraits<MeshType>::marker2_element_const_iterator> > list_elements;
843  for( auto it = flag.begin(), en = flag.end(); it!=en; ++it )
844  {
845  flag_type theflag = mesh->markerId( *it );
846  VLOG(2) << "[markedelements] flag: " << theflag << "\n";
847  list_elements.push_back( detail::marked2elements( mesh, theflag, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() ) );
848  }
849  return list_elements;
850 }
851 
858 template<typename MeshType>
859 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
860  typename MeshTraits<MeshType>::marker3_element_const_iterator,
861  typename MeshTraits<MeshType>::marker3_element_const_iterator>
862  marked3elements( MeshType const& mesh, flag_type flag )
863 {
864  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
865  return detail::marked3elements( mesh, flag, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
866 }
867 
874 template<typename MeshType>
875 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
876  typename MeshTraits<MeshType>::marker3_element_const_iterator,
877  typename MeshTraits<MeshType>::marker3_element_const_iterator>
878  marked3elements( MeshType const& mesh, std::string const& flag )
879 {
880  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
881  return detail::marked3elements( mesh, mesh->markerName( flag ), meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
882 }
883 
884 template<typename MeshType>
885 std::list<boost::tuple<mpl::size_t<MESH_ELEMENTS>,
886  typename MeshTraits<MeshType>::marker3_element_const_iterator,
887  typename MeshTraits<MeshType>::marker3_element_const_iterator> >
888 marked3elements( MeshType const& mesh, std::initializer_list<boost::any> const& flag )
889 {
890  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
891  std::list<boost::tuple<mpl::size_t<MESH_ELEMENTS>,
892  typename MeshTraits<MeshType>::marker3_element_const_iterator,
893  typename MeshTraits<MeshType>::marker3_element_const_iterator> > list_elements;
894  for( auto it = flag.begin(), en = flag.end(); it!=en; ++it )
895  {
896  flag_type theflag = mesh->markerId( *it );
897  VLOG(2) << "[markedelements] flag: " << theflag << "\n";
898  list_elements.push_back( detail::marked3elements( mesh, theflag, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() ) );
899  }
900  return list_elements;
901 }
902 
908 template<typename MeshType>
909 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
910  typename MeshTraits<MeshType>::element_const_iterator,
911  typename MeshTraits<MeshType>::element_const_iterator>
912  idedelements( MeshType const& mesh, flag_type flag )
913 {
914  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
915  return detail::idedelements( mesh, flag, is_ptr_or_shared_ptr() );
916 }
917 
929 template<typename MeshType>
930 boost::tuple<mpl::size_t<MESH_FACES>,
931  typename MeshTraits<MeshType>::pid_face_const_iterator,
932  typename MeshTraits<MeshType>::pid_face_const_iterator>
933  faces( MeshType const& mesh )
934 {
935  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
936  return detail::faces( mesh, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
937 }
938 
944 template<typename MeshType>
945 boost::tuple<mpl::size_t<MESH_FACES>,
946  typename MeshTraits<MeshType>::face_const_iterator,
947  typename MeshTraits<MeshType>::face_const_iterator>
948  idedfaces( MeshType const& mesh, size_type id )
949 {
950  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
951  return detail::idedfaces( mesh, id, is_ptr_or_shared_ptr() );
952 }
953 
965 template<typename MeshType>
966 boost::tuple<mpl::size_t<MESH_FACES>,
967  typename MeshTraits<MeshType>::marker_face_const_iterator,
968  typename MeshTraits<MeshType>::marker_face_const_iterator>
969  markedfaces( MeshType const& mesh )
970 {
971  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
972  return detail::markedfaces( mesh, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
973 }
974 
987 template<typename MeshType>
988 boost::tuple<mpl::size_t<MESH_FACES>,
989  typename MeshTraits<MeshType>::marker_face_const_iterator,
990  typename MeshTraits<MeshType>::marker_face_const_iterator>
991  markedfaces( MeshType const& mesh,
992  std::string const&__marker )
993 {
994  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
995  return detail::markedfaces( mesh, mesh->markerName( __marker ), meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
996 }
997 
998 template<typename MeshType>
999 boost::tuple<mpl::size_t<MESH_FACES>,
1000  typename MeshTraits<MeshType>::marker_face_const_iterator,
1001  typename MeshTraits<MeshType>::marker_face_const_iterator>
1002  markedfaces( MeshType const& mesh,
1003  const char*__marker )
1004 {
1005  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1006  return detail::markedfaces( mesh, mesh->markerName( __marker ), meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
1007 }
1008 
1009 template<typename MeshType>
1010 boost::tuple<mpl::size_t<MESH_FACES>,
1011  typename MeshTraits<MeshType>::marker_face_const_iterator,
1012  typename MeshTraits<MeshType>::marker_face_const_iterator>
1013  markedfaces( MeshType const& mesh,
1014  boost::any const&__marker )
1015 {
1016  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1017  flag_type theflag = mesh->markerId( __marker );
1018  VLOG(2) << "[markedfaces] flag: " << theflag << "\n";
1019  return detail::markedfaces( mesh, theflag, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
1020 
1021 }
1022 
1023 template<typename MeshType>
1024 std::list<boost::tuple<mpl::size_t<MESH_FACES>,
1025  typename MeshTraits<MeshType>::marker_face_const_iterator,
1026  typename MeshTraits<MeshType>::marker_face_const_iterator> >
1027 markedfaces( MeshType const& mesh,
1028  std::initializer_list<boost::any> __markers )
1029 {
1030  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1031  std::list<boost::tuple<mpl::size_t<MESH_FACES>,
1032  typename MeshTraits<MeshType>::marker_face_const_iterator,
1033  typename MeshTraits<MeshType>::marker_face_const_iterator> > list_faces;
1034  for( auto it = __markers.begin(), en = __markers.end(); it != en; ++it )
1035  {
1036  flag_type theflag = mesh->markerId( *it );
1037  VLOG(2) << "[markedfaces] flag: " << theflag << "\n";
1038  list_faces.push_back( detail::markedfaces( mesh, theflag, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() ) );
1039  }
1040  return list_faces;
1041 }
1042 
1043 template<typename MeshType>
1044 std::list<boost::tuple<mpl::size_t<MESH_FACES>,
1045  typename MeshTraits<MeshType>::marker_face_const_iterator,
1046  typename MeshTraits<MeshType>::marker_face_const_iterator> >
1047 markedfaces( MeshType const& mesh,
1048  std::list<std::string> __markers )
1049 {
1050  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1051  std::list<boost::tuple<mpl::size_t<MESH_FACES>,
1052  typename MeshTraits<MeshType>::marker_face_const_iterator,
1053  typename MeshTraits<MeshType>::marker_face_const_iterator> > list_faces;
1054  for( auto it = __markers.begin(), en = __markers.end(); it != en; ++it )
1055  {
1056  flag_type theflag = mesh->markerId( *it );
1057  VLOG(2) << "[markedfaces] flag: " << theflag << "\n";
1058  list_faces.push_back( detail::markedfaces( mesh, theflag, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() ) );
1059  }
1060  return list_faces;
1061 }
1062 
1063 template<typename MeshType>
1064 boost::tuple<mpl::size_t<MESH_FACES>,
1065  typename MeshTraits<MeshType>::marker2_face_const_iterator,
1066  typename MeshTraits<MeshType>::marker2_face_const_iterator>
1067  marked2faces( MeshType const& mesh,
1068  flag_type __marker )
1069 {
1070  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1071  return detail::marked2faces( mesh, __marker, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
1072 }
1073 
1074 template<typename MeshType>
1075 std::list<boost::tuple<mpl::size_t<MESH_FACES>,
1076  typename MeshTraits<MeshType>::marker2_face_const_iterator,
1077  typename MeshTraits<MeshType>::marker2_face_const_iterator> >
1078 marked2faces( MeshType const& mesh,
1079  std::initializer_list<boost::any> __markers )
1080 {
1081  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1082  std::list<boost::tuple<mpl::size_t<MESH_FACES>,
1083  typename MeshTraits<MeshType>::marker2_face_const_iterator,
1084  typename MeshTraits<MeshType>::marker2_face_const_iterator> > list_faces;
1085  for( auto it = __markers.begin(), en = __markers.end(); it != en; ++it )
1086  {
1087  flag_type theflag = mesh->markerId( *it );
1088  VLOG(2) << "[markedfaces] flag: " << theflag << "\n";
1089  list_faces.push_back( detail::marked2faces( mesh, theflag, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() ) );
1090  }
1091  return list_faces;
1092 }
1093 
1094 template<typename MeshType>
1095 boost::tuple<mpl::size_t<MESH_FACES>,
1096  typename MeshTraits<MeshType>::marker3_face_const_iterator,
1097  typename MeshTraits<MeshType>::marker3_face_const_iterator>
1098  marked3faces( MeshType const& mesh,
1099  flag_type __marker )
1100 {
1101  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1102  return detail::marked3faces( mesh, __marker, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
1103 }
1104 
1105 
1106 template<typename MeshType>
1107 boost::tuple<mpl::size_t<MESH_FACES>,
1108  typename MeshTraits<MeshType>::marker2_face_const_iterator,
1109  typename MeshTraits<MeshType>::marker2_face_const_iterator>
1110  marked2faces( MeshType const& mesh,
1111  std::string const& __marker )
1112 {
1113  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1114  return detail::marked2faces( mesh, mesh->markerName( __marker ), meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
1115 }
1116 
1117 template<typename MeshType>
1118 boost::tuple<mpl::size_t<MESH_FACES>,
1119  typename MeshTraits<MeshType>::marker3_face_const_iterator,
1120  typename MeshTraits<MeshType>::marker3_face_const_iterator>
1121  marked3faces( MeshType const& mesh,
1122  std::string const& __marker )
1123 {
1124  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1125  return detail::marked3faces( mesh, mesh->markerName( __marker ), meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
1126 }
1127 
1128 template<typename MeshType>
1129 std::list<boost::tuple<mpl::size_t<MESH_FACES>,
1130  typename MeshTraits<MeshType>::marker3_face_const_iterator,
1131  typename MeshTraits<MeshType>::marker3_face_const_iterator> >
1132 marked3faces( MeshType const& mesh,
1133  std::initializer_list<boost::any> __markers )
1134 {
1135  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1136  std::list<boost::tuple<mpl::size_t<MESH_FACES>,
1137  typename MeshTraits<MeshType>::marker3_face_const_iterator,
1138  typename MeshTraits<MeshType>::marker3_face_const_iterator> > list_faces;
1139  for( auto it = __markers.begin(), en = __markers.end(); it != en; ++it )
1140  {
1141  flag_type theflag = mesh->markerId( *it );
1142  VLOG(2) << "[markedfaces] flag: " << theflag << "\n";
1143  list_faces.push_back( detail::marked3faces( mesh, theflag, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() ) );
1144  }
1145  return list_faces;
1146 }
1147 
1154 template<typename MeshType>
1155 boost::tuple<mpl::size_t<MESH_FACES>,
1156  typename MeshTraits<MeshType>::location_face_const_iterator,
1157  typename MeshTraits<MeshType>::location_face_const_iterator>
1158  boundaryfaces( MeshType const& mesh )
1159 {
1160  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1161  return detail::boundaryfaces( mesh, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
1162 }
1163 
1164 
1171 template<typename MeshType>
1172 boost::tuple<mpl::size_t<MESH_FACES>,
1173  typename MeshTraits<MeshType>::location_face_const_iterator,
1174  typename MeshTraits<MeshType>::location_face_const_iterator>
1175  internalfaces( MeshType const& mesh )
1176 {
1177  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1178  return detail::internalfaces( mesh, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
1179 }
1180 
1187 template<typename MeshType>
1188 boost::tuple<mpl::size_t<MESH_FACES>,
1189  typename MeshTraits<MeshType>::interprocess_face_const_iterator,
1190  typename MeshTraits<MeshType>::interprocess_face_const_iterator>
1191  interprocessfaces( MeshType const& mesh )
1192 {
1193  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1194  return detail::interprocessfaces( mesh, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
1195 }
1196 
1197 
1209 template<typename MeshType>
1210 boost::tuple<mpl::size_t<MESH_EDGES>,
1211  typename MeshTraits<MeshType>::pid_edge_const_iterator,
1212  typename MeshTraits<MeshType>::pid_edge_const_iterator>
1213  edges( MeshType const& mesh )
1214 {
1215  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1216  return detail::edges( mesh, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
1217 }
1218 
1219 
1232 template<typename MeshType>
1233 boost::tuple<mpl::size_t<MESH_EDGES>,
1234  typename MeshTraits<MeshType>::marker_edge_const_iterator,
1235  typename MeshTraits<MeshType>::marker_edge_const_iterator>
1236  markededges( MeshType const& mesh,
1237  flag_type __marker )
1238 {
1239  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1240  return detail::markededges( mesh, __marker, meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
1241 }
1242 
1243 template<typename MeshType>
1244 boost::tuple<mpl::size_t<MESH_EDGES>,
1245  typename MeshTraits<MeshType>::marker_edge_const_iterator,
1246  typename MeshTraits<MeshType>::marker_edge_const_iterator>
1247  markededges( MeshType const& mesh,
1248  std::string const& __marker )
1249 {
1250  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1251  return detail::markededges( mesh, mesh->markerName(__marker), meshrank( mesh, is_ptr_or_shared_ptr() ), is_ptr_or_shared_ptr() );
1252 }
1253 
1260 template<typename MeshType>
1261 boost::tuple<mpl::size_t<MESH_EDGES>,
1262  typename MeshTraits<MeshType>::location_edge_const_iterator,
1263  typename MeshTraits<MeshType>::location_edge_const_iterator>
1264  boundaryedges( MeshType const& mesh )
1265 {
1266  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1267  return detail::boundaryedges( mesh, is_ptr_or_shared_ptr() );
1268 }
1269 
1270 
1277 template<typename MeshType>
1278 boost::tuple<mpl::size_t<MESH_EDGES>,
1279  typename MeshTraits<MeshType>::location_edge_const_iterator,
1280  typename MeshTraits<MeshType>::location_edge_const_iterator>
1281  internaledges( MeshType const& mesh )
1282 {
1283  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1284  return detail::internaledges( mesh, is_ptr_or_shared_ptr() );
1285 }
1286 
1292 template<typename MeshType>
1293 boost::tuple<mpl::size_t<MESH_POINTS>,
1294  typename MeshTraits<MeshType>::point_const_iterator,
1295  typename MeshTraits<MeshType>::point_const_iterator>
1296  points( MeshType const& mesh )
1297 {
1298  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1299  return detail::points( mesh, is_ptr_or_shared_ptr() );
1300 }
1301 
1307 template<typename MeshType>
1308 boost::tuple<mpl::size_t<MESH_POINTS>,
1309  typename MeshTraits<MeshType>::marker_point_const_iterator,
1310  typename MeshTraits<MeshType>::marker_point_const_iterator>
1311  markedpoints( MeshType const& mesh, size_type flag )
1312 {
1313  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1314  return detail::markedpoints( mesh, flag, is_ptr_or_shared_ptr() );
1315 }
1316 
1317 template<typename MeshType>
1318 boost::tuple<mpl::size_t<MESH_POINTS>,
1319  typename MeshTraits<MeshType>::marker_point_const_iterator,
1320  typename MeshTraits<MeshType>::marker_point_const_iterator>
1321 markedpoints( MeshType const& mesh, std::string const& flag )
1322 {
1323  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1324  return detail::markedpoints( mesh, mesh->markerName(flag), is_ptr_or_shared_ptr() );
1325 }
1326 
1332 template<typename MeshType>
1333 boost::tuple<mpl::size_t<MESH_POINTS>,
1334  typename MeshTraits<MeshType>::location_point_const_iterator,
1335  typename MeshTraits<MeshType>::location_point_const_iterator>
1336  boundarypoints( MeshType const& mesh )
1337 {
1338  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1339  return detail::boundarypoints( mesh, is_ptr_or_shared_ptr() );
1340 }
1341 
1347 template<typename MeshType>
1348 boost::tuple<mpl::size_t<MESH_POINTS>,
1349  typename MeshTraits<MeshType>::location_point_const_iterator,
1350  typename MeshTraits<MeshType>::location_point_const_iterator>
1351  internalpoints( MeshType const& mesh )
1352 {
1353  typedef typename mpl::or_<is_shared_ptr<MeshType>, boost::is_pointer<MeshType> >::type is_ptr_or_shared_ptr;
1354 
1355  return detail::internalpoints( mesh, is_ptr_or_shared_ptr() );
1356 }
1357 
1373 template<typename MT, typename Iterator>
1374 size_type
1375 nelements( boost::tuple<MT,Iterator,Iterator> const& its, bool global = false )
1376 {
1377  size_type d = std::distance( boost::get<1>( its ), boost::get<2>( its ) );
1378  size_type gd = d;
1379  if ( global )
1380  mpi::all_reduce(Environment::worldComm().globalComm(),
1381  d,
1382  gd,
1383  std::plus<size_type>());
1384  return gd;
1385 
1386 }
1402 template<typename MT, typename Iterator>
1403 size_type
1404 nelements( std::list<boost::tuple<MT,Iterator,Iterator> > const& its, bool global = false )
1405 {
1406  size_type d = 0;
1407  std::for_each( its.begin(), its.end(),
1408  [&d]( boost::tuple<MT,Iterator,Iterator> const& t )
1409  {
1410  d+=std::distance( boost::get<1>( t ), boost::get<2>( t ) );
1411  } );
1412  size_type gd = d;
1413  if ( global )
1414  mpi::all_reduce(Environment::worldComm().globalComm(),
1415  d,
1416  gd,
1417  std::plus<size_type>());
1418  return gd;
1419 }
1420 
1421 template<typename ElementType>
1422 boost::tuple<mpl::size_t<MESH_ELEMENTS>,
1423  typename std::list<ElementType>::const_iterator,
1424  typename std::list<ElementType>::const_iterator>
1425  element( ElementType const& elt )
1426 {
1427  std::list<ElementType> lst;
1428  lst.push_back( elt );
1429  return boost::make_tuple( mpl::size_t<MESH_ELEMENTS>(),
1430  lst.begin(),
1431  lst.end() );
1432 }
1433 
1434 }
1435 
1436 
1437 #endif

Generated on Fri Oct 25 2013 14:24:11 for Feel++ by doxygen 1.8.4