DUNE PDELab (git)

gridview.hh
1// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
2// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
3// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
4// vi: set et ts=4 sw=2 sts=2:
5#ifndef DUNE_ALBERTAGRID_GRIDVIEW_HH
6#define DUNE_ALBERTAGRID_GRIDVIEW_HH
7
8#if HAVE_ALBERTA
9
10#include <dune/common/typetraits.hh>
11#include <dune/common/exceptions.hh>
12
13#include <dune/grid/common/capabilities.hh>
14#include <dune/grid/common/gridview.hh>
15
16#include <dune/grid/albertagrid/intersectioniterator.hh>
17
18namespace Dune
19{
20
21 template< class GridImp >
22 class AlbertaLevelGridView;
23
24 template< class GridImp >
25 class AlbertaLeafGridView;
26
27
28 template< class GridImp >
29 struct AlbertaLevelGridViewTraits
30 {
31 typedef AlbertaLevelGridView< GridImp > GridViewImp;
32
34 typedef typename std::remove_const<GridImp>::type Grid;
35
37 typedef typename Grid::Traits::LevelIndexSet IndexSet;
38
40 typedef typename Grid::Traits::LevelIntersection Intersection;
41
43 typedef typename Grid::Traits::LevelIntersectionIterator
44 IntersectionIterator;
45
47 typedef typename Grid::Traits::Communication Communication;
48
49 template< int cd >
50 struct Codim
51 {
52 typedef typename Grid::Traits::template Codim< cd >::template Partition< All_Partition >::LevelIterator Iterator;
53
54 typedef typename Grid::Traits::template Codim< cd >::Entity Entity;
55
56 typedef typename Grid::template Codim< cd >::Geometry Geometry;
57 typedef typename Grid::template Codim< cd >::LocalGeometry
58 LocalGeometry;
59
61 template< PartitionIteratorType pit >
62 struct Partition
63 {
65 typedef typename Grid::template Codim< cd >::template Partition< pit >::LevelIterator
66 Iterator;
67 };
68 };
69
70 constexpr static bool conforming = Capabilities::isLevelwiseConforming< Grid >::v;
71 };
72
73
74 template< class GridImp >
75 class AlbertaLevelGridView
76 {
77 typedef AlbertaLevelGridView< GridImp > ThisType;
78
79 public:
80 typedef AlbertaLevelGridViewTraits<GridImp> Traits;
81
83 typedef typename Traits::Grid Grid;
84
86 typedef typename Traits::IndexSet IndexSet;
87
89 typedef typename Traits::Intersection Intersection;
90
92 typedef typename Traits::IntersectionIterator IntersectionIterator;
93
95 typedef typename Traits::Communication Communication;
96
98 template< int cd >
99 struct Codim : public Traits::template Codim<cd> {};
100
101 constexpr static bool conforming = Traits::conforming;
102
103 private:
104 typedef Alberta::ElementInfo< Grid::dimension > ElementInfo;
105
106 typedef Dune::AlbertaGridLeafIntersectionIterator< GridImp > IntersectionIteratorImpl;
107
108 public:
109 AlbertaLevelGridView ( const Grid &grid, int level )
110 : grid_( &grid ),
111 indexSet_( &(grid.levelIndexSet( level )) ),
112 level_( level )
113 {}
114
115 // use default implementation of copy constructor and assignment operator
116#if 0
117 AlbertaLevelGridView ( const ThisType &other )
118 : grid_( other.grid_ ),
119 indexSet_( other.indexSet_ ),
120 level_( other.level_ )
121 {}
122
124 ThisType &operator= ( const ThisType & other)
125 {
126 grid_ = other.grid_;
127 indexSet_ = other.indexSet_;
128 level_ = other.level_;
129 }
130#endif
131
133 const Grid &grid () const
134 {
135 return *grid_;
136 }
137
139 const IndexSet &indexSet () const
140 {
141 return *indexSet_;
142 }
143
145 bool isConforming() const { return bool(conforming); }
146
148 int size ( int codim ) const
149 {
150 return grid().size( level_, codim );
151 }
152
154 int size ( const GeometryType &type ) const
155 {
156 return grid().size( level_, type );
157 }
158
160 template< int cd >
161 typename Codim< cd >::Iterator begin () const
162 {
163 return grid().template lbegin< cd, All_Partition >( level_ );
164 }
165
167 template< int cd, PartitionIteratorType pit >
168 typename Codim< cd >::template Partition< pit >::Iterator begin () const
169 {
170 return grid().template lbegin< cd, pit >( level_ );
171 }
172
174 template< int cd >
175 typename Codim< cd >::Iterator end () const
176 {
177 return grid().template lend< cd, All_Partition >( level_ );
178 }
179
181 template< int cd, PartitionIteratorType pit >
182 typename Codim< cd >::template Partition< pit >::Iterator end () const
183 {
184 return grid().template lend< cd, pit >( level_ );
185 }
186
188 IntersectionIterator
189 ibegin ( const typename Codim< 0 >::Entity &entity ) const
190 {
191 if( grid().maxLevel() == 0)
192 {
193 typename IntersectionIteratorImpl::Begin begin;
194 return IntersectionIteratorImpl( entity.impl(), begin );
195 }
196 else
197 {
198 DUNE_THROW( NotImplemented, "method ibegin not implemented on LevelGridView for AlbertaGrid." );
199 typename IntersectionIteratorImpl::End end;
200 return IntersectionIteratorImpl( entity.impl(), end );
201 }
202 }
203
205 IntersectionIterator
206 iend ( const typename Codim< 0 >::Entity &entity ) const
207 {
208 typename IntersectionIteratorImpl::End end;
209 return IntersectionIteratorImpl( entity.impl(), end );
210 }
211
213 const Communication &comm () const
214 {
215 return grid().comm();
216 }
217
219 int overlapSize ( [[maybe_unused]] int codim ) const { return 0; }
220
222 int ghostSize ( [[maybe_unused]] int codim ) const { return 0; }
223
225 template< class DataHandleImp, class DataType >
226 void communicate ( [[maybe_unused]] CommDataHandleIF< DataHandleImp, DataType > &data,
227 [[maybe_unused]] InterfaceType iftype,
228 [[maybe_unused]] CommunicationDirection dir ) const
229 {}
230
231 private:
232 const Grid *grid_;
233 const IndexSet *indexSet_;
234 int level_;
235 };
236
237
238 template< class GridImp >
239 struct AlbertaLeafGridViewTraits
240 {
241 typedef AlbertaLeafGridView< GridImp > GridViewImp;
242
244 typedef typename std::remove_const<GridImp>::type Grid;
245
247 typedef typename Grid::Traits::LeafIndexSet IndexSet;
248
250 typedef typename Grid::Traits::LeafIntersection Intersection;
251
253 typedef typename Grid::Traits::LeafIntersectionIterator
254 IntersectionIterator;
255
257 typedef typename Grid::Traits::Communication Communication;
258
259 template< int cd >
260 struct Codim
261 {
262 typedef typename Grid::Traits::template Codim< cd >::template Partition< All_Partition >::LeafIterator
263 Iterator;
264
265 typedef typename Grid::Traits::template Codim< cd >::Entity Entity;
266
267 typedef typename Grid::template Codim< cd >::Geometry Geometry;
268 typedef typename Grid::template Codim< cd >::LocalGeometry
269 LocalGeometry;
270
272 template <PartitionIteratorType pit >
273 struct Partition
274 {
276 typedef typename Grid::template Codim< cd >::template Partition< pit >::LeafIterator
277 Iterator;
278 };
279 };
280
281 constexpr static bool conforming = Capabilities::isLeafwiseConforming< Grid >::v;
282 };
283
284
285 template< class GridImp >
286 class AlbertaLeafGridView
287 {
288 typedef AlbertaLeafGridView< GridImp > ThisType;
289
290 public:
291 typedef AlbertaLeafGridViewTraits<GridImp> Traits;
292
294 typedef typename Traits::Grid Grid;
295
297 typedef typename Traits::IndexSet IndexSet;
298
300 typedef typename Traits::Intersection Intersection;
301
303 typedef typename Traits::IntersectionIterator IntersectionIterator;
304
306 typedef typename Traits::Communication Communication;
307
309 template< int cd >
310 struct Codim : public Traits::template Codim<cd> {};
311
312 constexpr static bool conforming = Traits::conforming;
313
314 private:
315 typedef Alberta::ElementInfo< Grid::dimension > ElementInfo;
316
317 typedef Dune::AlbertaGridLeafIntersectionIterator< GridImp > IntersectionIteratorImpl;
318
319 public:
320 AlbertaLeafGridView ( const Grid &grid )
321 : grid_( &grid ),
322 indexSet_( &(grid.leafIndexSet()) )
323 {}
324
325 // use default implementation of copy constructor and assignment operator
326#if 0
327 AlbertaLeafGridView ( const ThisType &other )
328 : grid_( other.grid_ ),
329 indexSet_( other.indexSet_ )
330 {}
331
333 ThisType &operator= ( const ThisType & other)
334 {
335 grid_ = other.grid_;
336 indexSet_ = other.indexSet_;
337 }
338#endif
339
341 const Grid &grid () const
342 {
343 return *grid_;
344 }
345
347 const IndexSet &indexSet () const
348 {
349 return *indexSet_;
350 }
351
353 bool isConforming() const { return bool(conforming); }
354
356 int size ( int codim ) const
357 {
358 return grid().size( codim );
359 }
360
362 int size ( const GeometryType &type ) const
363 {
364 return grid().size( type );
365 }
366
368 template< int cd >
369 typename Codim< cd >::Iterator begin () const
370 {
371 return grid().template leafbegin< cd, All_Partition >();
372 }
373
375 template< int cd, PartitionIteratorType pit >
376 typename Codim< cd >::template Partition< pit >::Iterator begin () const
377 {
378 return grid().template leafbegin< cd, pit >();
379 }
380
382 template< int cd >
383 typename Codim< cd >::Iterator end () const
384 {
385 return grid().template leafend< cd, All_Partition >();
386 }
387
389 template< int cd, PartitionIteratorType pit >
390 typename Codim< cd >::template Partition< pit >::Iterator end () const
391 {
392 return grid().template leafend< cd, pit >();
393 }
394
396 IntersectionIterator
397 ibegin ( const typename Codim< 0 >::Entity &entity ) const
398 {
399 const ElementInfo elementInfo = entity.impl().elementInfo();
400 assert( !!elementInfo );
401
402#ifndef NDEBUG
403 for( int i = 0; i <= Grid::dimension; ++i )
404 {
405 if( elementInfo.elInfo().opp_vertex[ i ] == 127 )
406 DUNE_THROW( NotImplemented, "AlbertaGrid: Intersections on outside entities are not fully implemented, yet." );
407 }
408#endif // #ifndef NDEBUG
409
410 typename IntersectionIteratorImpl::Begin begin;
411 return IntersectionIteratorImpl( entity.impl(), begin );
412 }
413
415 IntersectionIterator
416 iend ( const typename Codim< 0 >::Entity &entity ) const
417 {
418 assert( !!entity.impl().elementInfo() );
419 typename IntersectionIteratorImpl::End end;
420 return IntersectionIteratorImpl( entity.impl(), end );
421 }
422
424 const Communication &comm () const
425 {
426 return grid().comm();
427 }
428
430 int overlapSize ( [[maybe_unused]] int codim ) const { return 0; }
431
433 int ghostSize ( [[maybe_unused]] int codim ) const { return 0; }
434
436 template< class DataHandleImp, class DataType >
437 void communicate ( [[maybe_unused]] CommDataHandleIF< DataHandleImp, DataType > &data,
438 [[maybe_unused]] InterfaceType iftype,
439 [[maybe_unused]] CommunicationDirection dir ) const
440 {}
441
442 private:
443 const Grid *grid_;
444 const IndexSet *indexSet_;
445 };
446
447}
448
449#endif // #if HAVE_ALBERTA
450#endif // #ifndef DUNE_ALBERTAGRID_GRIDVIEW_HH
intersectioniterator.hh
Implementation of the IntersectionIterator for AlbertaGrid.
Dune::Communication
Collective communication interface and sequential default implementation.
Definition: communication.hh:100
Dune::Grid
Grid abstract base class.
Definition: grid.hh:375
Dune::Grid::dimension
static constexpr int dimension
The dimension of the grid.
Definition: grid.hh:387
Dune::IndexSet
Index Set Interface base class.
Definition: indexidset.hh:78
Dune::IntersectionIterator
Mesh entities of codimension 0 ("elements") allow to visit all intersections with "neighboring" eleme...
Definition: intersectioniterator.hh:83
Dune::Intersection
Intersection of a mesh entity of codimension 0 ("element") with a "neighboring" element or with the d...
Definition: intersection.hh:164
capabilities.hh
A set of traits classes to store static information about grid implementation.
exceptions.hh
A few common exception classes.
typetraits.hh
Traits for type conversions and type information.
DUNE_THROW
#define DUNE_THROW(E, m)
Definition: exceptions.hh:218
Dune::CommunicationDirection
CommunicationDirection
Define a type for communication direction parameter.
Definition: gridenums.hh:170
Dune::InterfaceType
InterfaceType
Parameter to be used for the communication functions.
Definition: gridenums.hh:86
Dune
Dune namespace.
Definition: alignedallocator.hh:13
Dune::size
constexpr std::integral_constant< std::size_t, sizeof...(II)> size(std::integer_sequence< T, II... >)
Return the size of the sequence.
Definition: integersequence.hh:75
Dune::AlbertaLeafGridViewTraits::Codim::Partition
Define types needed to iterate over entities of a given partition type.
Definition: gridview.hh:274
Dune::AlbertaLeafGridViewTraits::Codim::Partition::Iterator
Grid::template Codim< cd >::template Partition< pit >::LeafIterator Iterator
iterator over a given codim and partition type
Definition: gridview.hh:277
Dune::AlbertaLeafGridView::Codim
Codim Structure.
Definition: gridview.hh:310
Dune::AlbertaLevelGridViewTraits::Codim::Partition
Define types needed to iterate over entities of a given partition type.
Definition: gridview.hh:63
Dune::AlbertaLevelGridViewTraits::Codim::Partition::Iterator
Grid::template Codim< cd >::template Partition< pit >::LevelIterator Iterator
iterator over a given codim and partition type
Definition: gridview.hh:66
Dune::AlbertaLevelGridView::Codim
Codim Structure.
Definition: gridview.hh:99
Dune::Capabilities::isLeafwiseConforming
Specialize with 'true' if implementation guarantees a conforming leaf grid. (default=false)
Definition: capabilities.hh:115
Dune::Capabilities::isLevelwiseConforming
Specialize with 'true' if implementation guarantees conforming level grids. (default=false)
Definition: capabilities.hh:106
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.111.3 (Nov 24, 23:30, 2024)