1 #ifndef DUNE_FEM_GRIDPART_IDGRIDPART_INDEXSET_HH
2 #define DUNE_FEM_GRIDPART_IDGRIDPART_INDEXSET_HH
3 
4 #include <type_traits>
5 #include <vector>
6 
7 #include <dune/geometry/type.hh>
8 
9 #include <dune/fem/gridpart/common/indexset.hh>
10 #include <dune/fem/gridpart/common/persistentindexset.hh>
11 
12 #include <dune/fem/io/streams/streams.hh>
13 
14 namespace Dune
15 {
16 
17   namespace Fem
18   {
19 
20     // Internal forward declaration
21     // ----------------------------
22 
23     template< class GridFamily >
24     class IdIndexSet;
25 
26 
27 
28     namespace __IdIndexSet
29     {
30 
31       // IndexSet
32       // --------
33 
34       template< class GridFamily >
35       class IndexSet
36       {
37       protected:
38         typedef typename std::remove_const< GridFamily >::type::Traits Traits;
39 
40       public:
41         typedef typename Traits::HostGridPartType::IndexSetType HostIndexSetType;
42 
43         static const int dimension = HostIndexSetType::dimension;
44 
45         template< int codim >
46         struct Codim
47         {
48           typedef typename Traits::template Codim< codim >::Entity Entity;
49         };
50 
51         typedef typename HostIndexSetType::IndexType IndexType;
52 
53         typedef typename HostIndexSetType::Types Types;
54 
IndexSet(const HostIndexSetType & hostIndexSet)55         explicit IndexSet ( const HostIndexSetType &hostIndexSet )
56           : hostIndexSet_( hostIndexSet )
57         {}
58 
types(int codim) const59         Types types ( int codim ) const
60         {
61           return hostIndexSet().types( codim );
62         }
63 
geomTypes(int codim) const64         const std::vector< GeometryType > &geomTypes ( int codim ) const
65         {
66           return hostIndexSet().geomTypes( codim );
67         }
68 
69         template< class Entity >
contains(const Entity & entity) const70         bool contains ( const Entity &entity ) const
71         {
72           return hostIndexSet().contains( entity.impl().hostEntity() );
73         }
74 
size(GeometryType type) const75         IndexType size ( GeometryType type ) const
76         {
77           return hostIndexSet().size( type );
78         }
79 
size(int codim) const80         IndexType size ( int codim ) const
81         {
82           return hostIndexSet().size( codim );
83         }
84 
85         template< class Entity >
index(const Entity & entity) const86         IndexType index ( const Entity &entity ) const
87         {
88           return index< Entity::codimension >( entity );
89         }
90 
91         template< int codim >
index(const typename Codim<codim>::Entity & entity) const92         IndexType index ( const typename Codim< codim >::Entity &entity ) const
93         {
94           return hostIndexSet().template index< codim >( entity.impl().hostEntity() );
95         }
96 
97         template< class Entity >
subIndex(const Entity & entity,int i,unsigned int cd) const98         IndexType subIndex ( const Entity &entity, int i, unsigned int cd ) const
99         {
100           return subIndex< Entity::codimension >( entity, i, cd );
101         }
102 
103         template< int codim >
subIndex(const typename Codim<codim>::Entity & entity,int i,unsigned int cd) const104         IndexType subIndex ( const typename Codim< codim >::Entity &entity, int i, unsigned int cd ) const
105         {
106           return hostIndexSet().template subIndex< codim >( entity.impl().hostEntity(), i, cd );
107         }
108 
hostIndexSet() const109         const HostIndexSetType &hostIndexSet () const
110         {
111           return hostIndexSet_;
112         }
113 
requestCodimensions(const std::vector<int> & codimensions) const114         void requestCodimensions( const std::vector< int >& codimensions ) const
115         {
116           hostIndexSet().requestCodimensions( codimensions );
117         }
118 
119       protected:
hostIndexSet()120         HostIndexSetType &hostIndexSet () { return const_cast< HostIndexSetType & >( hostIndexSet_); }
121 
122       private:
123         const HostIndexSetType &hostIndexSet_;
124       };
125 
126 
127 
128       // ConsecutiveIndexSet
129       // -------------------
130 
131       template< class GridFamily >
132       class ConsecutiveIndexSet
133         : public IndexSet< GridFamily >
134       {
135         typedef IndexSet< GridFamily > BaseType;
136 
137       public:
138         typedef typename BaseType::HostIndexSetType HostIndexSetType;
139 
140         using BaseType::hostIndexSet;
141 
ConsecutiveIndexSet(const HostIndexSetType & hostIndexSet)142         explicit ConsecutiveIndexSet ( const HostIndexSetType &hostIndexSet )
143           : BaseType ( hostIndexSet )
144         {}
145 
resize()146         void resize () { hostIndexSet().resize(); }
147 
compress()148         bool compress () { return hostIndexSet().compress(); }
149 
insertEntity(const typename BaseType::template Codim<0>::Entity & entity)150         void insertEntity ( const typename BaseType::template Codim< 0 >::Entity &entity )
151         {
152           hostIndexSet().insertEntity( entity.impl().hostEntity() );
153         }
154 
removeEntity(const typename BaseType::template Codim<0>::Entity & entity)155         void removeEntity ( const typename BaseType::template Codim< 0 >::Entity &entity )
156         {
157           hostIndexSet().removeEntity( entity.impl().hostEntity() );
158         }
159 
backup() const160         void backup () const { hostIndexSet().backup(); }
161 
restore()162         void restore () { hostIndexSet().restore(); }
163 
164         template< class T >
write(OutStreamInterface<T> & stream)165         void write ( OutStreamInterface< T > &stream )
166         {
167           hostIndexSet().write( stream );
168         }
169 
170         template< class T >
read(InStreamInterface<T> & stream)171         void read ( InStreamInterface< T > &stream )
172         {
173           hostIndexSet().read( stream );
174         }
175 
176       protected:
hostIndexSet()177         HostIndexSetType &hostIndexSet ()
178         {
179           return const_cast< HostIndexSetType & >( BaseType::hostIndexSet() );
180         }
181       };
182 
183 
184 
185       // AdaptiveIndexSet
186       // ----------------
187 
188       template< class GridFamily >
189       class AdaptiveIndexSet
190         : public ConsecutiveIndexSet< GridFamily >
191       {
192         typedef ConsecutiveIndexSet< GridFamily > BaseType;
193 
194       public:
AdaptiveIndexSet(const typename BaseType::HostIndexSetType & hostIndexSet)195         explicit AdaptiveIndexSet ( const typename BaseType::HostIndexSetType &hostIndexSet )
196           : BaseType ( hostIndexSet )
197         {}
198 
numberOfHoles(GeometryType type) const199         int numberOfHoles ( GeometryType type ) const
200         {
201           return this->hostIndexSet().numberOfHoles( type );
202         }
203 
numberOfHoles(int codim) const204         int numberOfHoles ( int codim ) const
205         {
206           return this->hostIndexSet().numberOfHoles( codim );
207         }
208 
oldIndex(int hole,GeometryType type) const209         int oldIndex ( int hole, GeometryType type ) const
210         {
211           return this->hostIndexSet().oldIndex( hole, type );
212         }
213 
oldIndex(int hole,int codim) const214         int oldIndex ( int hole, int codim ) const
215         {
216           return this->hostIndexSet().oldIndex( hole, codim );
217         }
218 
newIndex(int hole,GeometryType type) const219         int newIndex ( int hole, GeometryType type ) const
220         {
221           return this->hostIndexSet().newIndex( hole, type );
222         }
223 
newIndex(int hole,int codim) const224         int newIndex ( int hole, int codim ) const
225         {
226           return this->hostIndexSet().newIndex( hole, codim );
227         }
228       };
229 
230 
231 
232       // Implementation
233       // --------------
234 
235       template< class GridFamily,
236                 class HostIndexSet = typename std::remove_const< GridFamily >::type::Traits::HostGridPartType::IndexSetType,
237                 bool consecutive = Capabilities::isConsecutiveIndexSet< HostIndexSet >::v,
238                 bool adaptive = Capabilities::isAdaptiveIndexSet< HostIndexSet >::v >
239       struct Implementation
240       {
241         typedef typename std::conditional< adaptive,
242             AdaptiveIndexSet< GridFamily >,
243             typename std::conditional< consecutive,
244                 ConsecutiveIndexSet< GridFamily >,
245                 IndexSet< GridFamily >
246               >::type
247           >::type Type;
248       };
249 
250     } // namespace __IdIndexSet
251 
252 
253 
254     // IdIndexSet
255     // ----------
256 
257     template< class GridFamily >
258     class IdIndexSet
259       : public __IdIndexSet::Implementation< GridFamily >::Type
260     {
261       typedef typename __IdIndexSet::Implementation< GridFamily >::Type BaseType;
262 
263       friend struct Capabilities::isPersistentIndexSet< IdIndexSet< GridFamily > >;
264 
265     public:
IdIndexSet(const typename BaseType::HostIndexSetType & hostIndexSet)266       explicit IdIndexSet ( const typename BaseType::HostIndexSetType &hostIndexSet )
267         : BaseType ( hostIndexSet )
268       {}
269     };
270 
271 
272 
273     namespace Capabilities
274     {
275 
276       template< class GridFamily >
277       struct isConsecutiveIndexSet< IdIndexSet< GridFamily > >
278         : public isConsecutiveIndexSet< typename IdIndexSet< GridFamily >::HostIndexSetType >
279       {};
280 
281       template< class GridFamily >
282       struct isAdaptiveIndexSet< IdIndexSet< GridFamily > >
283         : public isAdaptiveIndexSet< typename IdIndexSet< GridFamily >::HostIndexSetType >
284       {};
285 
286       template< class GridFamily >
287       struct isPersistentIndexSet< IdIndexSet< GridFamily > >
288       {
289       private:
290         typedef IdIndexSet< GridFamily > IndexSetType;
291         typedef typename IndexSetType::HostIndexSetType HostIndexSetType;
292 
293       public:
294         static const bool v = isPersistentIndexSet< HostIndexSetType >::v;
295 
mapDune::Fem::Capabilities::isPersistentIndexSet296         static constexpr PersistentIndexSetInterface *map ( IndexSetType &indexSet ) noexcept
297         {
298           return isPersistentIndexSet< HostIndexSetType >::map( indexSet.hostIndexSet() );
299         }
300       };
301 
302     } // namespace Capabilities
303 
304   } // namespace Fem
305 
306 } // namespace Dune
307 
308 #endif // #ifndef DUNE_FEM_GRIDPART_IDGRIDPART_INDEXSET_HH
309