│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
5#ifndef DUNE_LOCALFUNCTIONS_BREZZIDOUGLASFORTINMARINI_BDFMCUBE_HH
│ │ │ │ -
6#define DUNE_LOCALFUNCTIONS_BREZZIDOUGLASFORTINMARINI_BDFMCUBE_HH
│ │ │ │ +
5#ifndef DUNE_LOCALFUNCTIONS_LAGRANGE_LAGRANGEPYRAMID_HH
│ │ │ │ +
6#define DUNE_LOCALFUNCTIONS_LAGRANGE_LAGRANGEPYRAMID_HH
│ │ │ │
│ │ │ │ -
8#include <dune/geometry/type.hh>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
11#include <dune/common/fmatrix.hh>
│ │ │ │ +
12#include <dune/common/fvector.hh>
│ │ │ │ +
13#include <dune/common/math.hh>
│ │ │ │ +
│ │ │ │ +
15#include <dune/geometry/referenceelements.hh>
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
43 template<
class D,
class R,
unsigned int dim,
unsigned int order>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
62 : basis( s ), interpolation( s )
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
70 unsigned int size ()
const {
return basis.size(); }
│ │ │ │ -
71 static constexpr auto type () -> GeometryType {
return GeometryTypes::cube(dim); }
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
75 LocalCoefficients coefficients;
│ │ │ │ -
76 LocalInterpolation interpolation;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
22namespace Dune {
namespace Impl
│ │ │ │ +
│ │ │ │ +
33 template<
class D,
class R,
unsigned int k>
│ │ │ │ +
34 class LagrangePyramidLocalBasis
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
37 using Traits = LocalBasisTraits<D,3,FieldVector<D,3>,R,1,FieldVector<R,1>,FieldMatrix<R,1,3> >;
│ │ │ │ +
│ │ │ │ +
41 static constexpr std::size_t size ()
│ │ │ │ +
│ │ │ │ +
43 std::size_t result = 0;
│ │ │ │ +
44 for (
unsigned int i=0; i<=k; i++)
│ │ │ │ +
45 result += power(i+1,2);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
51 std::vector<typename Traits::RangeType>& out)
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
66 out[0] = (1-in[0])*(1-in[1])-in[2]*(1-in[1]);
│ │ │ │ +
67 out[1] = in[0]*(1-in[1])-in[2]*in[1];
│ │ │ │ +
68 out[2] = (1-in[0])*in[1]-in[2]*in[1];
│ │ │ │ +
69 out[3] = in[0]*in[1]+in[2]*in[1];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
73 out[0] = (1-in[0])*(1-in[1])-in[2]*(1-in[0]);
│ │ │ │ +
74 out[1] = in[0]*(1-in[1])-in[2]*in[0];
│ │ │ │ +
75 out[2] = (1-in[0])*in[1]-in[2]*in[0];
│ │ │ │ +
76 out[3] = in[0]*in[1]+in[2]*in[0];
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
87 const R x = 2.0*in[0] + in[2] - 1.0;
│ │ │ │ +
88 const R y = 2.0*in[1] + in[2] - 1.0;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
94 out[0] = 0.25*(x + z)*(x + z - 1)*(y - z - 1)*(y - z);
│ │ │ │ +
95 out[1] = -0.25*(x + z)*(y - z)*((x + z + 1)*(-y + z + 1) - 4*z) - z*(x - y);
│ │ │ │ +
96 out[2] = 0.25*(x + z)*(y - z)*(y - z + 1)*(x + z - 1);
│ │ │ │ +
97 out[3] = 0.25*(y - z)*(x + z)*(y - z + 1)*(x + z + 1);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
101 out[5] = -0.5*(y - z + 1)*(x + z - 1)*(y - 1)*x;
│ │ │ │ +
102 out[6] = -0.5*(y - z + 1)*(((x + z + 1)*(y - 1)*x - z) + z*(2*y + 1));
│ │ │ │ +
103 out[7] = -0.5*(x + z - 1)*(((y - z - 1)*(x + 1)*y - z) + z*(2*x + 1));
│ │ │ │ +
104 out[8] = -0.5*(y - z + 1)*(x + z - 1)*(x + 1)*y;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
107 out[9] = z*(x + z - 1)*(y - z - 1);
│ │ │ │ +
108 out[10] = -z*((x + z + 1)*(y - z - 1) + 4*z);
│ │ │ │ +
109 out[11] = -z*(y - z + 1)*(x + z - 1);
│ │ │ │ +
110 out[12] = z*(y - z + 1)*(x + z + 1);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
113 out[13] = (y - z + 1)*(x + z - 1)*((y - 1)*(x + 1) + z*(x - y + z + 1));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
118 out[0] = 0.25*(y + z)*(y + z - 1)*(x - z - 1)*(x - z);
│ │ │ │ +
119 out[1] = -0.25*(x - z)*(y + z)*(x - z + 1)*(-y - z + 1);
│ │ │ │ +
120 out[2] = 0.25*(x - z)*(y + z)*((x - z - 1)*(y + z + 1) + 4*z) + z*(x - y);
│ │ │ │ +
121 out[3] = 0.25*(y + z)*(x - z)*(x - z + 1)*(y + z + 1);
│ │ │ │ +
122 out[4] = z*(2*z - 1);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
125 out[5] = -0.5*(y + z - 1)*(((x - z - 1)*(y + 1)*x - z) + z*(2*y + 1));
│ │ │ │ +
126 out[6] = -0.5*(x - z + 1)*(y + z - 1)*(y + 1)*x;
│ │ │ │ +
127 out[7] = -0.5*(x - z + 1)*(y + z - 1)*(x - 1)*y;
│ │ │ │ +
128 out[8] = -0.5*(x - z + 1)*(((y + z + 1)*(x - 1)*y - z) + z*(2*x + 1));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
131 out[9] = z*(y + z - 1)*(x - z - 1);
│ │ │ │ +
132 out[10] = -z*(x - z + 1)*(y + z - 1);
│ │ │ │ +
133 out[11] = -z*((y + z + 1)*(x - z - 1) + 4*z);
│ │ │ │ +
134 out[12] = z*(x - z + 1)*(y + z + 1);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
137 out[13] = (x - z + 1)*(y + z - 1)*((y + 1)*(x - 1) - z*(x - y - z - 1));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
143 DUNE_THROW(NotImplemented,
"LagrangePyramidLocalBasis::evaluateFunction for order " << k);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
152 std::vector<typename Traits::JacobianType>& out)
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
159 std::fill(out[0][0].begin(), out[0][0].end(), 0);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
167 out[0][0] = {-1 + in[1], -1 + in[0] + in[2], -1 + in[1]};
│ │ │ │ +
168 out[1][0] = { 1 - in[1], -in[0] - in[2], -in[1]};
│ │ │ │ +
169 out[2][0] = { -in[1], 1 - in[0] - in[2], -in[1]};
│ │ │ │ +
170 out[3][0] = { in[1], in[0] + in[2], in[1]};
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
174 out[0][0] = {-1 + in[1] + in[2], -1 + in[0], -1 + in[0]};
│ │ │ │ +
175 out[1][0] = { 1 - in[1] - in[2], -in[0], -in[0]};
│ │ │ │ +
176 out[2][0] = { -in[1] - in[2], 1 - in[0], -in[0]};
│ │ │ │ +
177 out[3][0] = { in[1] + in[2], in[0], in[0]};
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
180 out[4][0] = {0, 0, 1};
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
187 const R x = 2.0*in[0] + in[2] - 1.0;
│ │ │ │ +
188 const R y = 2.0*in[1] + in[2] - 1.0;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
196 out[0][0][0] = 0.5*(y - z - 1)*(y - z)*(2*x + 2*z - 1);
│ │ │ │ +
197 out[0][0][1] = 0.5*(x + z)*(x + z - 1)*(2*y - 2*z - 1);
│ │ │ │ +
198 out[0][0][2] = 0.5*(out[0][0][0] + out[0][0][1])
│ │ │ │ +
199 + 0.25*((2*x + 2*z - 1)*(y - z - 1)*(y - z)
│ │ │ │ +
200 + (x + z)*(x + z - 1)*(-2*y + 2*z + 1));
│ │ │ │ +
│ │ │ │ +
202 out[1][0][0] = 2*(-0.25*((y - z)*((x + z + 1)*(-y + z + 1) - 4*z)
│ │ │ │ +
203 + (x + z)*(y - z)*(-y + z + 1)) - z);
│ │ │ │ +
204 out[1][0][1] = 2*(-0.25*((x + z)*((x + z + 1)*(-y + z + 1) - 4*z)
│ │ │ │ +
205 + (x + z)*(y - z)*(-(x + z + 1))) + z);
│ │ │ │ +
206 out[1][0][2] = 0.5*(out[1][0][0] + out[1][0][1])
│ │ │ │ +
207 - 0.25*((y - z)*((x + z + 1)*(-y + z + 1) - 4*z)
│ │ │ │ +
208 - (x + z)*((x + z + 1)*(-y + z + 1) - 4*z)
│ │ │ │ +
209 + (x + z)*(y - z)*(x - y + 2*z - 2))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
212 out[2][0][0] = 0.5*(y - z)*(y - z + 1)*(2*x + 2*z - 1);
│ │ │ │ +
213 out[2][0][1] = 0.5*(x + z)*(2*y - 2*z + 1)*(x + z - 1);
│ │ │ │ +
214 out[2][0][2] = 0.5*(out[2][0][0] + out[2][0][1])
│ │ │ │ +
215 + 0.25*((y - x - 2*z)*(y - z + 1)*(x + z - 1)
│ │ │ │ +
216 + (x + z)*(y - z)*(y - x - 2*z + 2));
│ │ │ │ +
│ │ │ │ +
218 out[3][0][0] = 0.5*(y - z)*(2*x + 2*z + 1)*(y - z + 1);
│ │ │ │ +
219 out[3][0][1] = 0.5*(2*y - 2*z + 1)*(x + z)*(x + z + 1);
│ │ │ │ +
220 out[3][0][2] = 0.5*(out[3][0][0] + out[3][0][1])
│ │ │ │ +
221 + 0.25*((y - x - 2*z)*(y - z + 1)*(x + z + 1)
│ │ │ │ +
222 + (y - z)*(x + z)*(y - x - 2*z));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
226 out[4][0][2] = 4*z - 1;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
229 out[5][0][0] = -(y - z + 1)*(y - 1)*(2*x + z - 1);
│ │ │ │ +
230 out[5][0][1] = -(x + z - 1)*(y - 1)*x - (y - z + 1)*(x + z - 1)*x;
│ │ │ │ +
231 out[5][0][2] = 0.5*(out[5][0][0] + out[5][0][1])
│ │ │ │ +
232 + 0.5*(x + z - 1)*(y - 1)*x - 0.5*(y - z + 1)*(y - 1)*x;
│ │ │ │ +
│ │ │ │ +
234 out[6][0][0] = -(y - z + 1)*(2*x + z + 1)*(y - 1);
│ │ │ │ +
235 out[6][0][1] = -(((x + z + 1)*(y - 1)*x - z) + z*(2*y + 1)
│ │ │ │ +
236 + (y - z + 1)*((x + z + 1)*x + 2*z));
│ │ │ │ +
237 out[6][0][2] = 0.5*(out[6][0][0] + out[6][0][1])
│ │ │ │ +
238 - 0.5*(-(((x + z + 1)*(y - 1)*x - z) + z*(2*y + 1))
│ │ │ │ +
239 + (y - z + 1)*(((y - 1)*x - 1) + 2*y + 1));
│ │ │ │ +
│ │ │ │ +
241 out[7][0][0] = -(((y - z - 1)*(x + 1)*y - z) + z*(2*x + 1)
│ │ │ │ +
242 + (x + z - 1)*((y - z - 1)*y + 2*z));
│ │ │ │ +
243 out[7][0][1] = -(x + z - 1)*(2*y - z - 1)*(x + 1);
│ │ │ │ +
244 out[7][0][2] = 0.5*(out[7][0][0] + out[7][0][1])
│ │ │ │ +
245 - 0.5*(((y - z - 1)*(x + 1)*y - z) + z*(2*x + 1)
│ │ │ │ +
246 + (x + z - 1)*((-(x + 1)*y - 1) + 2*x + 1));
│ │ │ │ +
│ │ │ │ +
248 out[8][0][0] = -(y - z + 1)*(2*x + z)*y;
│ │ │ │ +
249 out[8][0][1] = -(2*y - z + 1)*(x + z - 1)*(x + 1);
│ │ │ │ +
250 out[8][0][2] = 0.5*(out[8][0][0] + out[8][0][1])
│ │ │ │ +
251 - 0.5*(-x + y - 2*z + 2)*(x + 1)*y;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
254 out[9][0][0] = 2*z*(y - z - 1);
│ │ │ │ +
255 out[9][0][1] = 2*z*(x + z - 1);
│ │ │ │ +
256 out[9][0][2] = 0.5*(out[9][0][0] + out[9][0][1])
│ │ │ │ +
257 + (x + z - 1)*(y - z - 1) + z*(-x + y - 2*z);
│ │ │ │ +
│ │ │ │ +
259 out[10][0][0] = -2*z*(y - z - 1);
│ │ │ │ +
260 out[10][0][1] = -2*z*(x + z + 1);
│ │ │ │ +
261 out[10][0][2] = 0.5*(out[10][0][0] + out[10][0][1])
│ │ │ │ +
262 - ((x + z + 1)*(y - z - 1) + 4*z)
│ │ │ │ +
263 - z*(-x + y - 2*z + 2);
│ │ │ │ +
│ │ │ │ +
265 out[11][0][0] = -2*z*(y - z + 1);
│ │ │ │ +
266 out[11][0][1] = -2*z*(x + z - 1);
│ │ │ │ +
267 out[11][0][2] = 0.5*(out[11][0][0] + out[11][0][1])
│ │ │ │ +
268 - (y - z + 1)*(x + z - 1) - z*(-x + y - 2*z + 2);
│ │ │ │ +
│ │ │ │ +
270 out[12][0][0] = 2*z*(y - z + 1);
│ │ │ │ +
271 out[12][0][1] = 2*z*(x + z + 1);
│ │ │ │ +
272 out[12][0][2] = 0.5*(out[12][0][0] + out[12][0][1])
│ │ │ │ +
273 + (y - z + 1)*(x + z + 1) + z*(-x + y - 2*z);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
276 out[13][0][0] = 2*((y - z + 1)*((y - 1)*(x + 1) + z*(x - y + z + 1))
│ │ │ │ +
277 + (y - z + 1)*(x + z - 1)*(y - 1 + z));
│ │ │ │ +
278 out[13][0][1] = 2*((x + z - 1)*((y - 1)*(x + 1) + z*(x - y + z + 1))
│ │ │ │ +
279 + (y - z + 1)*(x + z - 1)*(x + 1 - z));
│ │ │ │ +
280 out[13][0][2] = 0.5*(out[13][0][0] + out[13][0][1])
│ │ │ │ +
281 + ((-x + y - 2*z + 2)*((y - 1)*(x + 1) + z*(x - y + z + 1))
│ │ │ │ +
282 + (y - z + 1)*(x + z - 1)*(x - y + 2*z + 1));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
287 out[0][0][0] = 0.5*(y + z)*(y + z - 1)*(2*x - 2*z - 1);
│ │ │ │ +
288 out[0][0][1] = 0.5*(2*y + 2*z - 1)*(x - z - 1)*(x - z);
│ │ │ │ +
289 out[0][0][2] = 0.5*(out[0][0][0] + out[0][0][1])
│ │ │ │ +
290 + 0.25*((2*y + 2*z - 1)*(x - z - 1)*(x - z)
│ │ │ │ +
291 + (y + z)*(y + z - 1)*(-2*x + 2*z + 1));
│ │ │ │ +
│ │ │ │ +
293 out[1][0][0] = -0.5*(y + z)*(2*x - 2*z + 1)*(-y - z + 1);
│ │ │ │ +
294 out[1][0][1] = -0.5*(x - z)*(x - z + 1)*(-2*y - 2*z + 1);
│ │ │ │ +
295 out[1][0][2] = 0.5*(out[1][0][0] + out[1][0][1])
│ │ │ │ +
296 - 0.25*((x - y - 2*z)*(x - z + 1)*(-y - z + 1)
│ │ │ │ +
297 + (x - z)*(y + z)*(-x + y + 2*z - 2));
│ │ │ │ +
│ │ │ │ +
299 out[2][0][0] = 0.5*((y + z)*((x - z - 1)*(y + z + 1) + 4*z)
│ │ │ │ +
300 + (x - z)*(y + z)*(y + z + 1) + 4*z);
│ │ │ │ +
301 out[2][0][1] = 0.5*((x - z)*((x - z - 1)*(y + z + 1) + 4*z)
│ │ │ │ +
302 + (x - z)*(y + z)*(x - z - 1) - 4*z);
│ │ │ │ +
303 out[2][0][2] = 0.5*(out[2][0][0] + out[2][0][1])
│ │ │ │ +
304 + 0.25*((x - y - 2*z)*((x - z - 1)*(y + z + 1) + 4*z)
│ │ │ │ +
305 + (x - z)*(y + z)*(x - y - 2*z + 2) + 4*(x - y));
│ │ │ │ +
│ │ │ │ +
307 out[3][0][0] = 0.5*(y + z)*(2*x - 2*z + 1)*(y + z + 1);
│ │ │ │ +
308 out[3][0][1] = 0.5*(x - z)*(x - z + 1)*(2*y + 2*z + 1);
│ │ │ │ +
309 out[3][0][2] = 0.5*(out[3][0][0] + out[3][0][1])
│ │ │ │ +
310 + 0.25*((x - y - 2*z)*(x - z + 1)*(y + z + 1)
│ │ │ │ +
311 + (y + z)*(x - z)*(x - y - 2*z));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
315 out[4][0][2] = 4*z - 1;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
318 out[5][0][0] = -(y + z - 1)*(2*x - z - 1)*(y + 1);
│ │ │ │ +
319 out[5][0][1] = -(((x - z - 1)*(y + 1)*x - z) + z*(2*y + 1)
│ │ │ │ +
320 + (y + z - 1)*((x - z - 1)*x + 2*z));
│ │ │ │ +
321 out[5][0][2] = 0.5*(out[5][0][0] + out[5][0][1])
│ │ │ │ +
322 - 0.5*((((x - z - 1)*(y + 1)*x - z) + z*(2*y + 1))
│ │ │ │ +
323 + (y + z - 1)*((-(y + 1)*x - 1) + 2*y + 1));
│ │ │ │ +
│ │ │ │ +
325 out[6][0][0] = -(2*x - z + 1)*(y + z - 1)*(y + 1);
│ │ │ │ +
326 out[6][0][1] = -(x - z + 1)*(2*y + z)*x;
│ │ │ │ +
327 out[6][0][2] = 0.5*(out[6][0][0] + out[6][0][1])
│ │ │ │ +
328 - 0.5*(x - y - 2*z + 2)*(y + 1)*x;
│ │ │ │ +
│ │ │ │ +
330 out[7][0][0] = -(2*x - z)*(y + z - 1)*y;
│ │ │ │ +
331 out[7][0][1] = -(x - z + 1)*(2*y + z - 1)*(x - 1);
│ │ │ │ +
332 out[7][0][2] = 0.5*(out[7][0][0] + out[7][0][1])
│ │ │ │ +
333 - 0.5*(x - y - 2*z + 2)*(x - 1)*y;
│ │ │ │ +
│ │ │ │ +
335 out[8][0][0] = -(((y + z + 1)*(x - 1)*y - z) + z*(2*x + 1)
│ │ │ │ +
336 + (x - z + 1)*((y + z + 1)*y + 2*z));
│ │ │ │ +
337 out[8][0][1] = -(x - z + 1)*(2*y + z + 1)*(x - 1);
│ │ │ │ +
338 out[8][0][2] = 0.5*(out[8][0][0] + out[8][0][1])
│ │ │ │ +
339 - 0.5*(-(((y + z + 1)*(x - 1)*y - z) + z*(2*x + 1))
│ │ │ │ +
340 + (x - z + 1)*(((x - 1)*y - 1) + 2*x + 1));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
343 out[9][0][0] = 2*z*(y + z - 1);
│ │ │ │ +
344 out[9][0][1] = 2*z*(x - z - 1);
│ │ │ │ +
345 out[9][0][2] = 0.5*(out[9][0][0] + out[9][0][1])
│ │ │ │ +
346 + (y + z - 1)*(x - z - 1) + z*(x - y - 2*z);
│ │ │ │ +
│ │ │ │ +
348 out[10][0][0] = -2*z*(y + z - 1);
│ │ │ │ +
349 out[10][0][1] = -2*z*(x - z + 1);
│ │ │ │ +
350 out[10][0][2] = 0.5*(out[10][0][0] + out[10][0][1])
│ │ │ │ +
351 - (x - z + 1)*(y + z - 1) - z*(x - y - 2*z + 2);
│ │ │ │ +
│ │ │ │ +
353 out[11][0][0] = -2*z*(y + z + 1);
│ │ │ │ +
354 out[11][0][1] = -2*z*(x - z - 1);
│ │ │ │ +
355 out[11][0][2] = 0.5*(out[11][0][0] + out[11][0][1])
│ │ │ │ +
356 - ((y + z + 1)*(x - z - 1) + 4*z) - z*(x - y - 2*z + 2);
│ │ │ │ +
│ │ │ │ +
358 out[12][0][0] = 2*z*(y + z + 1);
│ │ │ │ +
359 out[12][0][1] = 2*z*(x - z + 1);
│ │ │ │ +
360 out[12][0][2] = 0.5*(out[12][0][0] + out[12][0][1])
│ │ │ │ +
361 + (x - z + 1)*(y + z + 1) + z*(x - y - 2*z);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
364 out[13][0][0] = 2*((y + z - 1)*((y + 1)*(x - 1) - z*(x - y - z - 1))
│ │ │ │ +
365 + (x - z + 1)*(y + z - 1)*(y + 1 - z));
│ │ │ │ +
366 out[13][0][1] = 2*((x - z + 1)*((y + 1)*(x - 1) - z*(x - y - z - 1))
│ │ │ │ +
367 + (x - z + 1)*(y + z - 1)*(x - 1 + z));
│ │ │ │ +
368 out[13][0][2] = 0.5*(out[13][0][0] + out[13][0][1])
│ │ │ │ +
369 + (x - y - 2*z + 2)*((y + 1)*(x - 1) - z*(x - y - z - 1))
│ │ │ │ +
370 + (x - z + 1)*(y + z - 1)*(-(x - y - 2*z - 1));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
376 DUNE_THROW(NotImplemented,
"LagrangePyramidLocalBasis::evaluateJacobian for order " << k);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
385 void partial(
const std::array<unsigned int,3>& order,
│ │ │ │ +
│ │ │ │ +
387 std::vector<typename Traits::RangeType>& out)
const
│ │ │ │ +
│ │ │ │ +
389 auto totalOrder = std::accumulate(order.begin(), order.end(), 0);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
395 evaluateFunction(in, out);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
409 auto const direction = std::distance(order.begin(), std::find(order.begin(), order.end(), 1));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
422 out[0] = -1 + in[0] + in[2];
│ │ │ │ +
423 out[1] = -in[0] - in[2];
│ │ │ │ +
424 out[2] = 1 - in[0] - in[2];
│ │ │ │ +
425 out[3] = in[0]+in[2];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
436 DUNE_THROW(RangeError,
"Component out of range.");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
444 out[0] = -1 + in[1] + in[2];
│ │ │ │ +
445 out[1] = 1 - in[1] - in[2];
│ │ │ │ +
446 out[2] = -in[1] - in[2];
│ │ │ │ +
447 out[3] = in[1] + in[2];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
465 DUNE_THROW(RangeError,
"Component out of range.");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
468 }
else if (totalOrder == 2)
│ │ │ │ +
│ │ │ │ +
470 if ((order[0] == 1 && order[1] == 1) ||
│ │ │ │ +
471 (order[1] == 1 && order[2] == 1 && in[0] > in[1]) ||
│ │ │ │ +
472 (order[0] == 1 && order[2] == 1 && in[0] <=in[1]))
│ │ │ │ +
│ │ │ │ +
474 out = {1, -1, -1, 1, 0};
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
477 out = {0, 0, 0, 0, 0};
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
482 out = {0, 0, 0, 0, 0};
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
493 const R x = 2.0*in[0] + in[2] - 1.0;
│ │ │ │ +
494 const R y = 2.0*in[1] + in[2] - 1.0;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
497 auto const direction = std::distance(order.begin(), std::find(order.begin(), order.end(), 1));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
506 out[0] = 0.5*(y - z - 1)*(y - z)*(2*x + 2*z - 1);
│ │ │ │ +
507 out[1] = 2*(-0.25*((y - z)*((x + z + 1)*(-y + z + 1) - 4*z) + (x + z)*(y - z)*(-y + z + 1)) - z);
│ │ │ │ +
508 out[2] = 0.5*(y - z)*(y - z + 1)*(2*x + 2*z - 1);
│ │ │ │ +
509 out[3] = 0.5*(y - z)*(2*x + 2*z + 1)*(y - z + 1);
│ │ │ │ +
│ │ │ │ +
511 out[5] = -(y - z + 1)*(2*x + z - 1)*(y - 1);
│ │ │ │ +
512 out[6] = -(y - z + 1)*(2*x + z + 1)*(y - 1);
│ │ │ │ +
513 out[7] = -(((y - z - 1)*(x + 1)*y - z) + z*(2*x + 1) + (x + z - 1)*((y - z - 1)*y + 2*z));
│ │ │ │ +
514 out[8] = -(y - z + 1)*(2*x + z)*y;
│ │ │ │ +
515 out[9] = 2*z*(y - z - 1);
│ │ │ │ +
516 out[10] = -2*z*(y - z - 1);
│ │ │ │ +
517 out[11] = -2*z*(y - z + 1);
│ │ │ │ +
518 out[12] = 2*z*(y - z + 1);
│ │ │ │ +
519 out[13] = 2*((y - z + 1)*((y - 1)*(x + 1) + z*(x - y + z + 1)) + (y - z + 1)*(x + z - 1)*(y - 1 + z));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
522 out[0] = 0.5*(x + z)*(x + z - 1)*(2*y - 2*z - 1);
│ │ │ │ +
523 out[1] = 2*(-0.25*((x + z)*((x + z + 1)*(-y + z + 1) - 4*z) + (x + z)*(y - z)*(-(x + z + 1))) + z);
│ │ │ │ +
524 out[2] = 0.5*(x + z)*(2*y - 2*z + 1)*(x + z - 1);
│ │ │ │ +
525 out[3] = 0.5*(2*y - 2*z + 1)*(x + z)*(x + z + 1);
│ │ │ │ +
│ │ │ │ +
527 out[5] = -(x + z - 1)*(y - 1)*x - (y - z + 1)*(x + z - 1)*x;
│ │ │ │ +
528 out[6] = -(((x + z + 1)*(y - 1)*x - z) + z*(2*y + 1) + (y - z + 1)*((x + z + 1)*x + 2*z));
│ │ │ │ +
529 out[7] = -(x + z - 1)*(2*y - z - 1)*(x + 1);
│ │ │ │ +
530 out[8] = -(2*y - z + 1)*(x + z - 1)*(x + 1);
│ │ │ │ +
531 out[9] = 2*z*(x + z - 1);
│ │ │ │ +
532 out[10] = -2*z*(x + z + 1);
│ │ │ │ +
533 out[11] = -2*z*(x + z - 1);
│ │ │ │ +
534 out[12] = 2*z*(x + z + 1);
│ │ │ │ +
535 out[13] = 2*((x + z - 1)*((y - 1)*(x + 1) + z*(x - y + z + 1)) + (y - z + 1)*(x + z - 1)*(x + 1 - z));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
538 out[0] = -((y - z)*(2*x + 2*z - 1)*(z - y + 1))/2;
│ │ │ │ +
539 out[1] = ((y - z + 1)*(y - 2*x + z + 2*x*y - 2*x*z + 2*y*z - 2*z*z))/2;
│ │ │ │ +
540 out[2] = ((y - z)*(2*x + 2*z - 1)*(y - z + 1))/2;
│ │ │ │ +
541 out[3] = ((y - z)*(2*x + 2*z + 1)*(y - z + 1))/2;
│ │ │ │ +
│ │ │ │ +
543 out[5] = (-(y - z + 1)*(2*x + z - 1)*(y - 1) - (x + z - 1)*(y - 1)*x - (y - z + 1)*(x + z - 1)*x + (x + z - 1)*(y - 1)*x - (y - z + 1)*(y - 1)*x)/2;
│ │ │ │ +
544 out[6] = -((y - z + 1)*(3*y - 2*x + z + 3*x*y + x*z + y*z + x*x - 1))/2;
│ │ │ │ +
545 out[7] = z - z*(2*x + 1) - ((2*z - y*(z - y + 1))*(x + z - 1))/2 - ((2*x - y*(x + 1))*(x + z - 1))/2 + ((x + 1)*(x + z - 1)*(z - 2*y + 1))/2 + y*(x + 1)*(z - y + 1);
│ │ │ │ +
546 out[8] = -((y - z + 1)*(y + z + 3*x*y + x*z + y*z + x*x - 1))/2;
│ │ │ │ +
547 out[9] = -(x + 3*z - 1)*(z - y + 1);
│ │ │ │ +
548 out[10] = (x + z + 1)*(z - y + 1) - 2*y*z - 6*z + 2*z*z;
│ │ │ │ +
549 out[11] = -(x + 3*z - 1)*(y - z + 1);
│ │ │ │ +
550 out[12] = (x + 3*z + 1)*(y - z + 1);
│ │ │ │ +
551 out[13] = (y - z + 1)*(2*y - 3*x + z + 2*x*y + 6*x*z - 2*y*z + 2*x*x + 4*z*z - 3);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
554 DUNE_THROW(RangeError,
"Component out of range.");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
562 out[0] = -((y + z)*(2*z - 2*x + 1)*(y + z - 1))/2;
│ │ │ │ +
563 out[1] = ((y + z)*(2*x - 2*z + 1)*(y + z - 1))/2;
│ │ │ │ +
564 out[2] = -((y + z + 1)*(y - 3*z - 2*x*y - 2*x*z + 2*y*z + 2*z*z))/2;
│ │ │ │ +
565 out[3] = ((y + z)*(2*x - 2*z + 1)*(y + z + 1))/2;
│ │ │ │ +
│ │ │ │ +
567 out[5] = (y + 1)*(y + z - 1)*(z - 2*x + 1);
│ │ │ │ +
568 out[6] = -(y + 1)*(2*x - z + 1)*(y + z - 1);
│ │ │ │ +
569 out[7] = -y*(2*x - z)*(y + z - 1);
│ │ │ │ +
570 out[8] = z - z*(2*x + 1) - (2*z + y*(y + z + 1))*(x - z + 1) - y*(x - 1)*(y + z + 1);
│ │ │ │ +
571 out[9] = 2*z*(y + z - 1);
│ │ │ │ +
572 out[10] = -2*z*(y + z - 1);
│ │ │ │ +
573 out[11] = -2*z*(y + z + 1);
│ │ │ │ +
574 out[12] = 2*z*(y + z + 1);
│ │ │ │ +
575 out[13] = 2*(y + z - 1)*(2*x - z + 2*x*y - 2*x*z + 2*z*z);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
578 out[0] = -(x - z)*(y + z - 0.5)*(z - x + 1);
│ │ │ │ +
579 out[1] = ((x - z)*(2*y + 2*z - 1)*(x - z + 1))/2;
│ │ │ │ +
580 out[2] = -((z - x + 1)*(x + 3*z + 2*x*y + 2*x*z - 2*y*z - 2*z*z))/2;
│ │ │ │ +
581 out[3] = ((x - z)*(2*y + 2*z + 1)*(x - z + 1))/2;
│ │ │ │ +
│ │ │ │ +
583 out[5] = z - z*(2*y + 1) - (2*z - x*(z - x + 1))*(y + z - 1) + x*(y + 1)*(z - x + 1);
│ │ │ │ +
584 out[6] = -x*(2*y + z)*(x - z + 1);
│ │ │ │ +
585 out[7] = -(x - 1)*(x - z + 1)*(2*y + z - 1);
│ │ │ │ +
586 out[8] = -(x - 1)*(x - z + 1)*(2*y + z + 1);
│ │ │ │ +
587 out[9] = -2*z*(z - x + 1);
│ │ │ │ +
588 out[10] = -2*z*(x - z + 1);
│ │ │ │ +
589 out[11] = 2*z*(z - x + 1);
│ │ │ │ +
590 out[12] = 2*z*(x - z + 1);
│ │ │ │ +
591 out[13] = 2*(x - z + 1)*(2*x*y - z - 2*y + 2*y*z + 2*z*z);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
594 out[0] = -((x - z)*(2*y + 2*z - 1)*(z - x + 1))/2;
│ │ │ │ +
595 out[1] = ((x - z)*(2*y + 2*z - 1)*(x - z + 1))/2;
│ │ │ │ +
596 out[2] = ((x - z + 1)*(x - 2*y + z + 2*x*y + 2*x*z - 2*y*z - 2*z*z))/2;
│ │ │ │ +
597 out[3] = ((x - z)*(2*y + 2*z + 1)*(x - z + 1))/2;
│ │ │ │ +
│ │ │ │ +
599 out[5] = z - z*(2*y + 1) - ((2*z - x*(z - x + 1))*(y + z - 1))/2 - ((2*y - x*(y + 1))*(y + z - 1))/2 + ((y + 1)*(y + z - 1)*(z - 2*x + 1))/2 + x*(y + 1)*(z - x + 1);
│ │ │ │ +
600 out[6] = -((x - z + 1)*(x + z + 3*x*y + x*z + y*z + y*y - 1))/2;
│ │ │ │ +
601 out[7] = -((x - z + 1)*(3*x*y - 4*y - z - x + x*z + y*z + y*y + 1))/2;
│ │ │ │ +
602 out[8] = -((x - z + 1)*(3*x - 2*y + z + 3*x*y + x*z + y*z + y*y - 1))/2;
│ │ │ │ +
603 out[9] = -(z - x + 1)*(y + 3*z - 1);
│ │ │ │ +
604 out[10] = -(x - z + 1)*(y + 3*z - 1);
│ │ │ │ +
605 out[11] = (y + z + 1)*(z - x + 1) - 2*x*z - 6*z + 2*z*z;
│ │ │ │ +
606 out[12] = (x - z + 1)*(y + 3*z + 1);
│ │ │ │ +
607 out[13] = (x - z + 1)*(2*x - 3*y + z + 2*x*y - 2*x*z + 6*y*z + 2*y*y + 4*z*z - 3);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
610 DUNE_THROW(RangeError,
"Component out of range.");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
614 DUNE_THROW(NotImplemented,
"Desired derivative order is not implemented");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
620 DUNE_THROW(NotImplemented,
"LagrangePyramidLocalBasis::partial for order " << k);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
624 static constexpr unsigned int order ()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
634 template<
unsigned int k>
│ │ │ │ +
635 class LagrangePyramidLocalCoefficients
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
639 LagrangePyramidLocalCoefficients ()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
644 localKeys_[0] = LocalKey(0,0,0);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
650 for (std::size_t i=0; i<size(); i++)
│ │ │ │ +
651 localKeys_[i] = LocalKey(i,3,0);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
658 localKeys_[0] = LocalKey(0,3,0);
│ │ │ │ +
659 localKeys_[1] = LocalKey(1,3,0);
│ │ │ │ +
660 localKeys_[2] = LocalKey(2,3,0);
│ │ │ │ +
661 localKeys_[3] = LocalKey(3,3,0);
│ │ │ │ +
662 localKeys_[4] = LocalKey(4,3,0);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
665 localKeys_[5] = LocalKey(0,2,0);
│ │ │ │ +
666 localKeys_[6] = LocalKey(1,2,0);
│ │ │ │ +
667 localKeys_[7] = LocalKey(2,2,0);
│ │ │ │ +
668 localKeys_[8] = LocalKey(3,2,0);
│ │ │ │ +
669 localKeys_[9] = LocalKey(4,2,0);
│ │ │ │ +
670 localKeys_[10] = LocalKey(5,2,0);
│ │ │ │ +
671 localKeys_[11] = LocalKey(6,2,0);
│ │ │ │ +
672 localKeys_[12] = LocalKey(7,2,0);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
675 localKeys_[13] = LocalKey(0,1,0);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
681 DUNE_THROW(NotImplemented,
"LagrangePyramidLocalCoefficients for order " << k);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
686 static constexpr std::size_t size ()
│ │ │ │ +
│ │ │ │ +
688 std::size_t result = 0;
│ │ │ │ +
689 for (
unsigned int i=0; i<=k; i++)
│ │ │ │ +
690 result += power(i+1,2);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
695 const LocalKey& localKey (std::size_t i)
const
│ │ │ │ +
│ │ │ │ +
697 return localKeys_[i];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
701 std::vector<LocalKey> localKeys_;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
708 template<
class LocalBasis>
│ │ │ │ +
709 class LagrangePyramidLocalInterpolation
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
720 template<
typename F,
typename C>
│ │ │ │ +
721 void interpolate (
const F& ff, std::vector<C>& out)
const
│ │ │ │ +
│ │ │ │ +
723 constexpr auto k = LocalBasis::order();
│ │ │ │ +
724 using D =
typename LocalBasis::Traits::DomainType;
│ │ │ │ +
725 using DF =
typename LocalBasis::Traits::DomainFieldType;
│ │ │ │ +
│ │ │ │ +
727 auto&& f = Impl::makeFunctionWithCallOperator<D>(ff);
│ │ │ │ +
│ │ │ │ +
729 out.resize(LocalBasis::size());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
734 auto center = ReferenceElements<DF,3>::general(GeometryTypes::pyramid).position(0,0);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
742 for (
unsigned int i=0; i<LocalBasis::size(); i++)
│ │ │ │ +
│ │ │ │ +
744 auto vertex = ReferenceElements<DF,3>::general(GeometryTypes::pyramid).position(i,3);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
753 out[0] = f( D( {0.0, 0.0, 0.0} ) );
│ │ │ │ +
754 out[1] = f( D( {1.0, 0.0, 0.0} ) );
│ │ │ │ +
755 out[2] = f( D( {0.0, 1.0, 0.0} ) );
│ │ │ │ +
756 out[3] = f( D( {1.0, 1.0, 0.0} ) );
│ │ │ │ +
757 out[4] = f( D( {0.0, 0.0, 1.0} ) );
│ │ │ │ +
758 out[5] = f( D( {0.0, 0.5, 0.0} ) );
│ │ │ │ +
759 out[6] = f( D( {1.0, 0.5, 0.0} ) );
│ │ │ │ +
760 out[7] = f( D( {0.5, 0.0, 0.0} ) );
│ │ │ │ +
761 out[8] = f( D( {0.5, 1.0, 0.0} ) );
│ │ │ │ +
762 out[9] = f( D( {0.0, 0.0, 0.5} ) );
│ │ │ │ +
763 out[10] = f( D( {0.5, 0.0, 0.5} ) );
│ │ │ │ +
764 out[11] = f( D( {0.0, 0.5, 0.5} ) );
│ │ │ │ +
765 out[12] = f( D( {0.5, 0.5, 0.5} ) );
│ │ │ │ +
766 out[13] = f( D( {0.5, 0.5, 0.0} ) );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
771 DUNE_THROW(NotImplemented,
"LagrangePyramidLocalInterpolation not implemented for order " << k);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
810 template<
class D,
class R,
int k>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
817 Impl::LagrangePyramidLocalCoefficients<k>,
│ │ │ │ +
818 Impl::LagrangePyramidLocalInterpolation<Impl::LagrangePyramidLocalBasis<D,R,k> > >;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
838 return coefficients_;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
845 return interpolation_;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
849 static constexpr std::size_t
size ()
│ │ │ │ +
│ │ │ │ +
851 return Impl::LagrangePyramidLocalBasis<D,R,k>::size();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
856 static constexpr GeometryType
type ()
│ │ │ │ +
│ │ │ │ +
858 return GeometryTypes::pyramid;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
862 Impl::LagrangePyramidLocalBasis<D,R,k> basis_;
│ │ │ │ +
863 Impl::LagrangePyramidLocalCoefficients<k> coefficients_;
│ │ │ │ +
864 Impl::LagrangePyramidLocalInterpolation<Impl::LagrangePyramidLocalBasis<D,R,k> > interpolation_;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
Definition bdfmcube.hh:18
│ │ │ │ -
Brezzi-Douglas-Fortin-Marini finite elements for cubes.
Definition bdfmcube.hh:45
│ │ │ │ -
auto localCoefficients() const -> const LocalCoefficients &
Definition bdfmcube.hh:66
│ │ │ │ -
unsigned int size() const
Number of shape functions in this finite element.
Definition bdfmcube.hh:70
│ │ │ │ -
BDFMCubeLocalFiniteElement()
Standard constructor.
Definition bdfmcube.hh:54
│ │ │ │ -
auto localBasis() const -> const LocalBasis &
Definition bdfmcube.hh:65
│ │ │ │ -
static constexpr auto type() -> GeometryType
Definition bdfmcube.hh:71
│ │ │ │ -
auto localInterpolation() const -> const LocalInterpolation &
Definition bdfmcube.hh:67
│ │ │ │ -
BDFMCubeLocalFiniteElement(std::bitset< 2 *dim > s)
Make set number s, where 0 <= s < 2^(2*dim)
Definition bdfmcube.hh:61
│ │ │ │ -
Brezzi-Douglas-Fortin-Marini shape functions on a reference cube.
Definition brezzidouglasfortinmarini/cube/localbasis.hh:37
│ │ │ │ -
Layout map for Brezzi-Douglas-Fortin-Marini elements on cubes.
Definition localcoefficients.hh:33
│ │ │ │ -
Interpolation for Brezzi-Douglas-Fortin-Marini shape functions on cubes.
Definition brezzidouglasfortinmarini/cube/localinterpolation.hh:38
│ │ │ │ +
D DomainType
domain type
Definition common/localbasis.hh:42
│ │ │ │
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
│ │ │ │ +
Lagrange finite element for 3d pyramids with compile-time polynomial order.
Definition lagrangepyramid.hh:812
│ │ │ │ +
const Traits::LocalCoefficientsType & localCoefficients() const
Returns the assignment of the degrees of freedom to the element subentities.
Definition lagrangepyramid.hh:836
│ │ │ │ +
static constexpr std::size_t size()
The number of shape functions.
Definition lagrangepyramid.hh:849
│ │ │ │ +
LagrangePyramidLocalFiniteElement()
Default constructor.
Definition lagrangepyramid.hh:825
│ │ │ │ +
static constexpr GeometryType type()
The reference element that the local finite element is defined on.
Definition lagrangepyramid.hh:856
│ │ │ │ +
const Traits::LocalBasisType & localBasis() const
Returns the local basis, i.e., the set of shape functions.
Definition lagrangepyramid.hh:829
│ │ │ │ +
const Traits::LocalInterpolationType & localInterpolation() const
Returns object that evaluates degrees of freedom.
Definition lagrangepyramid.hh:843
│ │ │ │ +
│ │ │ │ +
│ │ │ │
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,36 +1,34 @@
│ │ │ │ │ dune-localfunctions 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _l_o_c_a_l_f_u_n_c_t_i_o_n_s
│ │ │ │ │ - * _o_r_t_h_o_n_o_r_m_a_l
│ │ │ │ │ -_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ -orthonormalcompute.hh File Reference
│ │ │ │ │ -#include