│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
5#ifndef DUNE_LOCALFUNCTIONS_NEDELEC_NEDELEC1STKINDCUBE_HH
│ │ │ │ -
6#define DUNE_LOCALFUNCTIONS_NEDELEC_NEDELEC1STKINDCUBE_HH
│ │ │ │ +
5#ifndef DUNE_RANNACHER_TUREK_3D_LOCALBASIS_HH
│ │ │ │ +
6#define DUNE_RANNACHER_TUREK_3D_LOCALBASIS_HH
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
10#include <dune/common/fmatrix.hh>
│ │ │ │ +
│ │ │ │ +
│ │ │ │
11#include <dune/common/fvector.hh>
│ │ │ │ -
12#include <dune/common/math.hh>
│ │ │ │ +
12#include <dune/common/fmatrix.hh>
│ │ │ │
│ │ │ │ -
14#include <dune/geometry/referenceelements.hh>
│ │ │ │ -
15#include <dune/geometry/type.hh>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
37 template<
class D,
class R,
int dim,
int k>
│ │ │ │ -
38 class Nedelec1stKindCubeLocalBasis
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
41 constexpr static std::size_t numberOfEdges = power(2,dim-1)*dim;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
44 using Traits = LocalBasisTraits<D,dim,FieldVector<D,dim>,
│ │ │ │ -
45 R,dim,FieldVector<R,dim>,
│ │ │ │ -
46 FieldMatrix<R,dim,dim> >;
│ │ │ │ -
│ │ │ │ -
54 Nedelec1stKindCubeLocalBasis()
│ │ │ │ -
│ │ │ │ -
56 std::fill(edgeOrientation_.begin(), edgeOrientation_.end(), 1.0);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
61 Nedelec1stKindCubeLocalBasis(std::bitset<numberOfEdges> edgeOrientation)
│ │ │ │ -
62 : Nedelec1stKindCubeLocalBasis()
│ │ │ │ -
│ │ │ │ -
64 for (std::size_t i=0; i<edgeOrientation_.size(); i++)
│ │ │ │ -
65 edgeOrientation_[i] *= edgeOrientation[i] ? -1.0 : 1.0;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
69 static constexpr unsigned int size()
│ │ │ │ -
│ │ │ │ -
71 static_assert(dim==2 || dim==3,
"Nedelec shape functions are implemented only for 2d and 3d cubes.");
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
75 return 3*k * (k+1) * (k+1);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
84 std::vector<typename Traits::RangeType>& out)
const
│ │ │ │ -
│ │ │ │ -
86 static_assert(k==1,
"Evaluating Nédélec shape functions is implemented only for first order.");
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
103 out[0] = { 0, D(1) - in[0]};
│ │ │ │ -
104 out[1] = { 0, in[0]};
│ │ │ │ -
105 out[2] = { D(1) - in[1], 0};
│ │ │ │ -
106 out[3] = { in[1], 0};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
109 if constexpr (dim==3)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
22 template<
class D,
class R >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
25 static const int coefficients[ 6 ][ 6 ];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
29 R, 1, FieldVector< R, 1 >,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
40 std::vector< typename Traits::RangeType > &out )
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
43 RangeFieldType y[ 6 ] = { 1, in[ 0 ], in[ 1 ], in[ 2 ],
│ │ │ │ +
44 in[ 0 ]*in[ 0 ] - in[ 1 ]*in[ 1 ],
│ │ │ │ +
45 in[ 1 ]*in[ 1 ] - in[ 2 ]*in[ 2 ] };
│ │ │ │ +
│ │ │ │ +
47 for(
unsigned int i = 0; i <
size(); ++i )
│ │ │ │ +
│ │ │ │ +
49 out[ i ] = RangeFieldType( 0 );
│ │ │ │ +
50 for(
unsigned int j = 0; j < 6; ++j )
│ │ │ │ +
51 out[ i ] += coefficients[ i ][ j ]*y[ j ];
│ │ │ │ +
52 out[ i ] /= RangeFieldType( 3 );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
58 std::vector< typename Traits::JacobianType > &out )
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
61 RangeFieldType y0[ 5 ] = { 1, 0, 0, 2*in[ 0 ], 0 };
│ │ │ │ +
62 RangeFieldType y1[ 5 ] = { 0, 1, 0, -2*in[ 1 ], 2*in[ 1 ] };
│ │ │ │ +
63 RangeFieldType y2[ 5 ] = { 0, 0, 1, 0, -2*in[ 2 ] };
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
66 for(
unsigned int i = 0; i <
size(); ++i )
│ │ │ │ +
│ │ │ │ +
68 out[ i ] = RangeFieldType( 0 );
│ │ │ │ +
69 for(
unsigned int j = 0; j < 5; ++j )
│ │ │ │ +
│ │ │ │ +
71 out[ i ][ 0 ][ 0 ] += coefficients[ i ][ j+1 ]*y0[ j ];
│ │ │ │ +
72 out[ i ][ 0 ][ 1 ] += coefficients[ i ][ j+1 ]*y1[ j ];
│ │ │ │ +
73 out[ i ][ 0 ][ 2 ] += coefficients[ i ][ j+1 ]*y2[ j ];
│ │ │ │ +
│ │ │ │ +
75 out[ i ] /= RangeFieldType( 3 );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
82 std::vector<typename Traits::RangeType>& out)
const
│ │ │ │ +
│ │ │ │ +
84 auto totalOrder = std::accumulate(
order.begin(),
order.end(), 0);
│ │ │ │ +
85 if (totalOrder == 0) {
│ │ │ │ +
│ │ │ │ +
87 }
else if (totalOrder == 1) {
│ │ │ │ +
│ │ │ │ +
89 auto const direction = std::distance(
order.begin(), std::find(
order.begin(),
order.end(), 1));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
92 RangeFieldType y[3][5] = { { 1.0, 0.0, 0.0, 2*in[0], 0.0 },
│ │ │ │ +
93 { 0.0, 1.0, 0.0, -2*in[1], 2*in[1] },
│ │ │ │ +
94 { 0.0, 0.0, 1.0, 0.0, -2*in[2] } };
│ │ │ │ +
│ │ │ │ +
96 for (std::size_t i = 0; i <
size(); ++i) {
│ │ │ │ +
97 out[i] = RangeFieldType{0};
│ │ │ │ +
98 for (std::size_t j = 0; j < 5; ++j)
│ │ │ │ +
99 out[i] += coefficients[i][j+1] * y[direction][j];
│ │ │ │ +
100 out[i] /= RangeFieldType{3};
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
103 DUNE_THROW(NotImplemented,
"Desired derivative order is not implemented");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
119 template<
class D,
class R >
│ │ │ │ +
120 const int RannacherTurek3DLocalBasis< D, R >
│ │ │ │ +
121 ::coefficients[ 6 ][ 6 ] = {{ 2, -7, 2, 2, 4, 2 },
│ │ │ │ +
122 { -1, -1, 2, 2, 4, 2 },
│ │ │ │ +
123 { 2, 2, -7, 2, -2, 2 },
│ │ │ │ +
124 { -1, 2, -1, 2, -2, 2 },
│ │ │ │ +
125 { 2, 2, 2, -7, -2, -4 },
│ │ │ │ +
126 { -1, 2, 2, -1, -2, -4 }};
│ │ │ │
│ │ │ │ -
128 for (std::size_t i=0; i<out.size(); i++)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
131 out[0][2] = { 1 - in[0] - in[1] + in[0]*in[1]};
│ │ │ │ -
132 out[1][2] = { in[0] - in[0]*in[1]};
│ │ │ │ -
133 out[2][2] = { in[1] - in[0]*in[1]};
│ │ │ │ -
134 out[3][2] = { in[0]*in[1]};
│ │ │ │ -
│ │ │ │ -
136 out[4][1] = { 1 - in[0] - in[2] + in[0]*in[2]};
│ │ │ │ -
137 out[5][1] = { in[0] - in[0]*in[2]};
│ │ │ │ -
138 out[8][1] = { in[2] - in[0]*in[2]};
│ │ │ │ -
139 out[9][1] = { in[0]*in[2]};
│ │ │ │ -
│ │ │ │ -
141 out[6][0] = { 1 - in[1] - in[2] + in[1]*in[2]};
│ │ │ │ -
142 out[7][0] = { in[1] - in[1]*in[2]};
│ │ │ │ -
143 out[10][0] = { in[2] - in[1]*in[2]};
│ │ │ │ -
144 out[11][0] = { in[1]*in[2]};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
147 for (std::size_t i=0; i<out.size(); i++)
│ │ │ │ -
148 out[i] *= edgeOrientation_[i];
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
157 std::vector<typename Traits::JacobianType>& out)
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
162 for (std::size_t i=0; i<out.size(); i++)
│ │ │ │ -
163 for (std::size_t j=0; j<dim; j++)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
166 out[0][1] = { -1, 0};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
169 out[2][0] = { 0, -1};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
174 for (std::size_t i=0; i<out.size(); i++)
│ │ │ │ -
175 for(std::size_t j=0;j<dim; j++)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
179 out[0][2] = {-1 +in[1], -1 + in[0], 0};
│ │ │ │ -
180 out[1][2] = { 1 -in[1], - in[0], 0};
│ │ │ │ -
181 out[2][2] = { -in[1], 1 - in[0], 0};
│ │ │ │ -
182 out[3][2] = { in[1], in[0], 0};
│ │ │ │ -
│ │ │ │ -
184 out[4][1] = {-1 +in[2], 0, -1 + in[0]};
│ │ │ │ -
185 out[5][1] = { 1 -in[2], 0, - in[0]};
│ │ │ │ -
186 out[8][1] = { -in[2], 0, 1 - in[0]};
│ │ │ │ -
187 out[9][1] = { in[2], 0, in[0]};
│ │ │ │ -
│ │ │ │ -
189 out[6][0] = { 0, -1 + in[2], -1 + in[1]};
│ │ │ │ -
190 out[7][0] = { 0, 1 - in[2], - in[1]};
│ │ │ │ -
191 out[10][0] = { 0, - in[2], 1 - in[1]};
│ │ │ │ -
192 out[11][0] = { 0, in[2], in[1]};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
196 for (std::size_t i=0; i<out.size(); i++)
│ │ │ │ -
197 out[i] *= edgeOrientation_[i];
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
207 void partial(
const std::array<unsigned int, dim>& order,
│ │ │ │ -
│ │ │ │ -
209 std::vector<typename Traits::RangeType>& out)
const
│ │ │ │ -
│ │ │ │ -
211 auto totalOrder = std::accumulate(order.begin(), order.end(), 0);
│ │ │ │ -
212 if (totalOrder == 0) {
│ │ │ │ -
213 evaluateFunction(in, out);
│ │ │ │ -
214 }
else if (totalOrder == 1) {
│ │ │ │ -
215 auto const direction = std::distance(order.begin(), std::find(order.begin(), order.end(), 1));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
241 out[0] = { 0, 0, -1 +in[1]};
│ │ │ │ -
242 out[1] = { 0, 0, 1 -in[1]};
│ │ │ │ -
243 out[2] = { 0, 0, -in[1]};
│ │ │ │ -
244 out[3] = { 0, 0, in[1]};
│ │ │ │ -
│ │ │ │ -
246 out[4] = { 0, -1 +in[2], 0};
│ │ │ │ -
247 out[5] = { 0, 1 -in[2], 0};
│ │ │ │ -
248 out[8] = { 0, -in[2], 0};
│ │ │ │ -
249 out[9] = { 0, in[2], 0};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
258 out[0] = { 0, 0, -1 + in[0]};
│ │ │ │ -
259 out[1] = { 0, 0, - in[0]};
│ │ │ │ -
260 out[2] = { 0, 0, 1 - in[0]};
│ │ │ │ -
261 out[3] = { 0, 0, in[0]};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
268 out[6] = { -1 + in[2], 0, 0};
│ │ │ │ -
269 out[7] = { 1 - in[2], 0, 0};
│ │ │ │ -
270 out[10] = { - in[2], 0, 0};
│ │ │ │ -
271 out[11] = { in[2], 0, 0};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
280 out[4] = { 0, -1 + in[0], 0};
│ │ │ │ -
281 out[5] = { 0, - in[0], 0};
│ │ │ │ -
282 out[8] = { 0, 1 - in[0], 0};
│ │ │ │ -
283 out[9] = { 0, in[0], 0};
│ │ │ │ -
│ │ │ │ -
285 out[6] = { -1 + in[1], 0, 0};
│ │ │ │ -
286 out[7] = { - in[1], 0, 0};
│ │ │ │ -
287 out[10] = { 1 - in[1], 0, 0};
│ │ │ │ -
288 out[11] = { in[1], 0, 0};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
293 for (std::size_t i=0; i<out.size(); i++)
│ │ │ │ -
294 out[i] *= edgeOrientation_[i];
│ │ │ │ -
│ │ │ │ -
296 }
else if (totalOrder == 2) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
300 for (std::size_t i = 0; i < size(); ++i)
│ │ │ │ -
301 for (std::size_t j = 0; j < dim; ++j)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
306 for(
size_t i=0; i<out.size(); i++)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
310 if( order[0] == 1 and order[1]==1)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
313 out[1] = { 0, 0, -1};
│ │ │ │ -
314 out[2] = { 0, 0, -1};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
319 if( order[0] == 1 and order[2]==1)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
322 out[5] = { 0, -1, 0};
│ │ │ │ -
323 out[8] = { 0, -1, 0};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
328 if( order[1] == 1 and order[2]==1)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
331 out[7] = { -1, 0, 0};
│ │ │ │ -
332 out[10] = { -1, 0, 0};
│ │ │ │ -
333 out[11] = { 1, 0, 0};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
336 for (std::size_t i=0; i<out.size(); i++)
│ │ │ │ -
337 out[i] *= edgeOrientation_[i];
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
343 for (std::size_t i = 0; i < size(); ++i)
│ │ │ │ -
344 for (std::size_t j = 0; j < dim; ++j)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
351 unsigned int order()
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
362 std::array<R,numberOfEdges> edgeOrientation_;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
370 template <
int dim,
int k>
│ │ │ │ -
371 class Nedelec1stKindCubeLocalCoefficients
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
375 Nedelec1stKindCubeLocalCoefficients ()
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
378 static_assert(k==1,
"Only first-order Nédélec local coefficients are implemented.");
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
381 for (std::size_t i=0; i<size(); i++)
│ │ │ │ -
382 localKey_[i] = LocalKey(i,dim-1,0);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
386 std::size_t size()
const
│ │ │ │ -
│ │ │ │ -
388 static_assert(dim==2 || dim==3,
"Nédélec shape functions are implemented only for 2d and 3d cubes.");
│ │ │ │ -
389 return (dim==2) ? 2*k * (k+1)
│ │ │ │ -
390 : 3*k * (k+1) * (k+1);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
395 const LocalKey& localKey (std::size_t i)
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
401 std::vector<LocalKey> localKey_;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
409 class Nedelec1stKindCubeLocalInterpolation
│ │ │ │ -
│ │ │ │ -
411 static constexpr auto dim = LB::Traits::dimDomain;
│ │ │ │ -
412 static constexpr auto size = LB::size();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
415 constexpr static std::size_t numberOfEdges = power(2,dim-1)*dim;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
420 Nedelec1stKindCubeLocalInterpolation (std::bitset<numberOfEdges> s = 0)
│ │ │ │ -
│ │ │ │ -
422 auto refElement = Dune::referenceElement<double,dim>(GeometryTypes::cube(dim));
│ │ │ │ -
│ │ │ │ -
424 for (std::size_t i=0; i<numberOfEdges; i++)
│ │ │ │ -
425 m_[i] = refElement.position(i,dim-1);
│ │ │ │ -
│ │ │ │ -
427 for (std::size_t i=0; i<numberOfEdges; i++)
│ │ │ │ -
│ │ │ │ -
429 auto vertexIterator = refElement.subEntities(i,dim-1,dim).begin();
│ │ │ │ -
430 auto v0 = *vertexIterator;
│ │ │ │ -
431 auto v1 = *(++vertexIterator);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
437 edge_[i] = refElement.position(v1,dim) - refElement.position(v0,dim);
│ │ │ │ -
438 edge_[i] *= (s[i]) ? -1.0 : 1.0;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
447 template<
typename F,
typename C>
│ │ │ │ -
448 void interpolate (
const F& f, std::vector<C>& out)
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
452 for (std::size_t i=0; i<size; i++)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
456 for (
int j=0; j<dim; j++)
│ │ │ │ -
457 out[i] += y[j]*edge_[i][j];
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
463 std::array<typename LB::Traits::DomainType, numberOfEdges> m_;
│ │ │ │ -
│ │ │ │ -
465 std::array<typename LB::Traits::DomainType, numberOfEdges> edge_;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
494 template<
class D,
class R,
int dim,
int k>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
499 Impl::Nedelec1stKindCubeLocalCoefficients<dim,k>,
│ │ │ │ -
500 Impl::Nedelec1stKindCubeLocalInterpolation<Impl::Nedelec1stKindCubeLocalBasis<D,R,dim,k> > >;
│ │ │ │ -
│ │ │ │ -
502 static_assert(dim==2 || dim==3,
"Nedelec elements are only implemented for 2d and 3d elements.");
│ │ │ │ -
503 static_assert(k==1,
"Nedelec elements of the first kind are currently only implemented for order k==1.");
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
526 return coefficients_;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
531 return interpolation_;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
534 static constexpr unsigned int size ()
│ │ │ │ -
│ │ │ │ -
536 return Traits::LocalBasisType::size();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
539 static constexpr GeometryType
type ()
│ │ │ │ -
│ │ │ │ -
541 return GeometryTypes::cube(dim);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
Definition bdfmcube.hh:18
│ │ │ │ +
Type traits for LocalBasisVirtualInterface.
Definition common/localbasis.hh:35
│ │ │ │
D DomainType
domain type
Definition common/localbasis.hh:43
│ │ │ │ -
traits helper struct
Definition localfiniteelementtraits.hh:13
│ │ │ │ -
LB LocalBasisType
Definition localfiniteelementtraits.hh:16
│ │ │ │ -
LC LocalCoefficientsType
Definition localfiniteelementtraits.hh:20
│ │ │ │ -
LI LocalInterpolationType
Definition localfiniteelementtraits.hh:24
│ │ │ │ -
Nédélec elements of the first kind for cube elements.
Definition nedelec1stkindcube.hh:496
│ │ │ │ -
const Traits::LocalInterpolationType & localInterpolation() const
Definition nedelec1stkindcube.hh:529
│ │ │ │ -
static constexpr unsigned int size()
Definition nedelec1stkindcube.hh:534
│ │ │ │ -
Nedelec1stKindCubeLocalFiniteElement()=default
Default constructor.
│ │ │ │ -
static constexpr GeometryType type()
Definition nedelec1stkindcube.hh:539
│ │ │ │ -
const Traits::LocalCoefficientsType & localCoefficients() const
Definition nedelec1stkindcube.hh:524
│ │ │ │ -
const Traits::LocalBasisType & localBasis() const
Definition nedelec1stkindcube.hh:519
│ │ │ │ -
Nedelec1stKindCubeLocalFiniteElement(std::bitset< power(2, dim-1) *dim > s)
Constructor with explicitly given edge orientations.
Definition nedelec1stkindcube.hh:514
│ │ │ │ +
RF RangeFieldType
Export type for range field.
Definition common/localbasis.hh:46
│ │ │ │ +
Definition rannacherturek3dlocalbasis.hh:24
│ │ │ │ +
LocalBasisTraits< D, 3, FieldVector< D, 3 >, R, 1, FieldVector< R, 1 >, FieldMatrix< R, 1, 3 > > Traits
Definition rannacherturek3dlocalbasis.hh:30
│ │ │ │ +
void evaluateFunction(const typename Traits::DomainType &in, std::vector< typename Traits::RangeType > &out) const
evaluate all shape functions
Definition rannacherturek3dlocalbasis.hh:39
│ │ │ │ +
unsigned int size() const
number of shape functions
Definition rannacherturek3dlocalbasis.hh:33
│ │ │ │ +
void evaluateJacobian(const typename Traits::DomainType &in, std::vector< typename Traits::JacobianType > &out) const
evaluate jacobian of all shape functions
Definition rannacherturek3dlocalbasis.hh:57
│ │ │ │ +
unsigned int order() const
polynomial order of the shape functions
Definition rannacherturek3dlocalbasis.hh:108
│ │ │ │ +
void partial(const std::array< unsigned int, 3 > &order, const typename Traits::DomainType &in, std::vector< typename Traits::RangeType > &out) const
Evaluate partial derivatives of all shape functions.
Definition rannacherturek3dlocalbasis.hh:80
│ │ │ │
│ │ │ │
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,26 +1,12 @@
│ │ │ │ │ dune-localfunctions 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _l_o_c_a_l_f_u_n_c_t_i_o_n_s
│ │ │ │ │ - * _r_e_f_i_n_e_d
│ │ │ │ │ - * _r_e_f_i_n_e_d_p_0
│ │ │ │ │ -_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ -refinedp0localbasis.hh File Reference
│ │ │ │ │ -#include