DDC 0.10.0
Loading...
Searching...
No Matches
spline_evaluator_2d.hpp
1// Copyright (C) The DDC development team, see COPYRIGHT.md file
2//
3// SPDX-License-Identifier: MIT
4
5#pragma once
6
7#include <array>
8#include <cstddef>
9#include <type_traits>
10
11#include <ddc/ddc.hpp>
12
13#include <Kokkos_Core.hpp>
14
15#include "deriv.hpp"
16#include "integrals.hpp"
17#include "periodic_extrapolation_rule.hpp"
18
19namespace ddc {
20
37template <
38 class ExecSpace,
39 class MemorySpace,
40 class BSplines1,
41 class BSplines2,
42 class EvaluationDDim1,
43 class EvaluationDDim2,
44 class LowerExtrapolationRule1,
45 class UpperExtrapolationRule1,
46 class LowerExtrapolationRule2,
47 class UpperExtrapolationRule2>
48class SplineEvaluator2D
49{
50public:
52 using continuous_dimension_type1 = typename BSplines1::continuous_dimension_type;
53
55 using continuous_dimension_type2 = typename BSplines2::continuous_dimension_type;
56
58 using exec_space = ExecSpace;
59
61 using memory_space = MemorySpace;
62
64 using evaluation_discrete_dimension_type1 = EvaluationDDim1;
65
67 using evaluation_discrete_dimension_type2 = EvaluationDDim2;
68
70 using bsplines_type1 = BSplines1;
71
73 using bsplines_type2 = BSplines2;
74
76 using evaluation_domain_type1 = ddc::DiscreteDomain<evaluation_discrete_dimension_type1>;
77
79 using evaluation_domain_type2 = ddc::DiscreteDomain<evaluation_discrete_dimension_type2>;
80
82 using evaluation_domain_type = ddc::DiscreteDomain<
83 evaluation_discrete_dimension_type1,
84 evaluation_discrete_dimension_type2>;
85
91 template <
92 class BatchedInterpolationDDom,
93 class = std::enable_if_t<ddc::is_discrete_domain_v<BatchedInterpolationDDom>>>
94 using batched_evaluation_domain_type = BatchedInterpolationDDom;
95
97 using spline_domain_type1 = ddc::DiscreteDomain<bsplines_type1>;
98
100 using spline_domain_type2 = ddc::DiscreteDomain<bsplines_type2>;
101
103 using spline_domain_type = ddc::DiscreteDomain<bsplines_type1, bsplines_type2>;
104
111 template <
112 class BatchedInterpolationDDom,
113 class = std::enable_if_t<ddc::is_discrete_domain_v<BatchedInterpolationDDom>>>
114 using batch_domain_type = typename ddc::remove_dims_of_t<
115 BatchedInterpolationDDom,
116 evaluation_discrete_dimension_type1,
117 evaluation_discrete_dimension_type2>;
118
125 template <
126 class BatchedInterpolationDDom,
127 class = std::enable_if_t<ddc::is_discrete_domain_v<BatchedInterpolationDDom>>>
128 using batched_spline_domain_type =
129 typename ddc::detail::convert_type_seq_to_discrete_domain_t<ddc::type_seq_replace_t<
130 ddc::to_type_seq_t<BatchedInterpolationDDom>,
131 ddc::detail::TypeSeq<
132 evaluation_discrete_dimension_type1,
133 evaluation_discrete_dimension_type2>,
134 ddc::detail::TypeSeq<bsplines_type1, bsplines_type2>>>;
135
137 using lower_extrapolation_rule_1_type = LowerExtrapolationRule1;
138
140 using upper_extrapolation_rule_1_type = UpperExtrapolationRule1;
141
143 using lower_extrapolation_rule_2_type = LowerExtrapolationRule2;
144
146 using upper_extrapolation_rule_2_type = UpperExtrapolationRule2;
147
148private:
149 LowerExtrapolationRule1 m_lower_extrap_rule_1;
150
151 UpperExtrapolationRule1 m_upper_extrap_rule_1;
152
153 LowerExtrapolationRule2 m_lower_extrap_rule_2;
154
155 UpperExtrapolationRule2 m_upper_extrap_rule_2;
156
157public:
158 static_assert(
159 std::is_same_v<LowerExtrapolationRule1,
160 typename ddc::PeriodicExtrapolationRule<continuous_dimension_type1>>
161 == bsplines_type1::is_periodic()
162 && std::is_same_v<
163 UpperExtrapolationRule1,
164 typename ddc::PeriodicExtrapolationRule<continuous_dimension_type1>>
165 == bsplines_type1::is_periodic()
166 && std::is_same_v<
167 LowerExtrapolationRule2,
168 typename ddc::PeriodicExtrapolationRule<continuous_dimension_type2>>
169 == bsplines_type2::is_periodic()
170 && std::is_same_v<
171 UpperExtrapolationRule2,
172 typename ddc::PeriodicExtrapolationRule<continuous_dimension_type2>>
173 == bsplines_type2::is_periodic(),
174 "PeriodicExtrapolationRule has to be used if and only if dimension is periodic");
175 static_assert(
176 std::is_invocable_r_v<
177 double,
178 LowerExtrapolationRule1,
179 ddc::Coordinate<continuous_dimension_type1>,
180 ddc::ChunkSpan<
181 double const,
182 spline_domain_type,
183 Kokkos::layout_right,
184 memory_space>>,
185 "LowerExtrapolationRule1::operator() has to be callable "
186 "with usual arguments.");
187 static_assert(
188 std::is_invocable_r_v<
189 double,
190 UpperExtrapolationRule1,
191 ddc::Coordinate<continuous_dimension_type1>,
192 ddc::ChunkSpan<
193 double const,
194 spline_domain_type,
195 Kokkos::layout_right,
196 memory_space>>,
197 "UpperExtrapolationRule1::operator() has to be callable "
198 "with usual arguments.");
199 static_assert(
200 std::is_invocable_r_v<
201 double,
202 LowerExtrapolationRule2,
203 ddc::Coordinate<continuous_dimension_type2>,
204 ddc::ChunkSpan<
205 double const,
206 spline_domain_type,
207 Kokkos::layout_right,
208 memory_space>>,
209 "LowerExtrapolationRule2::operator() has to be callable "
210 "with usual arguments.");
211 static_assert(
212 std::is_invocable_r_v<
213 double,
214 UpperExtrapolationRule2,
215 ddc::Coordinate<continuous_dimension_type2>,
216 ddc::ChunkSpan<
217 double const,
218 spline_domain_type,
219 Kokkos::layout_right,
220 memory_space>>,
221 "UpperExtrapolationRule2::operator() has to be callable "
222 "with usual arguments.");
223
234 explicit SplineEvaluator2D(
235 LowerExtrapolationRule1 const& lower_extrap_rule1,
236 UpperExtrapolationRule1 const& upper_extrap_rule1,
237 LowerExtrapolationRule2 const& lower_extrap_rule2,
238 UpperExtrapolationRule2 const& upper_extrap_rule2)
239 : m_lower_extrap_rule_1(lower_extrap_rule1)
240 , m_upper_extrap_rule_1(upper_extrap_rule1)
241 , m_lower_extrap_rule_2(lower_extrap_rule2)
242 , m_upper_extrap_rule_2(upper_extrap_rule2)
243 {
244 }
245
251 SplineEvaluator2D(SplineEvaluator2D const& x) = default;
252
258 SplineEvaluator2D(SplineEvaluator2D&& x) = default;
259
261 ~SplineEvaluator2D() = default;
262
269 SplineEvaluator2D& operator=(SplineEvaluator2D const& x) = default;
270
277 SplineEvaluator2D& operator=(SplineEvaluator2D&& x) = default;
278
288 lower_extrapolation_rule_1_type lower_extrapolation_rule_dim_1() const
289 {
290 return m_lower_extrap_rule_1;
291 }
292
302 upper_extrapolation_rule_1_type upper_extrapolation_rule_dim_1() const
303 {
304 return m_upper_extrap_rule_1;
305 }
306
316 lower_extrapolation_rule_2_type lower_extrapolation_rule_dim_2() const
317 {
318 return m_lower_extrap_rule_2;
319 }
320
330 upper_extrapolation_rule_2_type upper_extrapolation_rule_dim_2() const
331 {
332 return m_upper_extrap_rule_2;
333 }
334
347 template <class Layout, class... CoordsDims>
355
376 template <
377 class Layout1,
378 class Layout2,
379 class Layout3,
380 class BatchedInterpolationDDom,
381 class... CoordsDims>
382 void operator()(
383 ddc::ChunkSpan<double, BatchedInterpolationDDom, Layout1, memory_space> const
384 spline_eval,
385 ddc::ChunkSpan<
386 ddc::Coordinate<CoordsDims...> const,
387 BatchedInterpolationDDom,
388 Layout2,
389 memory_space> const coords_eval,
390 ddc::ChunkSpan<
391 double const,
392 batched_spline_domain_type<BatchedInterpolationDDom>,
393 Layout3,
394 memory_space> const spline_coef) const
395 {
396 batch_domain_type<BatchedInterpolationDDom> const batch_domain(coords_eval.domain());
397 evaluation_domain_type1 const evaluation_domain1(spline_eval.domain());
398 evaluation_domain_type2 const evaluation_domain2(spline_eval.domain());
399 ddc::parallel_for_each(
400 "ddc_splines_evaluate_2d",
401 exec_space(),
402 batch_domain,
403 KOKKOS_CLASS_LAMBDA(
404 typename batch_domain_type<
405 BatchedInterpolationDDom>::discrete_element_type const j) {
406 auto const spline_eval_2D = spline_eval[j];
407 auto const coords_eval_2D = coords_eval[j];
408 auto const spline_coef_2D = spline_coef[j];
409 for (auto const i1 : evaluation_domain1) {
410 for (auto const i2 : evaluation_domain2) {
411 spline_eval_2D(i1, i2) = eval(coords_eval_2D(i1, i2), spline_coef_2D);
412 }
413 }
414 });
415 }
416
432 template <class Layout1, class Layout2, class BatchedInterpolationDDom>
463
464#if defined(DDC_BUILD_DEPRECATED_CODE)
476 template <class Layout, class... CoordsDims>
477 [[deprecated(
478 "Use deriv(DiscreteElement<Deriv<Dim1>>(1), ...) instead)")]] KOKKOS_FUNCTION double
479 deriv_dim_1(
480 ddc::Coordinate<CoordsDims...> const& coord_eval,
481 ddc::ChunkSpan<double const, spline_domain_type, Layout, memory_space> const
482 spline_coef) const
483 {
484 return deriv(
485 ddc::DiscreteElement<Deriv<continuous_dimension_type1>>(1),
486 coord_eval,
487 spline_coef);
488 }
489
501 template <class Layout, class... CoordsDims>
502 [[deprecated(
503 "Use deriv(DiscreteElement<Deriv<Dim2>>(1), ...) instead)")]] KOKKOS_FUNCTION double
504 deriv_dim_2(
505 ddc::Coordinate<CoordsDims...> const& coord_eval,
506 ddc::ChunkSpan<double const, spline_domain_type, Layout, memory_space> const
507 spline_coef) const
508 {
509 return deriv(
510 ddc::DiscreteElement<Deriv<continuous_dimension_type2>>(1),
511 coord_eval,
512 spline_coef);
513 }
514
526 template <class Layout, class... CoordsDims>
527 [[deprecated(
528 "Use deriv(DiscreteElement<Deriv<Dim1>, Deriv<Dim2>>(1, 1), ...) "
529 "instead)")]] KOKKOS_FUNCTION double
530 deriv_1_and_2(
531 ddc::Coordinate<CoordsDims...> const& coord_eval,
532 ddc::ChunkSpan<double const, spline_domain_type, Layout, memory_space> const
533 spline_coef) const
534 {
535 return deriv(
536 ddc::DiscreteElement<
537 Deriv<continuous_dimension_type1>,
538 Deriv<continuous_dimension_type2>>(1, 1),
539 coord_eval,
540 spline_coef);
541 }
542
556 template <class InterestDim, class Layout, class... CoordsDims>
557 [[deprecated(
558 "Use deriv(DiscreteElement<Deriv<InterestDim>>(1), ...) "
559 "instead)")]] KOKKOS_FUNCTION double
560 deriv(ddc::Coordinate<CoordsDims...> const& coord_eval,
561 ddc::ChunkSpan<double const, spline_domain_type, Layout, memory_space> const spline_coef)
562 const
563 {
564 DDC_DISABLE_DEPRECATED_WARNINGS_PUSH()
565 static_assert(
566 std::is_same_v<InterestDim, continuous_dimension_type1>
567 || std::is_same_v<InterestDim, continuous_dimension_type2>);
568 if constexpr (std::is_same_v<
569 InterestDim,
570 typename evaluation_discrete_dimension_type1::
571 continuous_dimension_type>) {
572 return deriv_dim_1(coord_eval, spline_coef);
573 } else if constexpr (std::is_same_v<
574 InterestDim,
575 typename evaluation_discrete_dimension_type2::
576 continuous_dimension_type>) {
577 return deriv_dim_2(coord_eval, spline_coef);
578 }
579 DDC_DISABLE_DEPRECATED_WARNINGS_POP()
580 }
581
598 template <class InterestDim1, class InterestDim2, class Layout, class... CoordsDims>
599 [[deprecated(
600 "Use deriv(DiscreteElement<Deriv<InterestDim1, InterestDim2>>(1, 1), ...) "
601 "instead)")]] KOKKOS_FUNCTION double
602 deriv2(ddc::Coordinate<CoordsDims...> const& coord_eval,
603 ddc::ChunkSpan<double const, spline_domain_type, Layout, memory_space> const spline_coef)
604 const
605 {
606 DDC_DISABLE_DEPRECATED_WARNINGS_PUSH()
607 static_assert(
608 (std::is_same_v<
609 InterestDim1,
610 typename evaluation_discrete_dimension_type1::continuous_dimension_type>
611 && std::is_same_v<InterestDim2, continuous_dimension_type2>)
612 || (std::is_same_v<
613 InterestDim2,
614 typename evaluation_discrete_dimension_type1::continuous_dimension_type>
615 && std::is_same_v<InterestDim1, continuous_dimension_type2>));
616 return deriv_1_and_2(coord_eval, spline_coef);
617 DDC_DISABLE_DEPRECATED_WARNINGS_POP()
618 }
619
640 template <
641 class Layout1,
642 class Layout2,
643 class Layout3,
644 class BatchedInterpolationDDom,
645 class... CoordsDims>
646 [[deprecated("Use deriv(DiscreteElement<Deriv<Dim1>>(1), ...) instead)")]] void deriv_dim_1(
647 ddc::ChunkSpan<double, BatchedInterpolationDDom, Layout1, memory_space> const
648 spline_eval,
649 ddc::ChunkSpan<
650 ddc::Coordinate<CoordsDims...> const,
651 BatchedInterpolationDDom,
652 Layout2,
653 memory_space> const coords_eval,
654 ddc::ChunkSpan<
655 double const,
656 batched_spline_domain_type<BatchedInterpolationDDom>,
657 Layout3,
658 memory_space> const spline_coef) const
659 {
660 return deriv(
661 ddc::DiscreteElement<Deriv<continuous_dimension_type1>>(1),
662 spline_eval,
663 coords_eval,
664 spline_coef);
665 }
666
680 template <class Layout1, class Layout2, class BatchedInterpolationDDom>
681 [[deprecated("Use deriv(DiscreteElement<Deriv<Dim1>>(1), ...) instead)")]] void deriv_dim_1(
682 ddc::ChunkSpan<double, BatchedInterpolationDDom, Layout1, memory_space> const
683 spline_eval,
684 ddc::ChunkSpan<
685 double const,
686 batched_spline_domain_type<BatchedInterpolationDDom>,
687 Layout2,
688 memory_space> const spline_coef) const
689 {
690 return deriv(
691 ddc::DiscreteElement<Deriv<continuous_dimension_type1>>(1),
692 spline_eval,
693 spline_coef);
694 }
695
714 template <
715 class Layout1,
716 class Layout2,
717 class Layout3,
718 class BatchedInterpolationDDom,
719 class... CoordsDims>
720 [[deprecated("Use deriv(DiscreteElement<Deriv<Dim2>>(1), ...) instead)")]] void deriv_dim_2(
721 ddc::ChunkSpan<double, BatchedInterpolationDDom, Layout1, memory_space> const
722 spline_eval,
723 ddc::ChunkSpan<
724 ddc::Coordinate<CoordsDims...> const,
725 BatchedInterpolationDDom,
726 Layout2,
727 memory_space> const coords_eval,
728 ddc::ChunkSpan<
729 double const,
730 batched_spline_domain_type<BatchedInterpolationDDom>,
731 Layout3,
732 memory_space> const spline_coef) const
733 {
734 return deriv(
735 ddc::DiscreteElement<Deriv<continuous_dimension_type2>>(1),
736 spline_eval,
737 coords_eval,
738 spline_coef);
739 }
740
754 template <class Layout1, class Layout2, class BatchedInterpolationDDom>
755 [[deprecated("Use deriv(DiscreteElement<Deriv<Dim2>>(1), ...) instead)")]] void deriv_dim_2(
756 ddc::ChunkSpan<double, BatchedInterpolationDDom, Layout1, memory_space> const
757 spline_eval,
758 ddc::ChunkSpan<
759 double const,
760 batched_spline_domain_type<BatchedInterpolationDDom>,
761 Layout2,
762 memory_space> const spline_coef) const
763 {
764 return deriv(
765 ddc::DiscreteElement<Deriv<continuous_dimension_type2>>(1),
766 spline_eval,
767 spline_coef);
768 }
769
788 template <
789 class Layout1,
790 class Layout2,
791 class Layout3,
792 class BatchedInterpolationDDom,
793 class... CoordsDims>
794 [[deprecated("Use deriv(DiscreteElement<Deriv<Dim1>, Deriv<Dim2>>(1, 1), ...) instead)")]] void
795 deriv_1_and_2(
796 ddc::ChunkSpan<double, BatchedInterpolationDDom, Layout1, memory_space> const
797 spline_eval,
798 ddc::ChunkSpan<
799 ddc::Coordinate<CoordsDims...> const,
800 BatchedInterpolationDDom,
801 Layout2,
802 memory_space> const coords_eval,
803 ddc::ChunkSpan<
804 double const,
805 batched_spline_domain_type<BatchedInterpolationDDom>,
806 Layout3,
807 memory_space> const spline_coef) const
808 {
809 return deriv(
810 ddc::DiscreteElement<
811 Deriv<continuous_dimension_type1>,
812 Deriv<continuous_dimension_type2>>(1, 1),
813 spline_eval,
814 coords_eval,
815 spline_coef);
816 }
817
831 template <class Layout1, class Layout2, class BatchedInterpolationDDom>
832 [[deprecated("Use deriv(DiscreteElement<Deriv<Dim1>, Deriv<Dim2>>(1, 1), ...) instead)")]] void
833 deriv_1_and_2(
834 ddc::ChunkSpan<double, BatchedInterpolationDDom, Layout1, memory_space> const
835 spline_eval,
836 ddc::ChunkSpan<
837 double const,
838 batched_spline_domain_type<BatchedInterpolationDDom>,
839 Layout2,
840 memory_space> const spline_coef) const
841 {
842 return deriv(
843 ddc::DiscreteElement<
844 Deriv<continuous_dimension_type1>,
845 Deriv<continuous_dimension_type2>>(1, 1),
846 spline_eval,
847 spline_coef);
848 }
849
869 template <
870 class InterestDim,
871 class Layout1,
872 class Layout2,
873 class Layout3,
874 class BatchedInterpolationDDom,
875 class... CoordsDims>
876 [[deprecated("Use deriv(DiscreteElement<Deriv<InterestDim>>(1), ...) instead)")]] void deriv(
877 ddc::ChunkSpan<double, BatchedInterpolationDDom, Layout1, memory_space> const
878 spline_eval,
879 ddc::ChunkSpan<
880 ddc::Coordinate<CoordsDims...> const,
881 BatchedInterpolationDDom,
882 Layout2,
883 memory_space> const coords_eval,
884 ddc::ChunkSpan<
885 double const,
886 batched_spline_domain_type<BatchedInterpolationDDom>,
887 Layout3,
888 memory_space> const spline_coef) const
889 {
890 DDC_DISABLE_DEPRECATED_WARNINGS_PUSH()
891 static_assert(
892 std::is_same_v<
893 InterestDim,
894 typename evaluation_discrete_dimension_type1::continuous_dimension_type>
895 || std::is_same_v<InterestDim, continuous_dimension_type2>);
896 if constexpr (std::is_same_v<
897 InterestDim,
898 typename evaluation_discrete_dimension_type1::
899 continuous_dimension_type>) {
900 return deriv_dim_1(spline_eval, coords_eval, spline_coef);
901 } else if constexpr (std::is_same_v<
902 InterestDim,
903 typename evaluation_discrete_dimension_type2::
904 continuous_dimension_type>) {
905 return deriv_dim_2(spline_eval, coords_eval, spline_coef);
906 }
907 DDC_DISABLE_DEPRECATED_WARNINGS_POP()
908 }
909
924 template <class InterestDim, class Layout1, class Layout2, class BatchedInterpolationDDom>
925 [[deprecated("Use deriv(DiscreteElement<Deriv<InterestDim>>(1), ...) instead)")]] void deriv(
926 ddc::ChunkSpan<double, BatchedInterpolationDDom, Layout1, memory_space> const
927 spline_eval,
928 ddc::ChunkSpan<
929 double const,
930 batched_spline_domain_type<BatchedInterpolationDDom>,
931 Layout2,
932 memory_space> const spline_coef) const
933 {
934 DDC_DISABLE_DEPRECATED_WARNINGS_PUSH()
935 static_assert(
936 std::is_same_v<
937 InterestDim,
938 typename evaluation_discrete_dimension_type1::continuous_dimension_type>
939 || std::is_same_v<InterestDim, continuous_dimension_type2>);
940 if constexpr (std::is_same_v<
941 InterestDim,
942 typename evaluation_discrete_dimension_type1::
943 continuous_dimension_type>) {
944 return deriv_dim_1(spline_eval, spline_coef);
945 } else if constexpr (std::is_same_v<
946 InterestDim,
947 typename evaluation_discrete_dimension_type2::
948 continuous_dimension_type>) {
949 return deriv_dim_2(spline_eval, spline_coef);
950 }
951 DDC_DISABLE_DEPRECATED_WARNINGS_POP()
952 }
953
977 template <
978 class InterestDim1,
979 class InterestDim2,
980 class Layout1,
981 class Layout2,
982 class Layout3,
983 class BatchedInterpolationDDom,
984 class... CoordsDims>
985 [[deprecated(
986 "Use deriv(DiscreteElement<Deriv<InterestDim1>, Deriv<InterestDim2>>(1, 1), ...) "
987 "instead)")]] void
988 deriv2(ddc::ChunkSpan<double, BatchedInterpolationDDom, Layout1, memory_space> const
989 spline_eval,
990 ddc::ChunkSpan<
991 ddc::Coordinate<CoordsDims...> const,
992 BatchedInterpolationDDom,
993 Layout2,
994 memory_space> const coords_eval,
995 ddc::ChunkSpan<
996 double const,
997 batched_spline_domain_type<BatchedInterpolationDDom>,
998 Layout3,
999 memory_space> const spline_coef) const
1000 {
1001 DDC_DISABLE_DEPRECATED_WARNINGS_PUSH()
1002 static_assert(
1003 (std::is_same_v<
1004 InterestDim1,
1005 typename evaluation_discrete_dimension_type1::continuous_dimension_type>
1006 && std::is_same_v<InterestDim2, continuous_dimension_type2>)
1007 || (std::is_same_v<
1008 InterestDim2,
1009 typename evaluation_discrete_dimension_type1::continuous_dimension_type>
1010 && std::is_same_v<InterestDim1, continuous_dimension_type2>));
1011 return deriv_1_and_2(spline_eval, coords_eval, spline_coef);
1012 DDC_DISABLE_DEPRECATED_WARNINGS_POP()
1013 }
1014
1033 template <
1034 class InterestDim1,
1035 class InterestDim2,
1036 class Layout1,
1037 class Layout2,
1038 class BatchedInterpolationDDom>
1039 [[deprecated(
1040 "Use deriv(DiscreteElement<Deriv<InterestDim1>, Deriv<InterestDim2>>(1, 1), ...) "
1041 "instead)")]] void
1042 deriv2(ddc::ChunkSpan<double, BatchedInterpolationDDom, Layout1, memory_space> const
1043 spline_eval,
1044 ddc::ChunkSpan<
1045 double const,
1046 batched_spline_domain_type<BatchedInterpolationDDom>,
1047 Layout2,
1048 memory_space> const spline_coef) const
1049 {
1050 DDC_DISABLE_DEPRECATED_WARNINGS_PUSH()
1051 static_assert(
1052 (std::is_same_v<
1053 InterestDim1,
1054 typename evaluation_discrete_dimension_type1::continuous_dimension_type>
1055 && std::is_same_v<InterestDim2, continuous_dimension_type2>)
1056 || (std::is_same_v<
1057 InterestDim2,
1058 typename evaluation_discrete_dimension_type1::continuous_dimension_type>
1059 && std::is_same_v<InterestDim1, continuous_dimension_type2>));
1060 return deriv_1_and_2(spline_eval, spline_coef);
1061 DDC_DISABLE_DEPRECATED_WARNINGS_POP()
1062 }
1063#endif
1064
1078 template <class DElem, class Layout, class... CoordsDims>
1087
1110 template <
1111 class DElem,
1112 class Layout1,
1113 class Layout2,
1114 class Layout3,
1115 class BatchedInterpolationDDom,
1116 class... CoordsDims>
1117 void deriv(
1118 DElem const& deriv_order,
1119 ddc::ChunkSpan<double, BatchedInterpolationDDom, Layout1, memory_space> const
1120 spline_eval,
1121 ddc::ChunkSpan<
1122 ddc::Coordinate<CoordsDims...> const,
1123 BatchedInterpolationDDom,
1124 Layout2,
1125 memory_space> const coords_eval,
1126 ddc::ChunkSpan<
1127 double const,
1128 batched_spline_domain_type<BatchedInterpolationDDom>,
1129 Layout3,
1130 memory_space> const spline_coef) const
1131 {
1132 static_assert(is_discrete_element_v<DElem>);
1133
1134 batch_domain_type<BatchedInterpolationDDom> const batch_domain(coords_eval.domain());
1135 evaluation_domain_type1 const evaluation_domain1(spline_eval.domain());
1136 evaluation_domain_type2 const evaluation_domain2(spline_eval.domain());
1137 ddc::parallel_for_each(
1138 "ddc_splines_differentiate_2d",
1139 exec_space(),
1140 batch_domain,
1141 KOKKOS_CLASS_LAMBDA(
1142 typename batch_domain_type<
1143 BatchedInterpolationDDom>::discrete_element_type const j) {
1144 auto const spline_eval_2D = spline_eval[j];
1145 auto const coords_eval_2D = coords_eval[j];
1146 auto const spline_coef_2D = spline_coef[j];
1147 for (auto const i1 : evaluation_domain1) {
1148 for (auto const i2 : evaluation_domain2) {
1149 spline_eval_2D(i1, i2) = eval_no_bc(
1150 deriv_order,
1151 coords_eval_2D(i1, i2),
1152 spline_coef_2D);
1153 }
1154 }
1155 });
1156 }
1157
1173 template <class DElem, class Layout1, class Layout2, class BatchedInterpolationDDom>
1174 void deriv(
1175 DElem const& deriv_order,
1176 ddc::ChunkSpan<double, BatchedInterpolationDDom, Layout1, memory_space> const
1177 spline_eval,
1178 ddc::ChunkSpan<
1179 double const,
1180 batched_spline_domain_type<BatchedInterpolationDDom>,
1181 Layout2,
1182 memory_space> const spline_coef) const
1183 {
1184 static_assert(is_discrete_element_v<DElem>);
1185
1186 batch_domain_type<BatchedInterpolationDDom> const batch_domain(spline_eval.domain());
1187 evaluation_domain_type1 const evaluation_domain1(spline_eval.domain());
1188 evaluation_domain_type2 const evaluation_domain2(spline_eval.domain());
1189 ddc::parallel_for_each(
1190 "ddc_splines_differentiate_2d",
1191 exec_space(),
1192 batch_domain,
1193 KOKKOS_CLASS_LAMBDA(
1194 typename batch_domain_type<
1195 BatchedInterpolationDDom>::discrete_element_type const j) {
1196 auto const spline_eval_2D = spline_eval[j];
1197 auto const spline_coef_2D = spline_coef[j];
1198 for (auto const i1 : evaluation_domain1) {
1199 for (auto const i2 : evaluation_domain2) {
1200 ddc::Coordinate<continuous_dimension_type1, continuous_dimension_type2>
1201 coord_eval_2D(ddc::coordinate(i1), ddc::coordinate(i2));
1202 spline_eval_2D(i1, i2)
1203 = eval_no_bc(deriv_order, coord_eval_2D, spline_coef_2D);
1204 }
1205 }
1206 });
1207 }
1208
1222 template <class Layout1, class Layout2, class BatchedDDom, class BatchedSplineDDom>
1223 void integrate(
1224 ddc::ChunkSpan<double, BatchedDDom, Layout1, memory_space> const integrals,
1225 ddc::ChunkSpan<double const, BatchedSplineDDom, Layout2, memory_space> const
1226 spline_coef) const
1227 {
1228 static_assert(
1229 ddc::type_seq_contains_v<
1230 ddc::detail::TypeSeq<bsplines_type1, bsplines_type2>,
1231 to_type_seq_t<BatchedSplineDDom>>,
1232 "The spline coefficients domain must contain the bsplines dimensions");
1233 using batch_domain_type
1234 = ddc::remove_dims_of_t<BatchedSplineDDom, bsplines_type1, bsplines_type2>;
1235 static_assert(
1236 std::is_same_v<batch_domain_type, BatchedDDom>,
1237 "The integrals domain must only contain the batch dimensions");
1238
1239 batch_domain_type batch_domain(integrals.domain());
1240 ddc::Chunk values1_alloc(
1241 ddc::DiscreteDomain<bsplines_type1>(spline_coef.domain()),
1242 ddc::KokkosAllocator<double, memory_space>());
1243 ddc::ChunkSpan values1 = values1_alloc.span_view();
1244 ddc::integrals(exec_space(), values1);
1245 ddc::Chunk values2_alloc(
1246 ddc::DiscreteDomain<bsplines_type2>(spline_coef.domain()),
1247 ddc::KokkosAllocator<double, memory_space>());
1248 ddc::ChunkSpan values2 = values2_alloc.span_view();
1249 ddc::integrals(exec_space(), values2);
1250
1251 ddc::parallel_for_each(
1252 "ddc_splines_integrate_bsplines",
1253 exec_space(),
1254 batch_domain,
1255 KOKKOS_LAMBDA(typename batch_domain_type::discrete_element_type const j) {
1256 integrals(j) = 0;
1257 for (typename spline_domain_type1::discrete_element_type const i1 :
1258 values1.domain()) {
1259 for (typename spline_domain_type2::discrete_element_type const i2 :
1260 values2.domain()) {
1261 integrals(j) += spline_coef(i1, i2, j) * values1(i1) * values2(i2);
1262 }
1263 }
1264 });
1265 }
1266
1267private:
1283 template <class Layout, class... CoordsDims>
1284 KOKKOS_INLINE_FUNCTION double eval(
1285 ddc::Coordinate<CoordsDims...> coord_eval,
1286 ddc::ChunkSpan<double const, spline_domain_type, Layout, memory_space> const
1287 spline_coef) const
1288 {
1289 using Dim1 = continuous_dimension_type1;
1290 using Dim2 = continuous_dimension_type2;
1291 if constexpr (bsplines_type1::is_periodic()) {
1292 if (ddc::get<Dim1>(coord_eval) < ddc::discrete_space<bsplines_type1>().rmin()
1293 || ddc::get<Dim1>(coord_eval) > ddc::discrete_space<bsplines_type1>().rmax()) {
1294 ddc::get<Dim1>(coord_eval)
1295 -= Kokkos::floor(
1296 (ddc::get<Dim1>(coord_eval)
1297 - ddc::discrete_space<bsplines_type1>().rmin())
1298 / ddc::discrete_space<bsplines_type1>().length())
1299 * ddc::discrete_space<bsplines_type1>().length();
1300 }
1301 }
1302 if constexpr (bsplines_type2::is_periodic()) {
1303 if (ddc::get<Dim2>(coord_eval) < ddc::discrete_space<bsplines_type2>().rmin()
1304 || ddc::get<Dim2>(coord_eval) > ddc::discrete_space<bsplines_type2>().rmax()) {
1305 ddc::get<Dim2>(coord_eval)
1306 -= Kokkos::floor(
1307 (ddc::get<Dim2>(coord_eval)
1308 - ddc::discrete_space<bsplines_type2>().rmin())
1309 / ddc::discrete_space<bsplines_type2>().length())
1310 * ddc::discrete_space<bsplines_type2>().length();
1311 }
1312 }
1313 if constexpr (!bsplines_type1::is_periodic()) {
1314 if (ddc::get<Dim1>(coord_eval) < ddc::discrete_space<bsplines_type1>().rmin()) {
1315 return m_lower_extrap_rule_1(coord_eval, spline_coef);
1316 }
1317 if (ddc::get<Dim1>(coord_eval) > ddc::discrete_space<bsplines_type1>().rmax()) {
1318 return m_upper_extrap_rule_1(coord_eval, spline_coef);
1319 }
1320 }
1321 if constexpr (!bsplines_type2::is_periodic()) {
1322 if (ddc::get<Dim2>(coord_eval) < ddc::discrete_space<bsplines_type2>().rmin()) {
1323 return m_lower_extrap_rule_2(coord_eval, spline_coef);
1324 }
1325 if (ddc::get<Dim2>(coord_eval) > ddc::discrete_space<bsplines_type2>().rmax()) {
1326 return m_upper_extrap_rule_2(coord_eval, spline_coef);
1327 }
1328 }
1329 return eval_no_bc(
1330 ddc::DiscreteElement<>(),
1331 ddc::Coordinate<continuous_dimension_type1, continuous_dimension_type2>(
1332 ddc::get<Dim1>(coord_eval),
1333 ddc::get<Dim2>(coord_eval)),
1334 spline_coef);
1335 }
1336
1345 template <class... DerivDims, class Layout, class... CoordsDims>
1346 KOKKOS_INLINE_FUNCTION double eval_no_bc(
1347 ddc::DiscreteElement<DerivDims...> const& deriv_order,
1348 ddc::Coordinate<CoordsDims...> const& coord_eval,
1349 ddc::ChunkSpan<double const, spline_domain_type, Layout, memory_space> const
1350 spline_coef) const
1351 {
1352 using deriv_dim1 = ddc::Deriv<continuous_dimension_type1>;
1353 using deriv_dim2 = ddc::Deriv<continuous_dimension_type2>;
1354 using deriv_dims = ddc::detail::TypeSeq<DerivDims...>;
1355
1356 // Check that the tags are valid
1357 static_assert(
1358 (in_tags_v<DerivDims, ddc::detail::TypeSeq<deriv_dim1, deriv_dim2>> && ...),
1359 "The only valid dimensions for deriv_order are Deriv<Dim1> and Deriv<Dim2>");
1360
1361 ddc::DiscreteElement<bsplines_type1> jmin1;
1362 ddc::DiscreteElement<bsplines_type2> jmin2;
1363
1364 std::array<double, bsplines_type1::degree() + 1> vals1_ptr;
1365 Kokkos::mdspan<double, Kokkos::extents<std::size_t, bsplines_type1::degree() + 1>> const
1366 vals1(vals1_ptr.data());
1367 std::array<double, bsplines_type2::degree() + 1> vals2_ptr;
1368 Kokkos::mdspan<double, Kokkos::extents<std::size_t, bsplines_type2::degree() + 1>> const
1369 vals2(vals2_ptr.data());
1370 ddc::Coordinate<continuous_dimension_type1> const coord_eval_interest1(coord_eval);
1371 ddc::Coordinate<continuous_dimension_type2> const coord_eval_interest2(coord_eval);
1372
1373 if constexpr (!in_tags_v<deriv_dim1, deriv_dims>) {
1374 jmin1 = ddc::discrete_space<bsplines_type1>().eval_basis(vals1, coord_eval_interest1);
1375 } else {
1376 auto const order1 = deriv_order.template uid<deriv_dim1>();
1377 KOKKOS_ASSERT(order1 > 0 && order1 <= bsplines_type1::degree())
1378
1379 std::array<double, (bsplines_type1::degree() + 1) * (bsplines_type1::degree() + 1)>
1380 derivs1_ptr;
1381 Kokkos::mdspan<
1382 double,
1383 Kokkos::extents<
1384 std::size_t,
1385 bsplines_type1::degree() + 1,
1386 Kokkos::dynamic_extent>> const derivs1(derivs1_ptr.data(), order1 + 1);
1387
1388 jmin1 = ddc::discrete_space<bsplines_type1>()
1389 .eval_basis_and_n_derivs(derivs1, coord_eval_interest1, order1);
1390
1391 for (std::size_t i = 0; i < bsplines_type1::degree() + 1; ++i) {
1392 vals1[i] = DDC_MDSPAN_ACCESS_OP(derivs1, i, order1);
1393 }
1394 }
1395
1396 if constexpr (!in_tags_v<deriv_dim2, deriv_dims>) {
1397 jmin2 = ddc::discrete_space<bsplines_type2>().eval_basis(vals2, coord_eval_interest2);
1398 } else {
1399 auto const order2 = deriv_order.template uid<deriv_dim2>();
1400 KOKKOS_ASSERT(order2 > 0 && order2 <= bsplines_type2::degree())
1401
1402 std::array<double, (bsplines_type2::degree() + 1) * (bsplines_type2::degree() + 1)>
1403 derivs2_ptr;
1404 Kokkos::mdspan<
1405 double,
1406 Kokkos::extents<
1407 std::size_t,
1408 bsplines_type2::degree() + 1,
1409 Kokkos::dynamic_extent>> const derivs2(derivs2_ptr.data(), order2 + 1);
1410
1411 jmin2 = ddc::discrete_space<bsplines_type2>()
1412 .eval_basis_and_n_derivs(derivs2, coord_eval_interest2, order2);
1413
1414 for (std::size_t i = 0; i < bsplines_type2::degree() + 1; ++i) {
1415 vals2[i] = DDC_MDSPAN_ACCESS_OP(derivs2, i, order2);
1416 }
1417 }
1418
1419 double y = 0.0;
1420 for (std::size_t i = 0; i < bsplines_type1::degree() + 1; ++i) {
1421 for (std::size_t j = 0; j < bsplines_type2::degree() + 1; ++j) {
1422 y += spline_coef(
1423 ddc::DiscreteElement<
1424 bsplines_type1,
1425 bsplines_type2>(jmin1 + i, jmin2 + j))
1426 * vals1[i] * vals2[j];
1427 }
1428 }
1429 return y;
1430 }
1431};
1432
1433} // namespace ddc
ddc::ChunkSpan::span_view
KOKKOS_FUNCTION constexpr span_type span_view() const
Definition chunk_span.hpp:415
ddc::DiscreteElement
A DiscreteElement identifies an element of the discrete dimension.
Definition discrete_element.hpp:161
ddc::SplineEvaluator2D
A class to evaluate, differentiate or integrate a 2D spline function.
Definition spline_evaluator_2d.hpp:49
ddc::SplineEvaluator2D::operator()
void operator()(ddc::ChunkSpan< double, BatchedInterpolationDDom, Layout1, memory_space > const spline_eval, ddc::ChunkSpan< double const, batched_spline_domain_type< BatchedInterpolationDDom >, Layout2, memory_space > const spline_coef) const
Evaluate 2D spline function (described by its spline coefficients) on a mesh.
Definition spline_evaluator_2d.hpp:433
ddc::SplineEvaluator2D::SplineEvaluator2D
SplineEvaluator2D(SplineEvaluator2D &&x)=default
Move-constructs.
ddc::SplineEvaluator2D::lower_extrapolation_rule_2_type
LowerExtrapolationRule2 lower_extrapolation_rule_2_type
The type of the extrapolation rule at the lower boundary along the second dimension.
Definition spline_evaluator_2d.hpp:143
ddc::SplineEvaluator2D::lower_extrapolation_rule_dim_1
lower_extrapolation_rule_1_type lower_extrapolation_rule_dim_1() const
Get the lower extrapolation rule along the first dimension.
Definition spline_evaluator_2d.hpp:288
ddc::SplineEvaluator2D::batched_spline_domain_type
typename ddc::detail::convert_type_seq_to_discrete_domain_t< ddc::type_seq_replace_t< ddc::to_type_seq_t< BatchedInterpolationDDom >, ddc::detail::TypeSeq< evaluation_discrete_dimension_type1, evaluation_discrete_dimension_type2 >, ddc::detail::TypeSeq< bsplines_type1, bsplines_type2 > > > batched_spline_domain_type
The type of the whole spline domain (cartesian product of 2D spline domain and batch domain) preservi...
Definition spline_evaluator_2d.hpp:134
ddc::SplineEvaluator2D::bsplines_type1
BSplines1 bsplines_type1
The discrete dimension representing the B-splines along first dimension.
Definition spline_evaluator_2d.hpp:70
ddc::SplineEvaluator2D::memory_space
MemorySpace memory_space
The type of the Kokkos memory space used by this class.
Definition spline_evaluator_2d.hpp:61
ddc::SplineEvaluator2D::bsplines_type2
BSplines2 bsplines_type2
The discrete dimension representing the B-splines along second dimension.
Definition spline_evaluator_2d.hpp:73
ddc::SplineEvaluator2D::upper_extrapolation_rule_1_type
UpperExtrapolationRule1 upper_extrapolation_rule_1_type
The type of the extrapolation rule at the upper boundary along the first dimension.
Definition spline_evaluator_2d.hpp:140
ddc::SplineEvaluator2D::operator=
SplineEvaluator2D & operator=(SplineEvaluator2D const &x)=default
Copy-assigns.
ddc::SplineEvaluator2D::deriv
void deriv(DElem const &deriv_order, ddc::ChunkSpan< double, BatchedInterpolationDDom, Layout1, memory_space > const spline_eval, ddc::ChunkSpan< ddc::Coordinate< CoordsDims... > const, BatchedInterpolationDDom, Layout2, memory_space > const coords_eval, ddc::ChunkSpan< double const, batched_spline_domain_type< BatchedInterpolationDDom >, Layout3, memory_space > const spline_coef) const
Differentiate 2D spline function (described by its spline coefficients) on a mesh along the dimension...
Definition spline_evaluator_2d.hpp:1117
ddc::SplineEvaluator2D::SplineEvaluator2D
SplineEvaluator2D(SplineEvaluator2D const &x)=default
Copy-constructs.
ddc::SplineEvaluator2D::~SplineEvaluator2D
~SplineEvaluator2D()=default
Destructs.
ddc::SplineEvaluator2D::deriv
KOKKOS_FUNCTION double deriv(DElem const &deriv_order, ddc::Coordinate< CoordsDims... > const &coord_eval, ddc::ChunkSpan< double const, spline_domain_type, Layout, memory_space > const spline_coef) const
Differentiate 2D spline function (described by its spline coefficients) at a given coordinate along t...
Definition spline_evaluator_2d.hpp:1079
ddc::SplineEvaluator2D::continuous_dimension_type2
typename BSplines2::continuous_dimension_type continuous_dimension_type2
The type of the second evaluation continuous dimension used by this class.
Definition spline_evaluator_2d.hpp:55
ddc::SplineEvaluator2D::batch_domain_type
typename ddc::remove_dims_of_t< BatchedInterpolationDDom, evaluation_discrete_dimension_type1, evaluation_discrete_dimension_type2 > batch_domain_type
The type of the batch domain (obtained by removing the dimensions of interest from the whole domain).
Definition spline_evaluator_2d.hpp:117
ddc::SplineEvaluator2D::lower_extrapolation_rule_1_type
LowerExtrapolationRule1 lower_extrapolation_rule_1_type
The type of the extrapolation rule at the lower boundary along the first dimension.
Definition spline_evaluator_2d.hpp:137
ddc::SplineEvaluator2D::spline_domain_type
ddc::DiscreteDomain< bsplines_type1, bsplines_type2 > spline_domain_type
The type of the 2D spline domain corresponding to the dimensions of interest.
Definition spline_evaluator_2d.hpp:103
ddc::SplineEvaluator2D::deriv
void deriv(DElem const &deriv_order, ddc::ChunkSpan< double, BatchedInterpolationDDom, Layout1, memory_space > const spline_eval, ddc::ChunkSpan< double const, batched_spline_domain_type< BatchedInterpolationDDom >, Layout2, memory_space > const spline_coef) const
Differentiate 2D spline function (described by its spline coefficients) on a mesh along the dimension...
Definition spline_evaluator_2d.hpp:1174
ddc::SplineEvaluator2D::continuous_dimension_type1
typename BSplines1::continuous_dimension_type continuous_dimension_type1
The type of the first evaluation continuous dimension used by this class.
Definition spline_evaluator_2d.hpp:52
ddc::SplineEvaluator2D::evaluation_discrete_dimension_type2
EvaluationDDim2 evaluation_discrete_dimension_type2
The type of the second discrete dimension of interest used by this class.
Definition spline_evaluator_2d.hpp:67
ddc::SplineEvaluator2D::batched_evaluation_domain_type
BatchedInterpolationDDom batched_evaluation_domain_type
The type of the whole domain representing evaluation points.
Definition spline_evaluator_2d.hpp:94
ddc::SplineEvaluator2D::integrate
void integrate(ddc::ChunkSpan< double, BatchedDDom, Layout1, memory_space > const integrals, ddc::ChunkSpan< double const, BatchedSplineDDom, Layout2, memory_space > const spline_coef) const
Perform batched 2D integrations of a spline function (described by its spline coefficients) along the...
Definition spline_evaluator_2d.hpp:1223
ddc::SplineEvaluator2D::evaluation_discrete_dimension_type1
EvaluationDDim1 evaluation_discrete_dimension_type1
The type of the first discrete dimension of interest used by this class.
Definition spline_evaluator_2d.hpp:64
ddc::SplineEvaluator2D::upper_extrapolation_rule_dim_2
upper_extrapolation_rule_2_type upper_extrapolation_rule_dim_2() const
Get the upper extrapolation rule along the second dimension.
Definition spline_evaluator_2d.hpp:330
ddc::SplineEvaluator2D::upper_extrapolation_rule_dim_1
upper_extrapolation_rule_1_type upper_extrapolation_rule_dim_1() const
Get the upper extrapolation rule along the first dimension.
Definition spline_evaluator_2d.hpp:302
ddc::SplineEvaluator2D::lower_extrapolation_rule_dim_2
lower_extrapolation_rule_2_type lower_extrapolation_rule_dim_2() const
Get the lower extrapolation rule along the second dimension.
Definition spline_evaluator_2d.hpp:316
ddc::SplineEvaluator2D::operator=
SplineEvaluator2D & operator=(SplineEvaluator2D &&x)=default
Move-assigns.
ddc::SplineEvaluator2D::operator()
KOKKOS_FUNCTION double operator()(ddc::Coordinate< CoordsDims... > const &coord_eval, ddc::ChunkSpan< double const, spline_domain_type, Layout, memory_space > const spline_coef) const
Evaluate 2D spline function (described by its spline coefficients) at a given coordinate.
Definition spline_evaluator_2d.hpp:348
ddc::SplineEvaluator2D::operator()
void operator()(ddc::ChunkSpan< double, BatchedInterpolationDDom, Layout1, memory_space > const spline_eval, ddc::ChunkSpan< ddc::Coordinate< CoordsDims... > const, BatchedInterpolationDDom, Layout2, memory_space > const coords_eval, ddc::ChunkSpan< double const, batched_spline_domain_type< BatchedInterpolationDDom >, Layout3, memory_space > const spline_coef) const
Evaluate 2D spline function (described by its spline coefficients) on a mesh.
Definition spline_evaluator_2d.hpp:382
ddc::SplineEvaluator2D::exec_space
ExecSpace exec_space
The type of the Kokkos execution space used by this class.
Definition spline_evaluator_2d.hpp:58
ddc::SplineEvaluator2D::upper_extrapolation_rule_2_type
UpperExtrapolationRule2 upper_extrapolation_rule_2_type
The type of the extrapolation rule at the upper boundary along the second dimension.
Definition spline_evaluator_2d.hpp:146
ddc::SplineEvaluator2D::SplineEvaluator2D
SplineEvaluator2D(LowerExtrapolationRule1 const &lower_extrap_rule1, UpperExtrapolationRule1 const &upper_extrap_rule1, LowerExtrapolationRule2 const &lower_extrap_rule2, UpperExtrapolationRule2 const &upper_extrap_rule2)
Build a SplineEvaluator2D acting on batched_spline_domain.
Definition spline_evaluator_2d.hpp:234
ddc
The top-level namespace of DDC.
Definition aligned_allocator.hpp:11
ddc::enable_chunk
constexpr bool enable_chunk
Definition chunk_traits.hpp:16
ddc::rmax
KOKKOS_FUNCTION Coordinate< typename DDim::continuous_dimension_type > rmax(DiscreteDomain< DDim > const &d)
Definition non_uniform_point_sampling.hpp:241
ddc::integrals
ddc::ChunkSpan< double, ddc::DiscreteDomain< DDim >, Layout, MemorySpace > integrals(ExecSpace const &execution_space, ddc::ChunkSpan< double, ddc::DiscreteDomain< DDim >, Layout, MemorySpace > int_vals)
Compute the integrals of the B-splines.
Definition integrals.hpp:166
ddc::remove_dims_of_t
decltype(remove_dims_of< DDims... >(std::declval< DDom >())) remove_dims_of_t
Definition discrete_domain.hpp:537
ddc::coordinate
KOKKOS_FUNCTION Coordinate< typename DDim::continuous_dimension_type... > coordinate(DiscreteElement< DDim... > const &c)
Definition coordinate.hpp:33
ddc::extents
KOKKOS_FUNCTION constexpr DiscreteVector< QueryDDims... > extents(DiscreteDomain< DDims... > const &domain) noexcept
Definition discrete_domain.hpp:588
ddc::rmin
KOKKOS_FUNCTION Coordinate< typename DDim::continuous_dimension_type > rmin(DiscreteDomain< DDim > const &d)
Definition non_uniform_point_sampling.hpp:234
ddc::Coordinate
detail::TaggedVector< CoordinateElement, CDims... > Coordinate
A Coordinate represents a coordinate in the continuous space.
Definition coordinate.hpp:30
ddc::discrete_space
KOKKOS_FUNCTION detail::ddim_impl_t< DDim, MemorySpace > const & discrete_space()
Definition discrete_space.hpp:235
ddc::parallel_for_each
void parallel_for_each(std::string const &label, ExecSpace const &execution_space, Support const &domain, Functor &&f) noexcept
iterates over a nD domain using a given Kokkos execution space
Definition parallel_for_each.hpp:79
ddc::Deriv
A templated struct representing a discrete dimension storing the derivatives of a function along a co...
Definition deriv.hpp:15