142 Assert(values.size() == this->n() || values.size() == 0,
144 Assert(grads.size() == this->n() || grads.size() == 0,
146 Assert(grad_grads.size() == this->n() || grad_grads.size() == 0,
148 Assert(third_derivatives.size() == this->n() || third_derivatives.size() == 0,
150 Assert(fourth_derivatives.size() == this->n() ||
151 fourth_derivatives.size() == 0,
154 std::vector<double> p_values;
155 std::vector<Tensor<1, dim>> p_grads;
156 std::vector<Tensor<2, dim>> p_grad_grads;
157 std::vector<Tensor<3, dim>> p_third_derivatives;
158 std::vector<Tensor<4, dim>> p_fourth_derivatives;
160 const unsigned int n_sub = polynomial_space.n();
161 p_values.resize((values.size() == 0) ? 0 : n_sub);
162 p_grads.resize((grads.size() == 0) ? 0 : n_sub);
163 p_grad_grads.resize((grad_grads.size() == 0) ? 0 : n_sub);
164 p_third_derivatives.resize((third_derivatives.size() == 0) ? 0 : n_sub);
165 p_fourth_derivatives.resize((fourth_derivatives.size() == 0) ? 0 : n_sub);
167 for (
unsigned int d = 0; d < dim; ++d)
175 for (
unsigned int c = 0; c < dim; ++c)
176 p(c) = unit_point((c + d) % dim);
178 polynomial_space.evaluate(p,
183 p_fourth_derivatives);
185 for (
unsigned int i = 0; i < p_values.size(); ++i)
186 values[lexicographic_to_hierarchic[i + d * n_sub]][d] =
187 p_values[renumber_aniso[d][i]];
189 for (
unsigned int i = 0; i < p_grads.size(); ++i)
190 for (
unsigned int d1 = 0; d1 < dim; ++d1)
191 grads[lexicographic_to_hierarchic[i + d * n_sub]][d][(d1 + d) % dim] =
192 p_grads[renumber_aniso[d][i]][d1];
194 for (
unsigned int i = 0; i < p_grad_grads.size(); ++i)
195 for (
unsigned int d1 = 0; d1 < dim; ++d1)
196 for (
unsigned int d2 = 0; d2 < dim; ++d2)
197 grad_grads[lexicographic_to_hierarchic[i + d * n_sub]][d]
198 [(d1 + d) % dim][(d2 + d) % dim] =
199 p_grad_grads[renumber_aniso[d][i]][d1][d2];
201 for (
unsigned int i = 0; i < p_third_derivatives.size(); ++i)
202 for (
unsigned int d1 = 0; d1 < dim; ++d1)
203 for (
unsigned int d2 = 0; d2 < dim; ++d2)
204 for (
unsigned int d3 = 0; d3 < dim; ++d3)
205 third_derivatives[lexicographic_to_hierarchic[i + d * n_sub]][d]
206 [(d1 + d) % dim][(d2 + d) % dim]
208 p_third_derivatives[renumber_aniso[d][i]][d1]
211 for (
unsigned int i = 0; i < p_fourth_derivatives.size(); ++i)
212 for (
unsigned int d1 = 0; d1 < dim; ++d1)
213 for (
unsigned int d2 = 0; d2 < dim; ++d2)
214 for (
unsigned int d3 = 0; d3 < dim; ++d3)
215 for (
unsigned int d4 = 0; d4 < dim; ++d4)
216 fourth_derivatives[lexicographic_to_hierarchic[i + d * n_sub]]
217 [d][(d1 + d) % dim][(d2 + d) % dim]
218 [(d3 + d) % dim][(d4 + d) % dim] =
219 p_fourth_derivatives[renumber_aniso[d][i]]
259 const unsigned int normal_degree,
260 const unsigned int tangential_degree)
262 const unsigned int n_dofs_face =
264 std::vector<unsigned int> lexicographic_numbering;
266 for (
unsigned int j = 0; j < n_dofs_face; ++j)
268 lexicographic_numbering.push_back(j);
269 if (normal_degree > 1)
270 for (
unsigned int i = n_dofs_face * 2 * dim;
271 i < n_dofs_face * 2 * dim + normal_degree - 1;
273 lexicographic_numbering.push_back(i + j * (normal_degree - 1));
274 lexicographic_numbering.push_back(n_dofs_face + j);
278 unsigned int layers = (dim == 3) ? tangential_degree + 1 : 1;
279 for (
unsigned int k = 0; k < layers; ++k)
281 unsigned int k_add = k * (tangential_degree + 1);
282 for (
unsigned int j = n_dofs_face * 2;
283 j < n_dofs_face * 2 + tangential_degree + 1;
285 lexicographic_numbering.push_back(j + k_add);
287 if (normal_degree > 1)
288 for (
unsigned int i = n_dofs_face * (2 * dim + (normal_degree - 1));
289 i < n_dofs_face * (2 * dim + (normal_degree - 1)) +
290 (normal_degree - 1) * (tangential_degree + 1);
293 lexicographic_numbering.push_back(i + k_add * tangential_degree);
295 for (
unsigned int j = n_dofs_face * 3;
296 j < n_dofs_face * 3 + tangential_degree + 1;
298 lexicographic_numbering.push_back(j + k_add);
304 for (
unsigned int i = 4 * n_dofs_face; i < 5 * n_dofs_face; ++i)
305 lexicographic_numbering.push_back(i);
306 if (normal_degree > 1)
307 for (
unsigned int i =
308 6 * n_dofs_face + n_dofs_face * 2 * (normal_degree - 1);
309 i < 6 * n_dofs_face + n_dofs_face * 3 * (normal_degree - 1);
311 lexicographic_numbering.push_back(i);
312 for (
unsigned int i = 5 * n_dofs_face; i < 6 * n_dofs_face; ++i)
313 lexicographic_numbering.push_back(i);
316 return lexicographic_numbering;
void evaluate(const Point< dim > &unit_point, std::vector< Tensor< 1, dim > > &values, std::vector< Tensor< 2, dim > > &grads, std::vector< Tensor< 3, dim > > &grad_grads, std::vector< Tensor< 4, dim > > &third_derivatives, std::vector< Tensor< 5, dim > > &fourth_derivatives) const override