dune-grid  2.9.0
dofadmin.hh
Go to the documentation of this file.
1 // SPDX-FileCopyrightText: Copyright (C) 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_ALBERTA_DOFADMIN_HH
6 #define DUNE_ALBERTA_DOFADMIN_HH
7 
8 #include <utility>
9 
10 #include <dune/common/hybridutilities.hh>
11 
14 
15 #if HAVE_ALBERTA
16 
17 namespace Dune
18 {
19 
20  namespace Alberta
21  {
22 
23  // External Forward Declarations
24  // -----------------------------
25 
26  template< int dim >
27  class MeshPointer;
28 
29 
30 
31  // DofAccess
32  // ---------
33 
34  template< int dim, int codim >
35  class DofAccess
36  {
37  static const int codimtype = CodimType< dim, codim >::value;
38 
39  public:
41 
42  static const int dimension = dim;
43  static const int codimension = codim;
44 
46 
48  : node_( -1 )
49  {}
50 
51  explicit DofAccess ( const DofSpace *dofSpace )
52  {
53  assert( dofSpace );
54  node_ = dofSpace->admin->mesh->node[ codimtype ];
55  index_ = dofSpace->admin->n0_dof[ codimtype ];
56  }
57 
58  int operator() ( const Element *element, int subEntity, int i ) const
59  {
60  assert( element );
61  assert( node_ != -1 );
62  assert( subEntity < numSubEntities );
63  return element->dof[ node_ + subEntity ][ index_ + i ];
64  }
65 
66  int operator() ( const Element *element, int subEntity ) const
67  {
68  return (*this)( element, subEntity, 0 );
69  }
70 
71  int operator() ( const ElementInfo &elementInfo, int subEntity, int i ) const
72  {
73  return (*this)( elementInfo.el(), subEntity, i );
74  }
75 
76  int operator() ( const ElementInfo &elementInfo, int subEntity ) const
77  {
78  return (*this)( elementInfo.el(), subEntity );
79  }
80 
81  private:
82  int node_;
83  int index_;
84  };
85 
86 
87 
88  // HierarchyDofNumbering
89  // ---------------------
90 
91  template< int dim >
93  {
95 
96  public:
97  static const int dimension = dim;
98 
101 
102  private:
103  static const int nNodeTypes = N_NODE_TYPES;
104 
105  template< int codim >
106  struct CreateDofSpace;
107 
108  template< int codim >
109  struct CacheDofSpace;
110 
111  typedef std::pair< int, int > Cache;
112 
113  public:
115  {}
116 
117  private:
118  HierarchyDofNumbering ( const This & );
119  This &operator= ( const This & );
120 
121  public:
123  {
124  release();
125  }
126 
127  int operator() ( const Element *element, int codim, unsigned int subEntity ) const
128  {
129  assert( !(*this) == false );
130  assert( (codim >= 0) && (codim <= dimension) );
131  const Cache &cache = cache_[ codim ];
132  return element->dof[ cache.first + subEntity ][ cache.second ];
133  }
134 
135  int operator() ( const ElementInfo &element, int codim, unsigned int subEntity ) const
136  {
137  return (*this)( element.el(), codim, subEntity );
138  }
139 
140  explicit operator bool () const
141  {
142  return (bool)mesh_;
143  }
144 
145  const DofSpace *dofSpace ( int codim ) const
146  {
147  assert( *this );
148  assert( (codim >= 0) && (codim <= dimension) );
149  return dofSpace_[ codim ];
150  }
151 
152  const DofSpace *emptyDofSpace () const
153  {
154  assert( *this );
155  return emptySpace_;
156  }
157 
158  const MeshPointer &mesh () const
159  {
160  return mesh_;
161  }
162 
163  int size ( int codim ) const
164  {
165  return dofSpace( codim )->admin->size;
166  }
167 
168  void create ( const MeshPointer &mesh );
169 
170  void release ()
171  {
172  if( *this )
173  {
174  for( int codim = 0; codim <= dimension; ++codim )
175  freeDofSpace( dofSpace_[ codim ] );
176  freeDofSpace( emptySpace_ );
177  mesh_ = MeshPointer();
178  }
179  }
180 
181  private:
182  static const DofSpace *createEmptyDofSpace ( const MeshPointer &mesh );
183  static const DofSpace *createDofSpace ( const MeshPointer &mesh,
184  const std::string &name,
185  const int (&ndof)[ nNodeTypes ],
186  const bool periodic = false );
187  static void freeDofSpace ( const DofSpace *dofSpace );
188 
189  MeshPointer mesh_;
190  const DofSpace *emptySpace_;
191  const DofSpace *dofSpace_[ dimension+1 ];
192  Cache cache_[ dimension+1 ];
193  };
194 
195 
196 
197  template< int dim >
198  inline void
200  {
201  release();
202 
203  if( !mesh )
204  return;
205 
206  mesh_ = mesh;
207 
208  Hybrid::forEach( std::make_index_sequence< dimension+1 >{}, [ & ]( auto i ){ CreateDofSpace< i >::apply( mesh_, dofSpace_ ); } );
209  Hybrid::forEach( std::make_index_sequence< dimension+1 >{}, [ & ]( auto i ){ CacheDofSpace< i >::apply( dofSpace_, cache_ ); } );
210 
211  emptySpace_ = createEmptyDofSpace( mesh_ );
212  for( int i = 0; i < nNodeTypes; ++i )
213  assert( emptySpace_->admin->n_dof[ i ] == 0 );
214  }
215 
216 
217 
218  template< int dim >
219  inline const DofSpace *
221  {
222  int ndof[ nNodeTypes ];
223  for( int i = 0; i < nNodeTypes; ++i )
224  ndof[ i ] = 0;
225  std::string name = "Empty";
226  return createDofSpace( mesh, name, ndof );
227  }
228 
229 
230  template< int dim >
231  inline const DofSpace *
232  HierarchyDofNumbering< dim >::createDofSpace ( const MeshPointer &mesh,
233  const std::string &name,
234  const int (&ndof)[ nNodeTypes ],
235  const bool periodic )
236  {
237  const ALBERTA FLAGS flags
238  = ADM_PRESERVE_COARSE_DOFS | (periodic ? ADM_PERIODIC : 0);
239  return ALBERTA get_dof_space ( mesh, name.c_str(), ndof, flags );
240  }
241 
242 
243  template< int dim >
244  inline void
245  HierarchyDofNumbering< dim >::freeDofSpace ( const DofSpace *dofSpace )
246  {
247  ALBERTA free_fe_space( dofSpace );
248  }
249 
250 
251 
252  // HierarchyDofNumbering::CreateDofSpace
253  // -------------------------------------
254 
255  template< int dim >
256  template< int codim >
257  struct HierarchyDofNumbering< dim >::CreateDofSpace
258  {
259  static void apply ( const MeshPointer &mesh, const DofSpace *(&dofSpace)[ dim+1 ] )
260  {
261  int ndof[ nNodeTypes ];
262  for( int i = 0; i < nNodeTypes; ++i )
263  ndof[ i ] = 0;
264  ndof[ CodimType< dim, codim >::value ] = 1;
265 
266  std::string name = "Codimension ";
267  name += (char)(codim + '0');
268 
269  dofSpace[ codim ] = createDofSpace( mesh, name, ndof );
270  assert( dofSpace[ codim ] );
271  }
272  };
273 
274 
275 
276  // HierarchyDofNumbering::CacheDofSpace
277  // ------------------------------------
278 
279  template< int dim >
280  template< int codim >
281  struct HierarchyDofNumbering< dim >::CacheDofSpace
282  {
283  static void apply ( const DofSpace *(&dofSpace)[ dim+1 ], Cache (&cache)[ dim+1 ] )
284  {
285  assert( dofSpace[ codim ] );
286  const int codimtype = CodimType< dim, codim >::value;
287  cache[ codim ].first = dofSpace[ codim ]->mesh->node[ codimtype ];
288  cache[ codim ].second = dofSpace[ codim ]->admin->n0_dof[ codimtype ];
289  }
290  };
291 
292  } // namespace Alberta
293 
294 } // namespace Dune
295 
296 #endif // #if HAVE_ALBERTA
297 
298 #endif // #ifndef DUNE_ALBERTA_DOFADMIN_HH
#define ALBERTA
Definition: albertaheader.hh:29
provides a wrapper for ALBERTA's el_info structure
Include standard header files.
Definition: agrid.hh:60
ALBERTA EL Element
Definition: misc.hh:54
ALBERTA FE_SPACE DofSpace
Definition: misc.hh:65
Definition: dofadmin.hh:36
static const int dimension
Definition: dofadmin.hh:42
DofAccess()
Definition: dofadmin.hh:47
static const int codimension
Definition: dofadmin.hh:43
static const int numSubEntities
Definition: dofadmin.hh:40
DofAccess(const DofSpace *dofSpace)
Definition: dofadmin.hh:51
int operator()(const Element *element, int subEntity, int i) const
Definition: dofadmin.hh:58
Alberta::ElementInfo< dimension > ElementInfo
Definition: dofadmin.hh:45
Definition: dofadmin.hh:93
HierarchyDofNumbering()
Definition: dofadmin.hh:114
int operator()(const Element *element, int codim, unsigned int subEntity) const
Definition: dofadmin.hh:127
void create(const MeshPointer &mesh)
Definition: dofadmin.hh:199
const DofSpace * dofSpace(int codim) const
Definition: dofadmin.hh:145
~HierarchyDofNumbering()
Definition: dofadmin.hh:122
Alberta::MeshPointer< dimension > MeshPointer
Definition: dofadmin.hh:99
int size(int codim) const
Definition: dofadmin.hh:163
const DofSpace * emptyDofSpace() const
Definition: dofadmin.hh:152
const MeshPointer & mesh() const
Definition: dofadmin.hh:158
Alberta::ElementInfo< dimension > ElementInfo
Definition: dofadmin.hh:100
static const int dimension
Definition: dofadmin.hh:97
void release()
Definition: dofadmin.hh:170
Element * el() const
Definition: elementinfo.hh:737
Definition: misc.hh:148
Definition: misc.hh:192