deal.II version GIT relicensing-6834-g5b78e6bcdf 2026-10-01 11:20:01+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Loading...
Searching...
No Matches
portable_evaluation_kernels.h
Go to the documentation of this file.
1// -----------------------------------------------------------------------------
2//
3// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
4// Copyright (C) 2017 - 2025 by the deal.II authors
5//
6// This file is part of the deal.II library.
7//
8// Detailed license information governing the source code and contributions
9// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
10//
11// -----------------------------------------------------------------------------
12
13
14#ifndef dealii__evaluation_kernels_h
15#define dealii__evaluation_kernels_h
16
17#include <deal.II/base/config.h>
18
19#include <deal.II/base/utilities.h>
20
21#include <deal.II/matrix_free/evaluation_flags.h>
22#include <deal.II/matrix_free/portable_matrix_free.h>
23#include <deal.II/matrix_free/portable_tensor_product_kernels.h>
24
25#include <Kokkos_Core.hpp>
26
27
28DEAL_II_NAMESPACE_OPEN
29
30
31namespace Portable
32{
33 namespace internal
34 {
42 constexpr bool
43 use_collocation_evaluation(const unsigned int fe_degree,
44 const unsigned int n_q_points_1d)
45 {
46 // TODO: are the conditions suit for GPU parallelization?
47 return (n_q_points_1d > fe_degree) && (n_q_points_1d < 200) &&
48 (n_q_points_1d <= 3 * fe_degree / 2 + 1);
49 }
50
51
52
62 template <int dim, int fe_degree, int n_q_points_1d, typename Number>
63 struct FEEvaluationImpl
64 {
65 using TeamHandle = Kokkos::TeamPolicy<
66 MemorySpace::Default::kokkos_space::execution_space>::member_type;
67 using SharedView = Kokkos::View<Number *,
68 MemorySpace::Default::kokkos_space::
69 execution_space::scratch_memory_space,
70 Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
71
72 DEAL_II_HOST_DEVICE static void
73 evaluate(const unsigned int dof_handler_index,
74 const unsigned int n_components,
75 const EvaluationFlags::EvaluationFlags evaluation_flag,
76 const typename MatrixFree<dim, Number>::Data *data)
77 {
78 if (evaluation_flag == EvaluationFlags::nothing)
79 return;
80
81 // the evaluator does not need temporary storage since no in-place
82 // operation takes place in this function
83 auto scratch_for_eval =
84 Kokkos::subview(data->shared_data[dof_handler_index].scratch_pad,
85 Kokkos::make_pair(0, 0));
86 EvaluatorTensorProduct<EvaluatorVariant::evaluate_general,
87 dim,
88 fe_degree + 1,
89 n_q_points_1d,
90 Number>
91 eval(data->team_member,
92 data->precomputed_data[dof_handler_index].shape_values,
93 data->precomputed_data[dof_handler_index].shape_gradients,
94 data->precomputed_data[dof_handler_index].co_shape_gradients,
95 scratch_for_eval);
96
97 for (unsigned int c = 0; c < n_components; ++c)
98 {
99 auto u =
100 Kokkos::subview(data->shared_data[dof_handler_index].values,
101 Kokkos::ALL,
102 c);
103 auto grad_u =
104 Kokkos::subview(data->shared_data[dof_handler_index].gradients,
105 Kokkos::ALL,
106 Kokkos::ALL,
107 c);
108
109 if constexpr (dim == 1)
110 {
111 auto temp = Kokkos::subview(
112 data->shared_data[dof_handler_index].scratch_pad,
113 Kokkos::make_pair(0, n_q_points_1d));
114
115 if (evaluation_flag & EvaluationFlags::gradients)
116 eval.template gradients<0, true, false, false>(
117 u, Kokkos::subview(grad_u, Kokkos::ALL, 0));
118 if (evaluation_flag & EvaluationFlags::values)
119 {
120 eval.template values<0, true, false, false>(u, temp);
121 populate_view<false>(data->team_member,
122 u,
123 temp,
124 n_q_points_1d);
125 }
126 }
127 else if constexpr (dim == 2)
128 {
129 constexpr int temp_size = (fe_degree + 1) * n_q_points_1d;
130 auto temp = Kokkos::subview(
131 data->shared_data[dof_handler_index].scratch_pad,
132 Kokkos::make_pair(0, temp_size));
133
134 // grad x
135 if (evaluation_flag & EvaluationFlags::gradients)
136 {
137 eval.template gradients<0, true, false, false>(u, temp);
138 eval.template values<1, true, false, false>(
139 temp, Kokkos::subview(grad_u, Kokkos::ALL, 0));
140 }
141
142 // grad y
143 eval.template values<0, true, false, false>(u, temp);
144 if (evaluation_flag & EvaluationFlags::gradients)
145 eval.template gradients<1, true, false, false>(
146 temp, Kokkos::subview(grad_u, Kokkos::ALL, 1));
147
148 // val: can use values applied in x
149 if (evaluation_flag & EvaluationFlags::values)
150 eval.template values<1, true, false, false>(temp, u);
151 }
152 else if constexpr (dim == 3)
153 {
154 constexpr int temp1_size = Utilities::pow(fe_degree + 1, 2) *
155 n_q_points_1d,
156 temp2_size = Utilities::pow(n_q_points_1d, 2) *
157 (fe_degree + 1);
158
159 auto temp1 = Kokkos::subview(
160 data->shared_data[dof_handler_index].scratch_pad,
161 Kokkos::make_pair(0, temp1_size));
162 auto temp2 = Kokkos::subview(
163 data->shared_data[dof_handler_index].scratch_pad,
164 Kokkos::make_pair(temp1_size, temp1_size + temp2_size));
165
166 if (evaluation_flag & EvaluationFlags::gradients)
167 {
168 // grad x
169 eval.template gradients<0, true, false, false>(u, temp1);
170 eval.template values<1, true, false, false>(temp1, temp2);
171 eval.template values<2, true, false, false>(
172 temp2, Kokkos::subview(grad_u, Kokkos::ALL, 0));
173 }
174
175 // grad y
176 eval.template values<0, true, false, false>(u, temp1);
177 if (evaluation_flag & EvaluationFlags::gradients)
178 {
179 eval.template gradients<1, true, false, false>(temp1,
180 temp2);
181 eval.template values<2, true, false, false>(
182 temp2, Kokkos::subview(grad_u, Kokkos::ALL, 1));
183 }
184
185 // grad z: can use the values applied in x direction stored
186 // in temp1
187 eval.template values<1, true, false, false>(temp1, temp2);
188 if (evaluation_flag & EvaluationFlags::gradients)
189 eval.template gradients<2, true, false, false>(
190 temp2, Kokkos::subview(grad_u, Kokkos::ALL, 2));
191
192 // val: can use the values applied in x & y direction stored
193 // in temp2
194 if (evaluation_flag & EvaluationFlags::values)
195 eval.template values<2, true, false, false>(temp2, u);
196 }
197 else
198 Assert(false, ExcMessage("dim must not exceed 3!"));
199 }
200 }
201
202
203
204 DEAL_II_HOST_DEVICE static void
205 integrate(const unsigned int dof_handler_index,
206 const unsigned int n_components,
207 const EvaluationFlags::EvaluationFlags integration_flag,
208 const typename MatrixFree<dim, Number>::Data *data)
209 {
210 if (integration_flag == EvaluationFlags::nothing)
211 return;
212
213 // the evaluator does not need temporary storage since no in-place
214 // operation takes place in this function
215 auto scratch_for_eval =
216 Kokkos::subview(data->shared_data[dof_handler_index].scratch_pad,
217 Kokkos::make_pair(0, 0));
218 EvaluatorTensorProduct<EvaluatorVariant::evaluate_general,
219 dim,
220 fe_degree + 1,
221 n_q_points_1d,
222 Number>
223 eval(data->team_member,
224 data->precomputed_data[dof_handler_index].shape_values,
225 data->precomputed_data[dof_handler_index].shape_gradients,
226 data->precomputed_data[dof_handler_index].co_shape_gradients,
227 scratch_for_eval);
228
229 for (unsigned int c = 0; c < n_components; ++c)
230 {
231 auto u =
232 Kokkos::subview(data->shared_data[dof_handler_index].values,
233 Kokkos::ALL,
234 c);
235 auto grad_u =
236 Kokkos::subview(data->shared_data[dof_handler_index].gradients,
237 Kokkos::ALL,
238 Kokkos::ALL,
239 c);
240
241 if constexpr (dim == 1)
242 {
243 auto temp = Kokkos::subview(
244 data->shared_data[dof_handler_index].scratch_pad,
245 Kokkos::make_pair(0, fe_degree + 1));
246
247 if ((integration_flag & EvaluationFlags::values) &&
248 !(integration_flag & EvaluationFlags::gradients))
249 {
250 eval.template values<0, false, false, false>(u, temp);
251 populate_view<false>(data->team_member,
252 u,
253 temp,
254 fe_degree + 1);
255 }
256 if (integration_flag & EvaluationFlags::gradients)
257 {
258 if (integration_flag & EvaluationFlags::values)
259 {
260 eval.template values<0, false, false, false>(u, temp);
261 eval.template gradients<0, false, true, false>(
262 Kokkos::subview(grad_u, Kokkos::ALL, 0), temp);
263 populate_view<false>(data->team_member,
264 u,
265 temp,
266 fe_degree + 1);
267 }
268 else
269 eval.template gradients<0, false, false, false>(
270 Kokkos::subview(grad_u, Kokkos::ALL, 0), u);
271 }
272 }
273 else if constexpr (dim == 2)
274 {
275 constexpr int temp_size = (fe_degree + 1) * n_q_points_1d;
276 auto temp = Kokkos::subview(
277 data->shared_data[dof_handler_index].scratch_pad,
278 Kokkos::make_pair(0, temp_size));
279
280 if ((integration_flag & EvaluationFlags::values) &&
281 !(integration_flag & EvaluationFlags::gradients))
282 {
283 eval.template values<1, false, false, false>(u, temp);
284 eval.template values<0, false, false, false>(temp, u);
285 }
286 if (integration_flag & EvaluationFlags::gradients)
287 {
288 eval.template gradients<1, false, false, false>(
289 Kokkos::subview(grad_u, Kokkos::ALL, 1), temp);
290 if (integration_flag & EvaluationFlags::values)
291 eval.template values<1, false, true, false>(u, temp);
292 eval.template values<0, false, false, false>(temp, u);
293 eval.template values<1, false, false, false>(
294 Kokkos::subview(grad_u, Kokkos::ALL, 0), temp);
295 eval.template gradients<0, false, true, false>(temp, u);
296 }
297 }
298 else if constexpr (dim == 3)
299 {
300 constexpr int temp1_size = Utilities::pow(n_q_points_1d, 2) *
301 (fe_degree + 1),
302 temp2_size = Utilities::pow(fe_degree + 1, 2) *
303 n_q_points_1d;
304
305 auto temp1 = Kokkos::subview(
306 data->shared_data[dof_handler_index].scratch_pad,
307 Kokkos::make_pair(0, temp1_size));
308 auto temp2 = Kokkos::subview(
309 data->shared_data[dof_handler_index].scratch_pad,
310 Kokkos::make_pair(temp1_size, temp1_size + temp2_size));
311
312 if ((integration_flag & EvaluationFlags::values) &&
313 !(integration_flag & EvaluationFlags::gradients))
314 {
315 eval.template values<2, false, false, false>(u, temp1);
316 eval.template values<1, false, false, false>(temp1, temp2);
317 eval.template values<0, false, false, false>(temp2, u);
318 }
319 if (integration_flag & EvaluationFlags::gradients)
320 {
321 eval.template gradients<2, false, false, false>(
322 Kokkos::subview(grad_u, Kokkos::ALL, 2), temp1);
323 if (integration_flag & EvaluationFlags::values)
324 eval.template values<2, false, true, false>(u, temp1);
325 eval.template values<1, false, false, false>(temp1, temp2);
326 eval.template values<2, false, false, false>(
327 Kokkos::subview(grad_u, Kokkos::ALL, 1), temp1);
328 eval.template gradients<1, false, true, false>(temp1,
329 temp2);
330 eval.template values<0, false, false, false>(temp2, u);
331 eval.template values<2, false, false, false>(
332 Kokkos::subview(grad_u, Kokkos::ALL, 0), temp1);
333 eval.template values<1, false, false, false>(temp1, temp2);
334 eval.template gradients<0, false, true, false>(temp2, u);
335 }
336 }
337 else
338 Assert(false, ExcMessage("dim must not exceed 3!"));
339 }
340 }
341 };
342
343
344
357 template <int dim, int fe_degree, typename Number>
358 struct FEEvaluationImplCollocation
359 {
360 DEAL_II_HOST_DEVICE static void
361 evaluate(const unsigned int dof_handler_index,
362 const unsigned int n_components,
363 const EvaluationFlags::EvaluationFlags evaluation_flag,
364 const typename MatrixFree<dim, Number>::Data *data)
365 {
366 // since the dof values have already been stored in
367 // shared_data->values, there is nothing to do if the gradients are
368 // not required
369 if (!(evaluation_flag & EvaluationFlags::gradients))
370 return;
371
372 constexpr int n_points = Utilities::pow(fe_degree + 1, dim);
373 auto scratch_for_eval =
374 Kokkos::subview(data->shared_data[dof_handler_index].scratch_pad,
375 Kokkos::make_pair(0, n_points));
376
377 EvaluatorTensorProduct<EvaluatorVariant::evaluate_general,
378 dim,
379 fe_degree + 1,
380 fe_degree + 1,
381 Number>
382 eval(data->team_member,
383 data->precomputed_data[dof_handler_index].shape_values,
384 data->precomputed_data[dof_handler_index].shape_gradients,
385 data->precomputed_data[dof_handler_index].co_shape_gradients,
386 scratch_for_eval);
387
388 for (unsigned int c = 0; c < n_components; ++c)
389 {
390 auto u =
391 Kokkos::subview(data->shared_data[dof_handler_index].values,
392 Kokkos::ALL,
393 c);
394 auto grad_u =
395 Kokkos::subview(data->shared_data[dof_handler_index].gradients,
396 Kokkos::ALL,
397 Kokkos::ALL,
398 c);
399
400 eval.template co_gradients<0, true, false, false>(
401 u, Kokkos::subview(grad_u, Kokkos::ALL, 0));
402 if constexpr (dim > 1)
403 eval.template co_gradients<1, true, false, false>(
404 u, Kokkos::subview(grad_u, Kokkos::ALL, 1));
405 if constexpr (dim > 2)
406 eval.template co_gradients<2, true, false, false>(
407 u, Kokkos::subview(grad_u, Kokkos::ALL, 2));
408 }
409 }
410
411
412 DEAL_II_HOST_DEVICE static void
413 integrate(const unsigned int dof_handler_index,
414 const unsigned int n_components,
415 const EvaluationFlags::EvaluationFlags integration_flag,
416 const typename MatrixFree<dim, Number>::Data *data)
417 {
418 // since the quad values have already been stored in
419 // shared_data->values, there is nothing to do if the gradients are
420 // not required
421 if (!(integration_flag & EvaluationFlags::gradients))
422 return;
423
424 constexpr int n_points = Utilities::pow(fe_degree + 1, dim);
425 auto scratch_for_eval =
426 Kokkos::subview(data->shared_data[dof_handler_index].scratch_pad,
427 Kokkos::make_pair(0, n_points));
428
429 EvaluatorTensorProduct<EvaluatorVariant::evaluate_general,
430 dim,
431 fe_degree + 1,
432 fe_degree + 1,
433 Number>
434 eval(data->team_member,
435 data->precomputed_data[dof_handler_index].shape_values,
436 data->precomputed_data[dof_handler_index].shape_gradients,
437 data->precomputed_data[dof_handler_index].co_shape_gradients,
438 scratch_for_eval);
439
440 for (unsigned int c = 0; c < n_components; ++c)
441 {
442 auto u =
443 Kokkos::subview(data->shared_data[dof_handler_index].values,
444 Kokkos::ALL,
445 c);
446 auto grad_u =
447 Kokkos::subview(data->shared_data[dof_handler_index].gradients,
448 Kokkos::ALL,
449 Kokkos::ALL,
450 c);
451
452 if constexpr (dim == 1)
453 {
454 if (integration_flag & EvaluationFlags::values)
455 eval.template co_gradients<0, false, true, false>(
456 Kokkos::subview(grad_u, Kokkos::ALL, 0), u);
457 else
458 eval.template co_gradients<0, false, false, false>(
459 Kokkos::subview(grad_u, Kokkos::ALL, 0), u);
460 }
461 else if constexpr (dim == 2)
462 {
463 if (integration_flag & EvaluationFlags::values)
464 eval.template co_gradients<1, false, true, false>(
465 Kokkos::subview(grad_u, Kokkos::ALL, 1), u);
466 else
467 eval.template co_gradients<1, false, false, false>(
468 Kokkos::subview(grad_u, Kokkos::ALL, 1), u);
469 eval.template co_gradients<0, false, true, false>(
470 Kokkos::subview(grad_u, Kokkos::ALL, 0), u);
471 }
472 else if constexpr (dim == 3)
473 {
474 if (integration_flag & EvaluationFlags::values)
475 eval.template co_gradients<2, false, true, false>(
476 Kokkos::subview(grad_u, Kokkos::ALL, 2), u);
477 else
478 eval.template co_gradients<2, false, false, false>(
479 Kokkos::subview(grad_u, Kokkos::ALL, 2), u);
480 eval.template co_gradients<1, false, true, false>(
481 Kokkos::subview(grad_u, Kokkos::ALL, 1), u);
482 eval.template co_gradients<0, false, true, false>(
483 Kokkos::subview(grad_u, Kokkos::ALL, 0), u);
484 }
485 else
486 Assert(false, ExcMessage("dim must not exceed 3!"));
487 }
488 }
489 };
490
491
492
503 template <int dim, int fe_degree, int n_q_points_1d, typename Number>
504 struct FEEvaluationImplTransformToCollocation
505 {
506 DEAL_II_HOST_DEVICE static void
507 evaluate(const unsigned int dof_handler_index,
508 const unsigned int n_components,
509 const EvaluationFlags::EvaluationFlags evaluation_flag,
510 const typename MatrixFree<dim, Number>::Data *data)
511 {
512 constexpr int scratch_size = Utilities::pow(n_q_points_1d, dim);
513 auto scratch_for_eval =
514 Kokkos::subview(data->shared_data[dof_handler_index].scratch_pad,
515 Kokkos::make_pair(0, scratch_size));
516
517 EvaluatorTensorProduct<EvaluatorVariant::evaluate_general,
518 dim,
519 fe_degree + 1,
520 n_q_points_1d,
521 Number>
522 eval(data->team_member,
523 data->precomputed_data[dof_handler_index].shape_values,
524 data->precomputed_data[dof_handler_index].shape_gradients,
525 data->precomputed_data[dof_handler_index].co_shape_gradients,
526 scratch_for_eval);
527
528 for (unsigned int c = 0; c < n_components; ++c)
529 {
530 auto u =
531 Kokkos::subview(data->shared_data[dof_handler_index].values,
532 Kokkos::ALL,
533 c);
534 auto grad_u =
535 Kokkos::subview(data->shared_data[dof_handler_index].gradients,
536 Kokkos::ALL,
537 Kokkos::ALL,
538 c);
539
540 eval.template values<0, true, false, true>(u, u);
541 if constexpr (dim > 1)
542 eval.template values<1, true, false, true>(u, u);
543 if constexpr (dim > 2)
544 eval.template values<2, true, false, true>(u, u);
545
546 if (evaluation_flag & EvaluationFlags::gradients)
547 {
548 eval.template co_gradients<0, true, false, false>(
549 u, Kokkos::subview(grad_u, Kokkos::ALL, 0));
550 if constexpr (dim > 1)
551 eval.template co_gradients<1, true, false, false>(
552 u, Kokkos::subview(grad_u, Kokkos::ALL, 1));
553 if constexpr (dim > 2)
554 eval.template co_gradients<2, true, false, false>(
555 u, Kokkos::subview(grad_u, Kokkos::ALL, 2));
556 }
557 }
558 }
559
560
561 DEAL_II_HOST_DEVICE static void
562 integrate(const unsigned int dof_handler_index,
563 const unsigned int n_components,
564 const EvaluationFlags::EvaluationFlags integration_flag,
565 const typename MatrixFree<dim, Number>::Data *data)
566 {
567 constexpr int scratch_size = Utilities::pow(n_q_points_1d, dim);
568 auto scratch_for_eval =
569 Kokkos::subview(data->shared_data[dof_handler_index].scratch_pad,
570 Kokkos::make_pair(0, scratch_size));
571
572 EvaluatorTensorProduct<EvaluatorVariant::evaluate_general,
573 dim,
574 fe_degree + 1,
575 n_q_points_1d,
576 Number>
577 eval(data->team_member,
578 data->precomputed_data[dof_handler_index].shape_values,
579 data->precomputed_data[dof_handler_index].shape_gradients,
580 data->precomputed_data[dof_handler_index].co_shape_gradients,
581 scratch_for_eval);
582
583 for (unsigned int c = 0; c < n_components; ++c)
584 {
585 auto u =
586 Kokkos::subview(data->shared_data[dof_handler_index].values,
587 Kokkos::ALL,
588 c);
589 auto grad_u =
590 Kokkos::subview(data->shared_data[dof_handler_index].gradients,
591 Kokkos::ALL,
592 Kokkos::ALL,
593 c);
594
595 // apply derivatives in collocation space
596 if (integration_flag & EvaluationFlags::gradients)
597 {
598 if constexpr (dim == 1)
599 {
600 if (integration_flag & EvaluationFlags::values)
601 eval.template co_gradients<0, false, true, false>(
602 Kokkos::subview(grad_u, Kokkos::ALL, 0), u);
603 else
604 eval.template co_gradients<0, false, false, false>(
605 Kokkos::subview(grad_u, Kokkos::ALL, 0), u);
606 }
607 else if constexpr (dim == 2)
608 {
609 if (integration_flag & EvaluationFlags::values)
610 eval.template co_gradients<1, false, true, false>(
611 Kokkos::subview(grad_u, Kokkos::ALL, 1), u);
612 else
613 eval.template co_gradients<1, false, false, false>(
614 Kokkos::subview(grad_u, Kokkos::ALL, 1), u);
615 eval.template co_gradients<0, false, true, false>(
616 Kokkos::subview(grad_u, Kokkos::ALL, 0), u);
617 }
618 else if constexpr (dim == 3)
619 {
620 if (integration_flag & EvaluationFlags::values)
621 eval.template co_gradients<2, false, true, false>(
622 Kokkos::subview(grad_u, Kokkos::ALL, 2), u);
623 else
624 eval.template co_gradients<2, false, false, false>(
625 Kokkos::subview(grad_u, Kokkos::ALL, 2), u);
626 eval.template co_gradients<1, false, true, false>(
627 Kokkos::subview(grad_u, Kokkos::ALL, 1), u);
628 eval.template co_gradients<0, false, true, false>(
629 Kokkos::subview(grad_u, Kokkos::ALL, 0), u);
630 }
631 else
632 Assert(false, ExcMessage("dim must not exceed 3!"));
633 }
634
635 // transform back to the original space
636 if constexpr (dim > 2)
637 eval.template values<2, false, false, true>(u, u);
638 if constexpr (dim > 1)
639 eval.template values<1, false, false, true>(u, u);
640 eval.template values<0, false, false, true>(u, u);
641 }
642 }
643 };
644 } // end of namespace internal
645} // end of namespace Portable
646
647
648DEAL_II_NAMESPACE_CLOSE
649
650#endif
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:38
DEAL_II_HOST_DEVICE
#define DEAL_II_HOST_DEVICE
Definition config.h:171
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:39
evaluation_flags.h
Assert
#define Assert(cond, exc)
Definition exception_macros.h:543
StandardExceptions::ExcMessage
static ::ExceptionBase & ExcMessage(std::string arg1)
data
std::vector< index_type > data
Definition mpi.cc:734
EvaluationFlags::EvaluationFlags
EvaluationFlags
The EvaluationFlags enum.
Definition evaluation_flags.h:42
Portable::internal::use_collocation_evaluation
constexpr bool use_collocation_evaluation(const unsigned int fe_degree, const unsigned int n_q_points_1d)
Definition portable_evaluation_kernels.h:43
Utilities::pow
constexpr T pow(const T base, const int iexp)
Definition utilities.h:966
portable_matrix_free.h
portable_tensor_product_kernels.h
Portable::internal::FEEvaluationImplCollocation::integrate
static void integrate(const unsigned int dof_handler_index, const unsigned int n_components, const EvaluationFlags::EvaluationFlags integration_flag, const typename MatrixFree< dim, Number >::Data *data)
Definition portable_evaluation_kernels.h:413
Portable::internal::FEEvaluationImplCollocation::evaluate
static void evaluate(const unsigned int dof_handler_index, const unsigned int n_components, const EvaluationFlags::EvaluationFlags evaluation_flag, const typename MatrixFree< dim, Number >::Data *data)
Definition portable_evaluation_kernels.h:361
Portable::internal::FEEvaluationImplTransformToCollocation::evaluate
static void evaluate(const unsigned int dof_handler_index, const unsigned int n_components, const EvaluationFlags::EvaluationFlags evaluation_flag, const typename MatrixFree< dim, Number >::Data *data)
Definition portable_evaluation_kernels.h:507
Portable::internal::FEEvaluationImplTransformToCollocation::integrate
static void integrate(const unsigned int dof_handler_index, const unsigned int n_components, const EvaluationFlags::EvaluationFlags integration_flag, const typename MatrixFree< dim, Number >::Data *data)
Definition portable_evaluation_kernels.h:562
Portable::internal::FEEvaluationImpl::TeamHandle
Kokkos::TeamPolicy< MemorySpace::Default::kokkos_space::execution_space >::member_type TeamHandle
Definition portable_evaluation_kernels.h:66
Portable::internal::FEEvaluationImpl::evaluate
static void evaluate(const unsigned int dof_handler_index, const unsigned int n_components, const EvaluationFlags::EvaluationFlags evaluation_flag, const typename MatrixFree< dim, Number >::Data *data)
Definition portable_evaluation_kernels.h:73
Portable::internal::FEEvaluationImpl::integrate
static void integrate(const unsigned int dof_handler_index, const unsigned int n_components, const EvaluationFlags::EvaluationFlags integration_flag, const typename MatrixFree< dim, Number >::Data *data)
Definition portable_evaluation_kernels.h:205
Portable::internal::FEEvaluationImpl::SharedView
Kokkos::View< Number *, MemorySpace::Default::kokkos_space::execution_space::scratch_memory_space, Kokkos::MemoryTraits< Kokkos::Unmanaged > > SharedView
Definition portable_evaluation_kernels.h:70
Generated by doxygen 1.9.8