DDC 0.0.0

a discrete domain computation library

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
9#include <ddc/ddc.hpp>
10
11#include "Kokkos_Macros.hpp"
12#include "view.hpp"
13
14namespace ddc {
15
19template <
20 class ExecSpace,
21 class MemorySpace,
22 class BSplinesType1,
23 class BSplinesType2,
24 class interpolation_mesh_type1,
25 class interpolation_mesh_type2,
26 class LeftExtrapolationRule1,
27 class RightExtrapolationRule1,
28 class LeftExtrapolationRule2,
29 class RightExtrapolationRule2,
30 class... IDimX>
31class SplineEvaluator2D
32{
33private:
37 struct eval_type
38 {
39 };
40
44 struct eval_deriv_type
45 {
46 };
47
48 using tag_type1 = typename BSplinesType1::tag_type;
49 using tag_type2 = typename BSplinesType2::tag_type;
50
51public:
52 using exec_space = ExecSpace;
53
54 using memory_space = MemorySpace;
55
56 using bsplines_type1 = BSplinesType1;
57 using bsplines_type2 = BSplinesType2;
58
59 using left_extrapolation_rule_1_type = LeftExtrapolationRule1;
60 using right_extrapolation_rule_1_type = RightExtrapolationRule1;
61 using left_extrapolation_rule_2_type = LeftExtrapolationRule2;
62 using right_extrapolation_rule_2_type = RightExtrapolationRule2;
63
64 using interpolation_domain_type1 = ddc::DiscreteDomain<interpolation_mesh_type1>;
65 using interpolation_domain_type2 = ddc::DiscreteDomain<interpolation_mesh_type2>;
66 using interpolation_domain_type
67 = ddc::DiscreteDomain<interpolation_mesh_type1, interpolation_mesh_type2>;
68
69 using batched_interpolation_domain_type = ddc::DiscreteDomain<IDimX...>;
70
71 using spline_domain_type1 = ddc::DiscreteDomain<bsplines_type1>;
72 using spline_domain_type2 = ddc::DiscreteDomain<bsplines_type2>;
73 using spline_domain_type = ddc::DiscreteDomain<bsplines_type1, bsplines_type2>;
74
75 using batch_domain_type =
76 typename ddc::detail::convert_type_seq_to_discrete_domain<ddc::type_seq_remove_t<
77 ddc::detail::TypeSeq<IDimX...>,
78 ddc::detail::TypeSeq<interpolation_mesh_type1, interpolation_mesh_type2>>>;
79
80 using batched_spline_domain_type =
81 typename ddc::detail::convert_type_seq_to_discrete_domain<ddc::type_seq_replace_t<
82 ddc::detail::TypeSeq<IDimX...>,
83 ddc::detail::TypeSeq<interpolation_mesh_type1, interpolation_mesh_type2>,
84 ddc::detail::TypeSeq<bsplines_type1, bsplines_type2>>>;
85
86
87private:
88 LeftExtrapolationRule1 m_left_extrap_rule_1;
89
90 RightExtrapolationRule1 m_right_extrap_rule_1;
91
92 LeftExtrapolationRule2 m_left_extrap_rule_2;
93
94 RightExtrapolationRule2 m_right_extrap_rule_2;
95
96public:
97 static_assert(
98 std::is_same_v<LeftExtrapolationRule1,
99 typename ddc::PeriodicExtrapolationRule<
100 tag_type1>> == bsplines_type1::is_periodic()
101 && std::is_same_v<
102 RightExtrapolationRule1,
103 typename ddc::PeriodicExtrapolationRule<
104 tag_type1>> == bsplines_type1::is_periodic()
105 && std::is_same_v<
106 LeftExtrapolationRule2,
107 typename ddc::PeriodicExtrapolationRule<
108 tag_type2>> == bsplines_type2::is_periodic()
109 && std::is_same_v<
110 RightExtrapolationRule2,
111 typename ddc::PeriodicExtrapolationRule<
112 tag_type2>> == bsplines_type2::is_periodic(),
113 "PeriodicExtrapolationRule has to be used if and only if dimension is periodic");
114 static_assert(
115 std::is_invocable_r_v<
116 double,
117 LeftExtrapolationRule1,
118 ddc::Coordinate<tag_type1>,
119 ddc::ChunkSpan<
120 double const,
121 spline_domain_type,
122 std::experimental::layout_right,
123 memory_space>>,
124 "LeftExtrapolationRule1::operator() has to be callable "
125 "with usual arguments.");
126 static_assert(
127 std::is_invocable_r_v<
128 double,
129 RightExtrapolationRule1,
130 ddc::Coordinate<tag_type1>,
131 ddc::ChunkSpan<
132 double const,
133 spline_domain_type,
134 std::experimental::layout_right,
135 memory_space>>,
136 "RightExtrapolationRule1::operator() has to be callable "
137 "with usual arguments.");
138 static_assert(
139 std::is_invocable_r_v<
140 double,
141 LeftExtrapolationRule2,
142 ddc::Coordinate<tag_type2>,
143 ddc::ChunkSpan<
144 double const,
145 spline_domain_type,
146 std::experimental::layout_right,
147 memory_space>>,
148 "LeftExtrapolationRule2::operator() has to be callable "
149 "with usual arguments.");
150 static_assert(
151 std::is_invocable_r_v<
152 double,
153 RightExtrapolationRule2,
154 ddc::Coordinate<tag_type2>,
155 ddc::ChunkSpan<
156 double const,
157 spline_domain_type,
158 std::experimental::layout_right,
159 memory_space>>,
160 "RightExtrapolationRule2::operator() has to be callable "
161 "with usual arguments.");
162
181 explicit SplineEvaluator2D(
182 LeftExtrapolationRule1 const& left_extrap_rule1,
183 RightExtrapolationRule1 const& right_extrap_rule1,
184 LeftExtrapolationRule2 const& left_extrap_rule2,
185 RightExtrapolationRule2 const& right_extrap_rule2)
186 : m_left_extrap_rule_1(left_extrap_rule1)
187 , m_right_extrap_rule_1(right_extrap_rule1)
188 , m_left_extrap_rule_2(left_extrap_rule2)
189 , m_right_extrap_rule_2(right_extrap_rule2)
190 {
191 }
192
200 SplineEvaluator2D(SplineEvaluator2D const& x) = default;
201
209 SplineEvaluator2D(SplineEvaluator2D&& x) = default;
210
211 ~SplineEvaluator2D() = default;
212
221 SplineEvaluator2D& operator=(SplineEvaluator2D const& x) = default;
222
231 SplineEvaluator2D& operator=(SplineEvaluator2D&& x) = default;
232
233
234
235 left_extrapolation_rule_1_type left_extrapolation_rule_dim_1() const
236 {
237 return m_left_extrap_rule_1;
238 }
239
240 right_extrapolation_rule_1_type right_extrapolation_rule_dim_1() const
241 {
242 return m_right_extrap_rule_1;
243 }
244
245 left_extrapolation_rule_2_type left_extrapolation_rule_dim_2() const
246 {
247 return m_left_extrap_rule_2;
248 }
249
250 right_extrapolation_rule_2_type right_extrapolation_rule_dim_2() const
251 {
252 return m_right_extrap_rule_2;
253 }
254
272 }
273
274 template <class Layout1, class Layout2, class Layout3, class... CoordsDims>
275 void operator()(
276 ddc::ChunkSpan<double, batched_interpolation_domain_type, Layout1, memory_space> const
277 spline_eval,
278 ddc::ChunkSpan<
279 ddc::Coordinate<CoordsDims...> const,
280 batched_interpolation_domain_type,
281 Layout2,
282 memory_space> const coords_eval,
283 ddc::ChunkSpan<double const, batched_spline_domain_type, Layout3, memory_space> const
284 spline_coef) const
285 {
286 batch_domain_type batch_domain(coords_eval.domain());
287 interpolation_domain_type1 const interpolation_domain1(spline_eval.domain());
288 interpolation_domain_type2 const interpolation_domain2(spline_eval.domain());
289 ddc::parallel_for_each(
290 exec_space(),
291 batch_domain,
292 KOKKOS_CLASS_LAMBDA(typename batch_domain_type::discrete_element_type const j) {
293 const auto spline_eval_2D = spline_eval[j];
294 const auto coords_eval_2D = coords_eval[j];
295 const auto spline_coef_2D = spline_coef[j];
296 for (auto const i1 : interpolation_domain1) {
297 for (auto const i2 : interpolation_domain2) {
298 spline_eval_2D(i1, i2) = eval(coords_eval_2D(i1, i2), spline_coef_2D);
299 }
300 }
301 });
302 }
303
321 }
322
340 }
341
359 }
360
361 template <class InterestDim, class Layout, class... CoordsDims>
362 KOKKOS_FUNCTION double deriv(
363 ddc::Coordinate<CoordsDims...> const& coord_eval,
364 ddc::ChunkSpan<double const, spline_domain_type, Layout, memory_space> const
365 spline_coef) const
366 {
367 static_assert(
368 std::is_same_v<
369 InterestDim,
370 typename interpolation_mesh_type1::
371 continuous_dimension_type> || std::is_same_v<InterestDim, typename interpolation_mesh_type2::continuous_dimension_type>);
372 if constexpr (std::is_same_v<
373 InterestDim,
374 typename interpolation_mesh_type1::continuous_dimension_type>) {
375 return deriv_dim_1(coord_eval, spline_coef);
376 } else if constexpr (std::is_same_v<
377 InterestDim,
378 typename interpolation_mesh_type2::
379 continuous_dimension_type>) {
380 return deriv_dim_2(coord_eval, spline_coef);
381 }
382 }
383
384 template <class InterestDim1, class InterestDim2, class Layout, class... CoordsDims>
385 KOKKOS_FUNCTION double deriv2(
386 ddc::Coordinate<CoordsDims...> const& coord_eval,
387 ddc::ChunkSpan<double const, spline_domain_type, Layout, memory_space> const
388 spline_coef) const
389 {
390 static_assert(
391 (std::is_same_v<
392 InterestDim1,
393 typename interpolation_mesh_type1::
394 continuous_dimension_type> && std::is_same_v<InterestDim2, typename interpolation_mesh_type2::continuous_dimension_type>)
395 || (std::is_same_v<
396 InterestDim2,
397 typename interpolation_mesh_type1::
398 continuous_dimension_type> && std::is_same_v<InterestDim1, typename interpolation_mesh_type2::continuous_dimension_type>));
399 return deriv_1_and_2(coord_eval, spline_coef);
400 }
401
412 template <class Layout1, class Layout2, class Layout3, class... CoordsDims>
413 void deriv_dim_1(
414 ddc::ChunkSpan<double, batched_interpolation_domain_type, Layout1, memory_space> const
415 spline_eval,
416 ddc::ChunkSpan<
417 ddc::Coordinate<CoordsDims...> const,
418 batched_interpolation_domain_type,
419 Layout2,
420 memory_space> const coords_eval,
421 ddc::ChunkSpan<double const, batched_spline_domain_type, Layout3, memory_space> const
422 spline_coef) const
423 {
424 batch_domain_type batch_domain(coords_eval.domain());
425 interpolation_domain_type1 const interpolation_domain1(spline_eval.domain());
426 interpolation_domain_type2 const interpolation_domain2(spline_eval.domain());
427 ddc::parallel_for_each(
428 exec_space(),
429 batch_domain,
430 KOKKOS_CLASS_LAMBDA(typename batch_domain_type::discrete_element_type const j) {
431 const auto spline_eval_2D = spline_eval[j];
432 const auto coords_eval_2D = coords_eval[j];
433 const auto spline_coef_2D = spline_coef[j];
434 for (auto const i1 : interpolation_domain1) {
435 for (auto const i2 : interpolation_domain2) {
436 spline_eval_2D(i1, i2) = eval_no_bc<
437 eval_deriv_type,
438 eval_type>(coords_eval_2D(i1, i2), spline_coef_2D);
439 }
440 }
441 });
442 }
443
454 template <class Layout1, class Layout2, class Layout3, class... CoordsDims>
455 void deriv_dim_2(
456 ddc::ChunkSpan<double, batched_interpolation_domain_type, Layout1, memory_space> const
457 spline_eval,
458 ddc::ChunkSpan<
459 ddc::Coordinate<CoordsDims...> const,
460 batched_interpolation_domain_type,
461 Layout2,
462 memory_space> const coords_eval,
463 ddc::ChunkSpan<double const, batched_spline_domain_type, Layout3, memory_space> const
464 spline_coef) const
465 {
466 batch_domain_type batch_domain(coords_eval.domain());
467 interpolation_domain_type1 const interpolation_domain1(spline_eval.domain());
468 interpolation_domain_type2 const interpolation_domain2(spline_eval.domain());
469 ddc::parallel_for_each(
470 exec_space(),
471 batch_domain,
472 KOKKOS_CLASS_LAMBDA(typename batch_domain_type::discrete_element_type const j) {
473 const auto spline_eval_2D = spline_eval[j];
474 const auto coords_eval_2D = coords_eval[j];
475 const auto spline_coef_2D = spline_coef[j];
476 for (auto const i1 : interpolation_domain1) {
477 for (auto const i2 : interpolation_domain2) {
478 spline_eval_2D(i1, i2) = eval_no_bc<
479 eval_type,
480 eval_deriv_type>(coords_eval_2D(i1, i2), spline_coef_2D);
481 }
482 }
483 });
484 }
485
496 template <class Layout1, class Layout2, class Layout3, class... CoordsDims>
497 void deriv_1_and_2(
498 ddc::ChunkSpan<double, batched_interpolation_domain_type, Layout1, memory_space> const
499 spline_eval,
500 ddc::ChunkSpan<
501 ddc::Coordinate<CoordsDims...> const,
502 batched_interpolation_domain_type,
503 Layout2,
504 memory_space> const coords_eval,
505 ddc::ChunkSpan<double const, batched_spline_domain_type, Layout3, memory_space> const
506 spline_coef) const
507 {
508 batch_domain_type batch_domain(coords_eval.domain());
509 interpolation_domain_type1 const interpolation_domain1(spline_eval.domain());
510 interpolation_domain_type2 const interpolation_domain2(spline_eval.domain());
511 ddc::parallel_for_each(
512 exec_space(),
513 batch_domain,
514 KOKKOS_CLASS_LAMBDA(typename batch_domain_type::discrete_element_type const j) {
515 const auto spline_eval_2D = spline_eval[j];
516 const auto coords_eval_2D = coords_eval[j];
517 const auto spline_coef_2D = spline_coef[j];
518 for (auto const i1 : interpolation_domain1) {
519 for (auto const i2 : interpolation_domain2) {
520 spline_eval_2D(i1, i2) = eval_no_bc<
521 eval_deriv_type,
522 eval_deriv_type>(coords_eval_2D(i1, i2), spline_coef_2D);
523 }
524 }
525 });
526 }
527
528 template <class InterestDim, class Layout1, class Layout2, class Layout3, class... CoordsDims>
529 void deriv(
530 ddc::ChunkSpan<double, batched_interpolation_domain_type, Layout1, memory_space> const
531 spline_eval,
532 ddc::ChunkSpan<
533 ddc::Coordinate<CoordsDims...> const,
534 batched_interpolation_domain_type,
535 Layout2,
536 memory_space> const coords_eval,
537 ddc::ChunkSpan<double const, batched_spline_domain_type, Layout3, memory_space> const
538 spline_coef) const
539 {
540 static_assert(
541 std::is_same_v<
542 InterestDim,
543 typename interpolation_mesh_type1::
544 continuous_dimension_type> || std::is_same_v<InterestDim, typename interpolation_mesh_type2::continuous_dimension_type>);
545 if constexpr (std::is_same_v<
546 InterestDim,
547 typename interpolation_mesh_type1::continuous_dimension_type>) {
548 return deriv_dim_1(spline_eval, coords_eval, spline_coef);
549 } else if constexpr (std::is_same_v<
550 InterestDim,
551 typename interpolation_mesh_type2::
552 continuous_dimension_type>) {
553 return deriv_dim_2(spline_eval, coords_eval, spline_coef);
554 }
555 }
556
557 template <
558 class InterestDim1,
559 class InterestDim2,
560 class Layout1,
561 class Layout2,
562 class Layout3,
563 class... CoordsDims>
564 void deriv2(
565 ddc::ChunkSpan<double, batched_interpolation_domain_type, Layout1, memory_space> const
566 spline_eval,
567 ddc::ChunkSpan<
568 ddc::Coordinate<CoordsDims...> const,
569 batched_interpolation_domain_type,
570 Layout2,
571 memory_space> const coords_eval,
572 ddc::ChunkSpan<double const, batched_spline_domain_type, Layout3, memory_space> const
573 spline_coef) const
574 {
575 static_assert(
576 (std::is_same_v<
577 InterestDim1,
578 typename interpolation_mesh_type1::
579 continuous_dimension_type> && std::is_same_v<InterestDim2, typename interpolation_mesh_type2::continuous_dimension_type>)
580 || (std::is_same_v<
581 InterestDim2,
582 typename interpolation_mesh_type1::
583 continuous_dimension_type> && std::is_same_v<InterestDim1, typename interpolation_mesh_type2::continuous_dimension_type>));
584 return deriv_1_and_2(spline_eval, coords_eval, spline_coef);
585 }
586
594 template <class Layout1, class Layout2>
595 void integrate(
596 ddc::ChunkSpan<double, batch_domain_type, Layout1, memory_space> const integrals,
597 ddc::ChunkSpan<double const, batched_spline_domain_type, Layout2, memory_space> const
598 spline_coef) const
599 {
600 batch_domain_type batch_domain(integrals.domain());
601 ddc::Chunk values1_alloc(
602 ddc::DiscreteDomain<bsplines_type1>(spline_coef.domain()),
603 ddc::KokkosAllocator<double, memory_space>());
604 ddc::ChunkSpan values1 = values1_alloc.span_view();
605 ddc::Chunk values2_alloc(
606 ddc::DiscreteDomain<bsplines_type2>(spline_coef.domain()),
607 ddc::KokkosAllocator<double, memory_space>());
608 ddc::ChunkSpan values2 = values2_alloc.span_view();
609 Kokkos::parallel_for(
610 Kokkos::RangePolicy<exec_space>(0, 1),
611 KOKKOS_LAMBDA(int) {
612 ddc::discrete_space<bsplines_type1>().integrals(values1);
613 ddc::discrete_space<bsplines_type2>().integrals(values2);
614 });
615
616 ddc::parallel_for_each(
617 exec_space(),
618 batch_domain,
619 KOKKOS_LAMBDA(typename batch_domain_type::discrete_element_type const j) {
620 integrals(j) = 0;
621 for (typename spline_domain_type1::discrete_element_type const i1 :
622 values1.domain()) {
623 for (typename spline_domain_type2::discrete_element_type const i2 :
624 values2.domain()) {
625 integrals(j) += spline_coef(i1, i2, j) * values1(i1) * values2(i2);
626 }
627 }
628 });
629 }
630
631private:
651 template <class Layout, class... CoordsDims>
652 KOKKOS_INLINE_FUNCTION double eval(
653 ddc::Coordinate<CoordsDims...> coord_eval,
654 ddc::ChunkSpan<double const, spline_domain_type, Layout, memory_space> const
655 spline_coef) const
656 {
657 using Dim1 = typename interpolation_mesh_type1::continuous_dimension_type;
658 using Dim2 = typename interpolation_mesh_type2::continuous_dimension_type;
659 if constexpr (bsplines_type1::is_periodic()) {
660 if (ddc::get<Dim1>(coord_eval) < ddc::discrete_space<bsplines_type1>().rmin()
661 || ddc::get<Dim1>(coord_eval) > ddc::discrete_space<bsplines_type1>().rmax()) {
662 ddc::get<Dim1>(coord_eval)
663 -= Kokkos::floor(
664 (ddc::get<Dim1>(coord_eval)
665 - ddc::discrete_space<bsplines_type1>().rmin())
666 / ddc::discrete_space<bsplines_type1>().length())
667 * ddc::discrete_space<bsplines_type1>().length();
668 }
669 }
670 if constexpr (bsplines_type2::is_periodic()) {
671 if (ddc::get<Dim2>(coord_eval) < ddc::discrete_space<bsplines_type2>().rmin()
672 || ddc::get<Dim2>(coord_eval) > ddc::discrete_space<bsplines_type2>().rmax()) {
673 ddc::get<Dim2>(coord_eval)
674 -= Kokkos::floor(
675 (ddc::get<Dim2>(coord_eval)
676 - ddc::discrete_space<bsplines_type2>().rmin())
677 / ddc::discrete_space<bsplines_type2>().length())
678 * ddc::discrete_space<bsplines_type2>().length();
679 }
680 }
681 if constexpr (!bsplines_type1::is_periodic()) {
682 if (ddc::get<Dim1>(coord_eval) < ddc::discrete_space<bsplines_type1>().rmin()) {
683 return m_left_extrap_rule_1(coord_eval, spline_coef);
684 }
685 if (ddc::get<Dim1>(coord_eval) > ddc::discrete_space<bsplines_type1>().rmax()) {
686 return m_right_extrap_rule_1(coord_eval, spline_coef);
687 }
688 }
689 if constexpr (!bsplines_type2::is_periodic()) {
690 if (ddc::get<Dim2>(coord_eval) < ddc::discrete_space<bsplines_type2>().rmin()) {
691 return m_left_extrap_rule_2(coord_eval, spline_coef);
692 }
693 if (ddc::get<Dim2>(coord_eval) > ddc::discrete_space<bsplines_type2>().rmax()) {
694 return m_right_extrap_rule_2(coord_eval, spline_coef);
695 }
696 }
697 return eval_no_bc<eval_type, eval_type>(
698 ddc::Coordinate<
699 typename interpolation_mesh_type1::continuous_dimension_type,
700 typename interpolation_mesh_type2::continuous_dimension_type>(
701 ddc::get<Dim1>(coord_eval),
702 ddc::get<Dim2>(coord_eval)),
703 spline_coef);
704 }
705
720 template <class EvalType1, class EvalType2, class Layout, class... CoordsDims>
721 KOKKOS_INLINE_FUNCTION double eval_no_bc(
722 ddc::Coordinate<CoordsDims...> const& coord_eval,
723 ddc::ChunkSpan<double const, spline_domain_type, Layout, memory_space> const
724 spline_coef) const
725 {
726 static_assert(
727 std::is_same_v<EvalType1, eval_type> || std::is_same_v<EvalType1, eval_deriv_type>);
728 static_assert(
729 std::is_same_v<EvalType2, eval_type> || std::is_same_v<EvalType2, eval_deriv_type>);
730 ddc::DiscreteElement<bsplines_type1> jmin1;
731 ddc::DiscreteElement<bsplines_type2> jmin2;
732
733 std::array<double, bsplines_type1::degree() + 1> vals1_ptr;
734 std::experimental::mdspan<
735 double,
736 std::experimental::extents<std::size_t, bsplines_type1::degree() + 1>> const
737 vals1(vals1_ptr.data());
738 std::array<double, bsplines_type2::degree() + 1> vals2_ptr;
739 std::experimental::mdspan<
740 double,
741 std::experimental::extents<std::size_t, bsplines_type2::degree() + 1>> const
742 vals2(vals2_ptr.data());
743 ddc::Coordinate<typename interpolation_mesh_type1::continuous_dimension_type>
744 coord_eval_interpolation1
745 = ddc::select<typename interpolation_mesh_type1::continuous_dimension_type>(
746 coord_eval);
747 ddc::Coordinate<typename interpolation_mesh_type2::continuous_dimension_type>
748 coord_eval_interpolation2
749 = ddc::select<typename interpolation_mesh_type2::continuous_dimension_type>(
750 coord_eval);
751
752 if constexpr (std::is_same_v<EvalType1, eval_type>) {
753 jmin1 = ddc::discrete_space<bsplines_type1>()
754 .eval_basis(vals1, coord_eval_interpolation1);
755 } else if constexpr (std::is_same_v<EvalType1, eval_deriv_type>) {
756 jmin1 = ddc::discrete_space<bsplines_type1>()
757 .eval_deriv(vals1, coord_eval_interpolation1);
758 }
759 if constexpr (std::is_same_v<EvalType2, eval_type>) {
760 jmin2 = ddc::discrete_space<bsplines_type2>()
761 .eval_basis(vals2, coord_eval_interpolation2);
762 } else if constexpr (std::is_same_v<EvalType2, eval_deriv_type>) {
763 jmin2 = ddc::discrete_space<bsplines_type2>()
764 .eval_deriv(vals2, coord_eval_interpolation2);
765 }
766
767 double y = 0.0;
768 for (std::size_t i = 0; i < bsplines_type1::degree() + 1; ++i) {
769 for (std::size_t j = 0; j < bsplines_type2::degree() + 1; ++j) {
770 y += spline_coef(ddc::DiscreteElement<
771 bsplines_type1,
772 bsplines_type2>(jmin1 + i, jmin2 + j))
773 * vals1[i] * vals2[j];
774 }
775 }
776 return y;
777 }
778};
779} // namespace ddc
ddc::DiscreteDomain
Definition discrete_domain.hpp:51
ddc::KokkosAllocator
Definition kokkos_allocator.hpp:17
ddc::SplineEvaluator2D
Define an evaluator 2D on B-splines.
Definition spline_evaluator_2d.hpp:32
ddc::SplineEvaluator2D::right_extrapolation_rule_1_type
RightExtrapolationRule1 right_extrapolation_rule_1_type
Definition spline_evaluator_2d.hpp:60
ddc::SplineEvaluator2D::bsplines_type2
BSplinesType2 bsplines_type2
Definition spline_evaluator_2d.hpp:57
ddc::SplineEvaluator2D::right_extrapolation_rule_dim_2
right_extrapolation_rule_2_type right_extrapolation_rule_dim_2() const
Definition spline_evaluator_2d.hpp:249
ddc::SplineEvaluator2D::integrate
void integrate(ddc::ChunkSpan< double, batch_domain_type, Layout1, memory_space > const integrals, ddc::ChunkSpan< double const, batched_spline_domain_type, Layout2, memory_space > const spline_coef) const
Get the the integral of the function on B-splines on the domain.
Definition spline_evaluator_2d.hpp:594
ddc::SplineEvaluator2D::deriv_1_and_2
KOKKOS_FUNCTION double deriv_1_and_2(ddc::Coordinate< CoordsDims... > const &coord_eval, ddc::ChunkSpan< double const, spline_domain_type, Layout, memory_space > const spline_coef) const
Get the value of the cross derivative of the function on B-splines at the coordinate given.
Definition spline_evaluator_2d.hpp:352
ddc::SplineEvaluator2D::left_extrapolation_rule_dim_2
left_extrapolation_rule_2_type left_extrapolation_rule_dim_2() const
Definition spline_evaluator_2d.hpp:244
ddc::SplineEvaluator2D::deriv_dim_1
KOKKOS_FUNCTION double deriv_dim_1(ddc::Coordinate< CoordsDims... > const &coord_eval, ddc::ChunkSpan< double const, spline_domain_type, Layout, memory_space > const spline_coef) const
Get the value of the derivative of the first dimension of the function on B-splines at the coordinate...
Definition spline_evaluator_2d.hpp:314
ddc::SplineEvaluator2D::SplineEvaluator2D
SplineEvaluator2D(LeftExtrapolationRule1 const &left_extrap_rule1, RightExtrapolationRule1 const &right_extrap_rule1, LeftExtrapolationRule2 const &left_extrap_rule2, RightExtrapolationRule2 const &right_extrap_rule2)
Instantiate an evaluator operator.
Definition spline_evaluator_2d.hpp:180
ddc::SplineEvaluator2D::right_extrapolation_rule_dim_1
right_extrapolation_rule_1_type right_extrapolation_rule_dim_1() const
Definition spline_evaluator_2d.hpp:239
ddc::SplineEvaluator2D::operator=
SplineEvaluator2D & operator=(SplineEvaluator2D const &x)=default
Assign a SplineEvaluator2D from another SplineEvaluator2D (lvalue).
ddc::SplineEvaluator2D::spline_domain_type
ddc::DiscreteDomain< bsplines_type1, bsplines_type2 > spline_domain_type
Definition spline_evaluator_2d.hpp:72
ddc::SplineEvaluator2D::left_extrapolation_rule_1_type
LeftExtrapolationRule1 left_extrapolation_rule_1_type
Definition spline_evaluator_2d.hpp:59
ddc::SplineEvaluator2D::~SplineEvaluator2D
~SplineEvaluator2D()=default
ddc::SplineEvaluator2D::batch_domain_type
typename ddc::detail::convert_type_seq_to_discrete_domain< ddc::type_seq_remove_t< ddc::detail::TypeSeq< IDimX... >, ddc::detail::TypeSeq< interpolation_mesh_type1, interpolation_mesh_type2 > > > batch_domain_type
Definition spline_evaluator_2d.hpp:74
ddc::SplineEvaluator2D::batched_spline_domain_type
typename ddc::detail::convert_type_seq_to_discrete_domain< ddc::type_seq_replace_t< ddc::detail::TypeSeq< IDimX... >, ddc::detail::TypeSeq< interpolation_mesh_type1, interpolation_mesh_type2 >, ddc::detail::TypeSeq< bsplines_type1, bsplines_type2 > > > batched_spline_domain_type
Definition spline_evaluator_2d.hpp:79
ddc::SplineEvaluator2D::right_extrapolation_rule_2_type
RightExtrapolationRule2 right_extrapolation_rule_2_type
Definition spline_evaluator_2d.hpp:62
ddc::SplineEvaluator2D::deriv
KOKKOS_FUNCTION double deriv(ddc::Coordinate< CoordsDims... > const &coord_eval, ddc::ChunkSpan< double const, spline_domain_type, Layout, memory_space > const spline_coef) const
Definition spline_evaluator_2d.hpp:361
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
Get the value of the function on B-splines at the coordinate given.
Definition spline_evaluator_2d.hpp:265
ddc::SplineEvaluator2D::exec_space
ExecSpace exec_space
Definition spline_evaluator_2d.hpp:52
ddc::SplineEvaluator2D::memory_space
MemorySpace memory_space
Definition spline_evaluator_2d.hpp:54
ddc::SplineEvaluator2D::bsplines_type1
BSplinesType1 bsplines_type1
Definition spline_evaluator_2d.hpp:56
ddc::SplineEvaluator2D::deriv_dim_2
KOKKOS_FUNCTION double deriv_dim_2(ddc::Coordinate< CoordsDims... > const &coord_eval, ddc::ChunkSpan< double const, spline_domain_type, Layout, memory_space > const spline_coef) const
Get the value of the derivative of the second dimension of the function on B-splines at the coordinat...
Definition spline_evaluator_2d.hpp:333
ddc::SplineEvaluator2D::deriv2
KOKKOS_FUNCTION double deriv2(ddc::Coordinate< CoordsDims... > const &coord_eval, ddc::ChunkSpan< double const, spline_domain_type, Layout, memory_space > const spline_coef) const
Definition spline_evaluator_2d.hpp:384
ddc::SplineEvaluator2D::left_extrapolation_rule_2_type
LeftExtrapolationRule2 left_extrapolation_rule_2_type
Definition spline_evaluator_2d.hpp:61
ddc::SplineEvaluator2D::left_extrapolation_rule_dim_1
left_extrapolation_rule_1_type left_extrapolation_rule_dim_1() const
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:182
ddc::parallel_for_each
void parallel_for_each(std::string const &label, ExecSpace const &execution_space, DiscreteDomain< DDims... > const &domain, Functor &&f) noexcept
iterates over a nD domain using a given Kokkos execution space
Definition parallel_for_each.hpp:155
ddc::rmin
KOKKOS_FUNCTION Coordinate< typename DDim::continuous_dimension_type > rmin(DiscreteDomain< DDim > const &d)
Definition non_uniform_point_sampling.hpp:175
ddc::Coordinate
detail::TaggedVector< CoordinateElement, CDims... > Coordinate
A Coordinate represents a coordinate in the continuous space.
Definition coordinate.hpp:26
ddc::Chunk
Definition chunk.hpp:21
ddc::ChunkSpan
Definition chunk_span.hpp:30
ddc::PeriodicExtrapolationRule
Definition periodic_extrapolation_rule.hpp:13