DUNE-FEM (unstable)

referenceelements.hh
1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2// vi: set et ts=4 sw=2 sts=2:
3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
4// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
5#ifndef DUNE_GEOMETRY_REFERENCEELEMENTS_HH
6#define DUNE_GEOMETRY_REFERENCEELEMENTS_HH
7
8#include <cassert>
9
10#include <algorithm>
11#include <limits>
12#include <tuple>
13#include <utility>
14#include <vector>
15#include <array>
16
18#include <dune/common/std/type_traits.hh>
20
21#include <dune/geometry/dimension.hh>
22#include <dune/geometry/type.hh>
23#include <dune/geometry/referenceelement.hh>
24#include <dune/geometry/referenceelementimplementation.hh>
25
26namespace Dune
27{
28
29 namespace Geo
30 {
31
32#ifndef DOXYGEN
33
34
35 namespace Impl
36 {
37
38 // ReferenceElementContainer
39 // -------------------------
40
41 template< class ctype, int dim >
42 class ReferenceElementContainer
43 {
44 static const unsigned int numTopologies = dim >= 0 ? (1u << dim) : 0;
45
46 using Implementation = ReferenceElementImplementation< ctype, dim >;
47
48 public:
49
50 using ReferenceElement = Dune::Geo::ReferenceElement< Implementation >;
51 using value_type = ReferenceElement;
52 using const_iterator = const value_type*;
53
54 ReferenceElementContainer ()
55 {
56 for( unsigned int topologyId = 0; topologyId < numTopologies; ++topologyId )
57 {
58 implementations_[ topologyId ].initialize( topologyId );
59 reference_elements_[ topologyId ].setImplementation( implementations_[ topologyId ] );
60 }
61 }
62
63 const ReferenceElement& operator() ( const GeometryType &type ) const
64 {
65 assert( type.dim() == dim );
66 return reference_elements_[ type.id() ];
67 }
68
69 const ReferenceElement& simplex () const
70 {
71 return reference_elements_[ Dune::GeometryTypes::simplex(dim).id() ];
72 }
73
74 const ReferenceElement& cube () const
75 {
76 return reference_elements_[ Dune::GeometryTypes::cube(dim).id() ];
77 }
78
79 const ReferenceElement& pyramid () const
80 {
81 return reference_elements_[ Dune::GeometryTypes::pyramid.id() ];
82 }
83
84 const ReferenceElement& prism () const
85 {
86 return reference_elements_[ Dune::GeometryTypes::prism.id() ];
87 }
88
89 const_iterator begin () const
90 {
91 return reference_elements_.data();
92 }
93
94 const_iterator end () const
95 {
96 return reference_elements_.data() + numTopologies;
97 }
98
99 private:
100
101 std::array<Implementation,numTopologies> implementations_;
102 std::array<ReferenceElement,numTopologies> reference_elements_;
103
104 };
105
106
107 } // namespace Impl
108
109
110#endif // DOXYGEN
111
112
113 // ReferenceElements
114 // ------------------------
115
126 template< class ctype_, int dim >
128 {
129
131 using ctype = ctype_;
132
135
137 static constexpr int dimension = dim;
138
139 private:
140
141 using Container = Impl::ReferenceElementContainer< ctype, dim >;
142
143 public:
144
146 using ReferenceElement = typename Container::ReferenceElement;
147
149 using Iterator = typename Container::const_iterator;
150
153
155 static const ReferenceElement&
156 general ( const GeometryType& type )
157 {
158 return container() ( type );
159 }
160
162 static const ReferenceElement& simplex ()
163 {
164 return container().simplex();
165 }
166
168 static const ReferenceElement& cube ()
169 {
170 return container().cube();
171 }
172
173 static Iterator begin ()
174 {
175 return container().begin();
176 }
177
178 static Iterator end ()
179 {
180 return container().end();
181 }
182
183 private:
184
185 DUNE_EXPORT static const Container& container ()
186 {
187 static Container container;
188 return container;
189 }
190 };
191
192 } // namespace Geo
193
195 using Geo::ReferenceElements;
196
197
198#ifdef DOXYGEN
199
201
244 template<typename... T>
245 unspecified-value-type referenceElement(T&&... t);
246
247#endif
248
249
251
264 template<typename T, int dim>
266 {
268 }
269
270
272
284 template<typename T, int dim, std::enable_if_t<IsNumber<std::decay_t<T>>::value, int> = 0>
286 {
288 }
289
290
291#ifndef DOXYGEN
292
293 // helpers for the ReferenceElement<> meta function
294 // the complete Impl block can be removed together with deprecated Transitional::ReferenceElement
295
296 namespace Impl {
297
298 // Evaluates to the correct reference element iff <T...> matches the pattern <number_type,Dim<int>>
299 // otherwise, it's ill-formed. Should be used with detected_or and friends.
300
301 template<typename... T>
302 struct DefaultReferenceElementExtractor;
303
304 template<typename T, typename std::enable_if<IsNumber<T>::value,int>::type dim>
305 struct DefaultReferenceElementExtractor<T,Dim<dim>>
306 {
308 };
309
310 template<typename... T>
311 using DefaultReferenceElement = typename DefaultReferenceElementExtractor<T...>::type;
312
313 }
314
315 // looks up the type of a reference element by trying to instantiate the correct overload
316 // of referenceElement() for the given arguments. This will fail if there is no valid
317 // overload and should be used with detected_or or some other utility that places the
318 // instantiation in SFINAE context.
319 //
320 // this is placed directly in namespace Dune to avoid any weird surprises
321
322 template<typename... T>
323 using LookupReferenceElement = decltype(referenceElement(std::declval<T>()...));
324
325#endif // DOXYGEN
326
327 namespace [[deprecated]] Transitional {
328
329 // this abomination checks whether the template signature matches the special case
330 // ReferenceElement<number_type,Dune::Dim<int>> and otherwise defers the type lookup
331 // to a decltype on a call to referenceElement(std::declval<T>())
332
337 template<typename... T>
338 using ReferenceElement = detected_or_fallback_t<
339 Impl::DefaultReferenceElement,
340 LookupReferenceElement,
341 T...
342 >;
343
344 }
345
346 template<typename... T>
347 using ReferenceElement = decltype(referenceElement(std::declval<T>()...));
348
349} // namespace Dune
350
351#endif // #ifndef DUNE_GEOMETRY_REFERENCEELEMENTS_HH
This class provides access to geometric and topological properties of a reference element.
Definition: referenceelement.hh:52
Unique label for each type of entities that can occur in DUNE grids.
Definition: type.hh:114
constexpr unsigned int id() const
Return the topology id of the type.
Definition: type.hh:365
bool gt(const T &first, const T &second, typename EpsilonType< T >::Type epsilon)
test if first greater than second
Definition: float_cmp.cc:158
unspecified value type referenceElement(T &&... t)
Returns a reference element for the objects t....
constexpr GeometryType cube(unsigned int dim)
Returns a GeometryType representing a hypercube of dimension dim.
Definition: type.hh:462
constexpr GeometryType prism
GeometryType representing a 3D prism.
Definition: type.hh:528
constexpr GeometryType pyramid
GeometryType representing a 3D pyramid.
Definition: type.hh:522
constexpr GeometryType simplex(unsigned int dim)
Returns a GeometryType representing a simplex of dimension dim.
Definition: type.hh:453
Dune namespace.
Definition: alignedallocator.hh:13
Std::detected_or_t< decltype(detail::warningIfNotDefined< Std::detected_t< Fallback, Args... > >(std::declval< const Std::detected_t< TargetType, Args... > * >())), TargetType, Args... > detected_or_fallback_t
This type will be either TargetType<Args...> if it exists, or the Fallback<Args......
Definition: type_traits.hh:255
Static tag representing a dimension.
Definition: dimension.hh:16
Class providing access to the singletons of the reference elements.
Definition: referenceelements.hh:128
Iterator iterator
Iterator over available reference elements.
Definition: referenceelements.hh:152
typename Container::ReferenceElement ReferenceElement
The reference element type.
Definition: referenceelements.hh:146
static const ReferenceElement & cube()
get hypercube reference elements
Definition: referenceelements.hh:168
ctype_ ctype
The coordinate field type of the contained reference elements.
Definition: referenceelements.hh:131
static const ReferenceElement & general(const GeometryType &type)
get general reference elements
Definition: referenceelements.hh:156
static const ReferenceElement & simplex()
get simplex reference elements
Definition: referenceelements.hh:162
typename Container::const_iterator Iterator
Iterator over available reference elements.
Definition: referenceelements.hh:149
static constexpr int dimension
The dimension of the contained reference elements.
Definition: referenceelements.hh:137
ctype CoordinateField
The coordinate field type of the contained reference elements.
Definition: referenceelements.hh:134
A unique label for each type of element that can occur in a grid.
Traits for type conversions and type information.
Definition of macros controlling symbol visibility at the ABI level.
#define DUNE_EXPORT
Export a symbol as part of the public ABI.
Definition: visibility.hh:20
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.111.3 (Nov 12, 23:30, 2024)