Cabana 0.8.0-dev
 
Loading...
Searching...
No Matches
Cabana_Grid_Interpolation.hpp
Go to the documentation of this file.
1/****************************************************************************
2 * Copyright (c) 2018-2023 by the Cabana authors *
3 * All rights reserved. *
4 * *
5 * This file is part of the Cabana library. Cabana is distributed under a *
6 * BSD 3-clause license. For the licensing terms see the LICENSE file in *
7 * the top-level directory. *
8 * *
9 * SPDX-License-Identifier: BSD-3-Clause *
10 ****************************************************************************/
11
16#ifndef CABANA_GRID_INTERPOLATION_HPP
17#define CABANA_GRID_INTERPOLATION_HPP
18
19#include <Cabana_Grid_Array.hpp>
20#include <Cabana_Grid_Halo.hpp>
21#include <Cabana_Grid_LocalMesh.hpp>
22#include <Cabana_Grid_Splines.hpp>
23#include <Cabana_Grid_Types.hpp>
24#include <Cabana_Utils.hpp> // FIXME: remove after next release.
25
26#include <Kokkos_Core.hpp>
27#include <Kokkos_ScatterView.hpp>
28
29#include <memory>
30#include <type_traits>
31
32namespace Cabana
33{
34namespace Grid
35{
36//---------------------------------------------------------------------------//
37// LOCAL INTERPOLATION
38//---------------------------------------------------------------------------//
39
40//---------------------------------------------------------------------------//
41// Local grid-to-point.
42//---------------------------------------------------------------------------//
43namespace G2P
44{
45//---------------------------------------------------------------------------//
53template <class ViewType, class SplineDataType, class PointDataType>
54KOKKOS_INLINE_FUNCTION
55 std::enable_if_t<3 == SplineDataType::num_space_dim, void>
56 value( const ViewType& view, const SplineDataType& sd,
57 PointDataType& result,
58 typename std::enable_if<( std::rank<PointDataType>::value == 0 ),
59 void*>::type = 0 )
60{
61 static_assert( SplineDataType::has_weight_values,
62 "G2P::value requires spline weight values" );
63
64 result = 0.0;
65
66 for ( int i = 0; i < SplineDataType::num_knot; ++i )
67 for ( int j = 0; j < SplineDataType::num_knot; ++j )
68 for ( int k = 0; k < SplineDataType::num_knot; ++k )
69 result += view( sd.s[Dim::I][i], sd.s[Dim::J][j],
70 sd.s[Dim::K][k], 0 ) *
71 sd.w[Dim::I][i] * sd.w[Dim::J][j] * sd.w[Dim::K][k];
72}
73
81template <class ViewType, class SplineDataType, class PointDataType>
82KOKKOS_INLINE_FUNCTION
83 std::enable_if_t<2 == SplineDataType::num_space_dim, void>
84 value( const ViewType& view, const SplineDataType& sd,
85 PointDataType& result,
86 typename std::enable_if<( std::rank<PointDataType>::value == 0 ),
87 void*>::type = 0 )
88{
89 static_assert( SplineDataType::has_weight_values,
90 "G2P::value requires spline weight values" );
91
92 result = 0.0;
93
94 for ( int i = 0; i < SplineDataType::num_knot; ++i )
95 for ( int j = 0; j < SplineDataType::num_knot; ++j )
96 result += view( sd.s[Dim::I][i], sd.s[Dim::J][j], 0 ) *
97 sd.w[Dim::I][i] * sd.w[Dim::J][j];
98}
99
100//---------------------------------------------------------------------------//
108template <class ViewType, class SplineDataType, class PointDataType>
109KOKKOS_INLINE_FUNCTION
110 std::enable_if_t<3 == SplineDataType::num_space_dim, void>
111 value( const ViewType& view, const SplineDataType& sd,
112 PointDataType result[3],
113 typename std::enable_if<( std::rank<PointDataType>::value == 0 ),
114 void*>::type = 0 )
115{
116 static_assert( SplineDataType::has_weight_values,
117 "G2P::value requires spline weight values" );
118
119 for ( int d = 0; d < 3; ++d )
120 result[d] = 0.0;
121
122 for ( int i = 0; i < SplineDataType::num_knot; ++i )
123 for ( int j = 0; j < SplineDataType::num_knot; ++j )
124 for ( int k = 0; k < SplineDataType::num_knot; ++k )
125 for ( int d = 0; d < 3; ++d )
126 result[d] += view( sd.s[Dim::I][i], sd.s[Dim::J][j],
127 sd.s[Dim::K][k], d ) *
128 sd.w[Dim::I][i] * sd.w[Dim::J][j] *
129 sd.w[Dim::K][k];
130}
131
139template <class ViewType, class SplineDataType, class PointDataType>
140KOKKOS_INLINE_FUNCTION
141 std::enable_if_t<2 == SplineDataType::num_space_dim, void>
142 value( const ViewType& view, const SplineDataType& sd,
143 PointDataType result[2],
144 typename std::enable_if<( std::rank<PointDataType>::value == 0 ),
145 void*>::type = 0 )
146{
147 static_assert( SplineDataType::has_weight_values,
148 "G2P::value requires spline weight values" );
149
150 for ( int d = 0; d < 2; ++d )
151 result[d] = 0.0;
152
153 for ( int i = 0; i < SplineDataType::num_knot; ++i )
154 for ( int j = 0; j < SplineDataType::num_knot; ++j )
155 for ( int d = 0; d < 2; ++d )
156 result[d] += view( sd.s[Dim::I][i], sd.s[Dim::J][j], d ) *
157 sd.w[Dim::I][i] * sd.w[Dim::J][j];
158}
159
160//---------------------------------------------------------------------------//
168template <class ViewType, class SplineDataType, class PointDataType>
169KOKKOS_INLINE_FUNCTION
170 std::enable_if_t<3 == SplineDataType::num_space_dim, void>
171 gradient( const ViewType& view, const SplineDataType& sd,
172 PointDataType result[3],
173 typename std::enable_if<( std::rank<PointDataType>::value == 0 ),
174 void*>::type = 0 )
175{
176 static_assert( SplineDataType::has_weight_values,
177 "G2P::gradient requires spline weight values" );
178 static_assert( SplineDataType::has_weight_physical_gradients,
179 "G2P::gradient requires spline weight physical gradients" );
180
181 for ( int d = 0; d < 3; ++d )
182 result[d] = 0.0;
183
184 for ( int i = 0; i < SplineDataType::num_knot; ++i )
185 for ( int j = 0; j < SplineDataType::num_knot; ++j )
186 for ( int k = 0; k < SplineDataType::num_knot; ++k )
187 {
188 result[Dim::I] += view( sd.s[Dim::I][i], sd.s[Dim::J][j],
189 sd.s[Dim::K][k], 0 ) *
190 sd.g[Dim::I][i] * sd.w[Dim::J][j] *
191 sd.w[Dim::K][k];
192
193 result[Dim::J] += view( sd.s[Dim::I][i], sd.s[Dim::J][j],
194 sd.s[Dim::K][k], 0 ) *
195 sd.w[Dim::I][i] * sd.g[Dim::J][j] *
196 sd.w[Dim::K][k];
197
198 result[Dim::K] += view( sd.s[Dim::I][i], sd.s[Dim::J][j],
199 sd.s[Dim::K][k], 0 ) *
200 sd.w[Dim::I][i] * sd.w[Dim::J][j] *
201 sd.g[Dim::K][k];
202 }
203}
204
212template <class ViewType, class SplineDataType, class PointDataType>
213KOKKOS_INLINE_FUNCTION
214 std::enable_if_t<2 == SplineDataType::num_space_dim, void>
215 gradient( const ViewType& view, const SplineDataType& sd,
216 PointDataType result[2],
217 typename std::enable_if<( std::rank<PointDataType>::value == 0 ),
218 void*>::type = 0 )
219{
220 static_assert( SplineDataType::has_weight_values,
221 "G2P::gradient requires spline weight values" );
222 static_assert( SplineDataType::has_weight_physical_gradients,
223 "G2P::gradient requires spline weight physical gradients" );
224
225 for ( int d = 0; d < 2; ++d )
226 result[d] = 0.0;
227
228 for ( int i = 0; i < SplineDataType::num_knot; ++i )
229 for ( int j = 0; j < SplineDataType::num_knot; ++j )
230 {
231 result[Dim::I] += view( sd.s[Dim::I][i], sd.s[Dim::J][j], 0 ) *
232 sd.g[Dim::I][i] * sd.w[Dim::J][j];
233
234 result[Dim::J] += view( sd.s[Dim::I][i], sd.s[Dim::J][j], 0 ) *
235 sd.w[Dim::I][i] * sd.g[Dim::J][j];
236 }
237}
238
239//---------------------------------------------------------------------------//
247template <class ViewType, class SplineDataType, class PointDataType>
248KOKKOS_INLINE_FUNCTION
249 std::enable_if_t<3 == SplineDataType::num_space_dim, void>
250 gradient( const ViewType& view, const SplineDataType& sd,
251 PointDataType result[3][3],
252 typename std::enable_if<( std::rank<PointDataType>::value == 0 ),
253 void*>::type = 0 )
254{
255 static_assert( SplineDataType::has_weight_values,
256 "G2P::gradient requires spline weight values" );
257 static_assert( SplineDataType::has_weight_physical_gradients,
258 "G2P::gradient requires spline weight physical gradients" );
259
260 for ( int d0 = 0; d0 < 3; ++d0 )
261 for ( int d1 = 0; d1 < 3; ++d1 )
262 result[d0][d1] = 0.0;
263
264 for ( int i = 0; i < SplineDataType::num_knot; ++i )
265 for ( int j = 0; j < SplineDataType::num_knot; ++j )
266 for ( int k = 0; k < SplineDataType::num_knot; ++k )
267 {
268 typename SplineDataType::scalar_type rg[3] = {
269 sd.g[Dim::I][i] * sd.w[Dim::J][j] * sd.w[Dim::K][k],
270 sd.w[Dim::I][i] * sd.g[Dim::J][j] * sd.w[Dim::K][k],
271 sd.w[Dim::I][i] * sd.w[Dim::J][j] * sd.g[Dim::K][k] };
272
273 for ( int d0 = 0; d0 < 3; ++d0 )
274 {
275 auto mg = rg[d0];
276 for ( int d1 = 0; d1 < 3; ++d1 )
277 result[d0][d1] +=
278 mg * view( sd.s[Dim::I][i], sd.s[Dim::J][j],
279 sd.s[Dim::K][k], d1 );
280 }
281 }
282}
283
291template <class ViewType, class SplineDataType, class PointDataType>
292KOKKOS_INLINE_FUNCTION
293 std::enable_if_t<2 == SplineDataType::num_space_dim, void>
294 gradient( const ViewType& view, const SplineDataType& sd,
295 PointDataType result[2][2],
296 typename std::enable_if<( std::rank<PointDataType>::value == 0 ),
297 void*>::type = 0 )
298{
299 static_assert( SplineDataType::has_weight_values,
300 "G2P::gradient requires spline weight values" );
301 static_assert( SplineDataType::has_weight_physical_gradients,
302 "G2P::gradient requires spline weight physical gradients" );
303
304 for ( int d0 = 0; d0 < 2; ++d0 )
305 for ( int d1 = 0; d1 < 2; ++d1 )
306 result[d0][d1] = 0.0;
307
308 for ( int i = 0; i < SplineDataType::num_knot; ++i )
309 for ( int j = 0; j < SplineDataType::num_knot; ++j )
310 {
311 typename SplineDataType::scalar_type rg[2] = {
312 sd.g[Dim::I][i] * sd.w[Dim::J][j],
313 sd.w[Dim::I][i] * sd.g[Dim::J][j] };
314
315 for ( int d0 = 0; d0 < 2; ++d0 )
316 {
317 auto mg = rg[d0];
318 for ( int d1 = 0; d1 < 2; ++d1 )
319 result[d0][d1] +=
320 mg * view( sd.s[Dim::I][i], sd.s[Dim::J][j], d1 );
321 }
322 }
323}
324
325//---------------------------------------------------------------------------//
333template <class ViewType, class SplineDataType, class PointDataType>
334KOKKOS_INLINE_FUNCTION
335 std::enable_if_t<3 == SplineDataType::num_space_dim, void>
336 divergence( const ViewType& view, const SplineDataType& sd,
337 PointDataType& result,
338 typename std::enable_if<
339 ( std::rank<PointDataType>::value == 0 ), void*>::type = 0 )
340{
341 static_assert( SplineDataType::has_weight_values,
342 "G2P::divergence requires spline weight values" );
343 static_assert(
344 SplineDataType::has_weight_physical_gradients,
345 "G2P::divergence requires spline weight physical gradients" );
346
347 result = 0.0;
348
349 for ( int i = 0; i < SplineDataType::num_knot; ++i )
350 for ( int j = 0; j < SplineDataType::num_knot; ++j )
351 for ( int k = 0; k < SplineDataType::num_knot; ++k )
352 result +=
353 view( sd.s[Dim::I][i], sd.s[Dim::J][j], sd.s[Dim::K][k],
354 Dim::I ) *
355 sd.g[Dim::I][i] * sd.w[Dim::J][j] * sd.w[Dim::K][k] +
356
357 view( sd.s[Dim::I][i], sd.s[Dim::J][j], sd.s[Dim::K][k],
358 Dim::J ) *
359 sd.w[Dim::I][i] * sd.g[Dim::J][j] * sd.w[Dim::K][k] +
360
361 view( sd.s[Dim::I][i], sd.s[Dim::J][j], sd.s[Dim::K][k],
362 Dim::K ) *
363 sd.w[Dim::I][i] * sd.w[Dim::J][j] * sd.g[Dim::K][k];
364}
365
373template <class ViewType, class SplineDataType, class PointDataType>
374KOKKOS_INLINE_FUNCTION
375 std::enable_if_t<2 == SplineDataType::num_space_dim, void>
376 divergence( const ViewType& view, const SplineDataType& sd,
377 PointDataType& result,
378 typename std::enable_if<
379 ( std::rank<PointDataType>::value == 0 ), void*>::type = 0 )
380{
381 static_assert( SplineDataType::has_weight_values,
382 "G2P::divergence requires spline weight values" );
383 static_assert(
384 SplineDataType::has_weight_physical_gradients,
385 "G2P::divergence requires spline weight physical gradients" );
386
387 result = 0.0;
388
389 for ( int i = 0; i < SplineDataType::num_knot; ++i )
390 for ( int j = 0; j < SplineDataType::num_knot; ++j )
391 result += view( sd.s[Dim::I][i], sd.s[Dim::J][j], Dim::I ) *
392 sd.g[Dim::I][i] * sd.w[Dim::J][j] +
393
394 view( sd.s[Dim::I][i], sd.s[Dim::J][j], Dim::J ) *
395 sd.w[Dim::I][i] * sd.g[Dim::J][j];
396}
397
398//---------------------------------------------------------------------------//
399
400} // end namespace G2P
401
402//---------------------------------------------------------------------------//
403// Local point-to-grid.
404//---------------------------------------------------------------------------//
405namespace P2G
406{
407//---------------------------------------------------------------------------//
409template <class T>
410struct is_scatter_view_impl : public std::false_type
411{
412};
413
414template <typename DataType, typename Layout, typename ExecSpace, typename Op,
415 typename duplication, typename contribution>
416struct is_scatter_view_impl<Kokkos::Experimental::ScatterView<
417 DataType, Layout, ExecSpace, Op, duplication, contribution>>
418 : public std::true_type
419{
420};
422
424template <class T>
425struct is_scatter_view
426 : public is_scatter_view_impl<typename std::remove_cv<T>::type>::type
427{
428};
429
430//---------------------------------------------------------------------------//
437template <class PointDataType, class ScatterViewType, class SplineDataType>
438KOKKOS_INLINE_FUNCTION
439 std::enable_if_t<3 == SplineDataType::num_space_dim, void>
440 value( const PointDataType& point_data, const SplineDataType& sd,
441 const ScatterViewType& view,
442 typename std::enable_if<( std::rank<PointDataType>::value == 0 ),
443 void*>::type = 0 )
444{
445 static_assert( SplineDataType::has_weight_values,
446 "P2G::value requires spline weight values" );
447
448 static_assert( is_scatter_view<ScatterViewType>::value,
449 "P2G requires a Kokkos::ScatterView" );
450 auto view_access = view.access();
451
452 for ( int i = 0; i < SplineDataType::num_knot; ++i )
453 for ( int j = 0; j < SplineDataType::num_knot; ++j )
454 for ( int k = 0; k < SplineDataType::num_knot; ++k )
455 view_access( sd.s[Dim::I][i], sd.s[Dim::J][j], sd.s[Dim::K][k],
456 0 ) += point_data * sd.w[Dim::I][i] *
457 sd.w[Dim::J][j] * sd.w[Dim::K][k];
458}
459
466template <class PointDataType, class ScatterViewType, class SplineDataType>
467KOKKOS_INLINE_FUNCTION
468 std::enable_if_t<2 == SplineDataType::num_space_dim, void>
469 value( const PointDataType& point_data, const SplineDataType& sd,
470 const ScatterViewType& view,
471 typename std::enable_if<( std::rank<PointDataType>::value == 0 ),
472 void*>::type = 0 )
473{
474 static_assert( SplineDataType::has_weight_values,
475 "P2G::value requires spline weight values" );
476
477 static_assert( is_scatter_view<ScatterViewType>::value,
478 "P2G requires a Kokkos::ScatterView" );
479 auto view_access = view.access();
480
481 for ( int i = 0; i < SplineDataType::num_knot; ++i )
482 for ( int j = 0; j < SplineDataType::num_knot; ++j )
483 view_access( sd.s[Dim::I][i], sd.s[Dim::J][j], 0 ) +=
484 point_data * sd.w[Dim::I][i] * sd.w[Dim::J][j];
485}
486
487//---------------------------------------------------------------------------//
495template <class PointDataType, class ScatterViewType, class SplineDataType>
496KOKKOS_INLINE_FUNCTION
497 std::enable_if_t<3 == SplineDataType::num_space_dim, void>
498 value( const PointDataType point_data[3], const SplineDataType& sd,
499 const ScatterViewType& view,
500 typename std::enable_if<( std::rank<PointDataType>::value == 0 ),
501 void*>::type = 0 )
502{
503 static_assert( SplineDataType::has_weight_values,
504 "P2G::value requires spline weight values" );
505
506 static_assert( is_scatter_view<ScatterViewType>::value,
507 "P2G requires a Kokkos::ScatterView" );
508 auto view_access = view.access();
509
510 for ( int i = 0; i < SplineDataType::num_knot; ++i )
511 for ( int j = 0; j < SplineDataType::num_knot; ++j )
512 for ( int k = 0; k < SplineDataType::num_knot; ++k )
513 for ( int d = 0; d < 3; ++d )
514 view_access( sd.s[Dim::I][i], sd.s[Dim::J][j],
515 sd.s[Dim::K][k], d ) +=
516 point_data[d] * sd.w[Dim::I][i] * sd.w[Dim::J][j] *
517 sd.w[Dim::K][k];
518}
519
527template <class PointDataType, class ScatterViewType, class SplineDataType>
528KOKKOS_INLINE_FUNCTION
529 std::enable_if_t<2 == SplineDataType::num_space_dim, void>
530 value( const PointDataType point_data[2], const SplineDataType& sd,
531 const ScatterViewType& view,
532 typename std::enable_if<( std::rank<PointDataType>::value == 0 ),
533 void*>::type = 0 )
534{
535 static_assert( SplineDataType::has_weight_values,
536 "P2G::value requires spline weight values" );
537
538 static_assert( is_scatter_view<ScatterViewType>::value,
539 "P2G requires a Kokkos::ScatterView" );
540 auto view_access = view.access();
541
542 for ( int i = 0; i < SplineDataType::num_knot; ++i )
543 for ( int j = 0; j < SplineDataType::num_knot; ++j )
544 for ( int d = 0; d < 2; ++d )
545 view_access( sd.s[Dim::I][i], sd.s[Dim::J][j], d ) +=
546 point_data[d] * sd.w[Dim::I][i] * sd.w[Dim::J][j];
547}
548
549//---------------------------------------------------------------------------//
557template <class PointDataType, class ScatterViewType, class SplineDataType>
558KOKKOS_INLINE_FUNCTION
559 std::enable_if_t<3 == SplineDataType::num_space_dim, void>
560 gradient( const PointDataType point_data, const SplineDataType& sd,
561 const ScatterViewType& view )
562{
563 static_assert( SplineDataType::has_weight_values,
564 "P2G::gradient requires spline weight values" );
565 static_assert( SplineDataType::has_weight_physical_gradients,
566 "P2G::gradient requires spline weight physical gradients" );
567
568 static_assert( is_scatter_view<ScatterViewType>::value,
569 "P2G requires a Kokkos::ScatterView" );
570 auto view_access = view.access();
571
572 for ( int i = 0; i < SplineDataType::num_knot; ++i )
573 for ( int j = 0; j < SplineDataType::num_knot; ++j )
574 for ( int k = 0; k < SplineDataType::num_knot; ++k )
575 {
576 view_access( sd.s[Dim::I][i], sd.s[Dim::J][j], sd.s[Dim::K][k],
577 Dim::I ) += point_data * sd.g[Dim::I][i] *
578 sd.w[Dim::J][j] * sd.w[Dim::K][k];
579
580 view_access( sd.s[Dim::I][i], sd.s[Dim::J][j], sd.s[Dim::K][k],
581 Dim::J ) += point_data * sd.w[Dim::I][i] *
582 sd.g[Dim::J][j] * sd.w[Dim::K][k];
583
584 view_access( sd.s[Dim::I][i], sd.s[Dim::J][j], sd.s[Dim::K][k],
585 Dim::K ) += point_data * sd.w[Dim::I][i] *
586 sd.w[Dim::J][j] * sd.g[Dim::K][k];
587 }
588}
589
597template <class PointDataType, class ScatterViewType, class SplineDataType>
598KOKKOS_INLINE_FUNCTION
599 std::enable_if_t<2 == SplineDataType::num_space_dim, void>
600 gradient( const PointDataType point_data, const SplineDataType& sd,
601 const ScatterViewType& view )
602{
603 static_assert( SplineDataType::has_weight_values,
604 "P2G::gradient requires spline weight values" );
605 static_assert( SplineDataType::has_weight_physical_gradients,
606 "P2G::gradient requires spline weight physical gradients" );
607
608 static_assert( is_scatter_view<ScatterViewType>::value,
609 "P2G requires a Kokkos::ScatterView" );
610 auto view_access = view.access();
611
612 for ( int i = 0; i < SplineDataType::num_knot; ++i )
613 for ( int j = 0; j < SplineDataType::num_knot; ++j )
614 {
615 view_access( sd.s[Dim::I][i], sd.s[Dim::J][j], Dim::I ) +=
616 point_data * sd.g[Dim::I][i] * sd.w[Dim::J][j];
617
618 view_access( sd.s[Dim::I][i], sd.s[Dim::J][j], Dim::J ) +=
619 point_data * sd.w[Dim::I][i] * sd.g[Dim::J][j];
620 }
621}
622
623//---------------------------------------------------------------------------//
631template <class PointDataType, class ScatterViewType, class SplineDataType>
632KOKKOS_INLINE_FUNCTION
633 std::enable_if_t<3 == SplineDataType::num_space_dim, void>
634 divergence( const PointDataType point_data[3], const SplineDataType& sd,
635 const ScatterViewType& view,
636 typename std::enable_if<
637 ( std::rank<PointDataType>::value == 0 ), void*>::type = 0 )
638{
639 static_assert( SplineDataType::has_weight_values,
640 "P2G::divergence requires spline weight values" );
641 static_assert(
642 SplineDataType::has_weight_physical_gradients,
643 "P2G::divergence requires spline weight physical gradients" );
644
645 static_assert( is_scatter_view<ScatterViewType>::value,
646 "P2G requires a Kokkos::ScatterView" );
647 auto view_access = view.access();
648
649 for ( int i = 0; i < SplineDataType::num_knot; ++i )
650 for ( int j = 0; j < SplineDataType::num_knot; ++j )
651 for ( int k = 0; k < SplineDataType::num_knot; ++k )
652 {
653 PointDataType result = point_data[Dim::I] * sd.g[Dim::I][i] *
654 sd.w[Dim::J][j] * sd.w[Dim::K][k] +
655
656 point_data[Dim::J] * sd.w[Dim::I][i] *
657 sd.g[Dim::J][j] * sd.w[Dim::K][k] +
658
659 point_data[Dim::K] * sd.w[Dim::I][i] *
660 sd.w[Dim::J][j] * sd.g[Dim::K][k];
661
662 view_access( sd.s[Dim::I][i], sd.s[Dim::J][j], sd.s[Dim::K][k],
663 0 ) += result;
664 }
665}
666
674template <class PointDataType, class ScatterViewType, class SplineDataType>
675KOKKOS_INLINE_FUNCTION
676 std::enable_if_t<2 == SplineDataType::num_space_dim, void>
677 divergence( const PointDataType point_data[2], const SplineDataType& sd,
678 const ScatterViewType& view,
679 typename std::enable_if<
680 ( std::rank<PointDataType>::value == 0 ), void*>::type = 0 )
681{
682 static_assert( SplineDataType::has_weight_values,
683 "P2G::divergence requires spline weight values" );
684 static_assert(
685 SplineDataType::has_weight_physical_gradients,
686 "P2G::divergence requires spline weight physical gradients" );
687
688 static_assert( is_scatter_view<ScatterViewType>::value,
689 "P2G requires a Kokkos::ScatterView" );
690 auto view_access = view.access();
691
692 for ( int i = 0; i < SplineDataType::num_knot; ++i )
693 for ( int j = 0; j < SplineDataType::num_knot; ++j )
694 {
695 PointDataType result =
696 point_data[Dim::I] * sd.g[Dim::I][i] * sd.w[Dim::J][j] +
697
698 point_data[Dim::J] * sd.w[Dim::I][i] * sd.g[Dim::J][j];
699
700 view_access( sd.s[Dim::I][i], sd.s[Dim::J][j], 0 ) += result;
701 }
702}
703
704//---------------------------------------------------------------------------//
712template <class ScatterViewType, class SplineDataType, class PointDataType>
713KOKKOS_INLINE_FUNCTION
714 std::enable_if_t<3 == SplineDataType::num_space_dim, void>
715 divergence( const PointDataType point_data[3][3], const SplineDataType& sd,
716 const ScatterViewType& view,
717 typename std::enable_if<
718 ( std::rank<PointDataType>::value == 0 ), void*>::type = 0 )
719{
720 static_assert( SplineDataType::has_weight_values,
721 "P2G::divergence requires spline weight values" );
722 static_assert(
723 SplineDataType::has_weight_physical_gradients,
724 "P2G::divergence requires spline weight physical gradients" );
725
726 static_assert( is_scatter_view<ScatterViewType>::value,
727 "P2G requires a Kokkos::ScatterView" );
728 auto view_access = view.access();
729
730 for ( int i = 0; i < SplineDataType::num_knot; ++i )
731 for ( int j = 0; j < SplineDataType::num_knot; ++j )
732 for ( int k = 0; k < SplineDataType::num_knot; ++k )
733 {
734 typename SplineDataType::scalar_type rg[3] = {
735 sd.g[Dim::I][i] * sd.w[Dim::J][j] * sd.w[Dim::K][k],
736 sd.w[Dim::I][i] * sd.g[Dim::J][j] * sd.w[Dim::K][k],
737 sd.w[Dim::I][i] * sd.w[Dim::J][j] * sd.g[Dim::K][k] };
738
739 for ( int d1 = 0; d1 < 3; ++d1 )
740 {
741 for ( int d0 = 0; d0 < 3; ++d0 )
742 view_access( sd.s[Dim::I][i], sd.s[Dim::J][j],
743 sd.s[Dim::K][k], d0 ) +=
744 rg[d1] * point_data[d0][d1];
745 }
746 }
747}
748
756template <class ScatterViewType, class SplineDataType, class PointDataType>
757KOKKOS_INLINE_FUNCTION
758 std::enable_if_t<2 == SplineDataType::num_space_dim, void>
759 divergence( const PointDataType point_data[2][2], const SplineDataType& sd,
760 const ScatterViewType& view,
761 typename std::enable_if<
762 ( std::rank<PointDataType>::value == 0 ), void*>::type = 0 )
763{
764 static_assert( SplineDataType::has_weight_values,
765 "P2G::divergence requires spline weight values" );
766 static_assert(
767 SplineDataType::has_weight_physical_gradients,
768 "P2G::divergence requires spline weight physical gradients" );
769
770 static_assert( is_scatter_view<ScatterViewType>::value,
771 "P2G requires a Kokkos::ScatterView" );
772 auto view_access = view.access();
773
774 for ( int i = 0; i < SplineDataType::num_knot; ++i )
775 for ( int j = 0; j < SplineDataType::num_knot; ++j )
776 {
777 typename SplineDataType::scalar_type rg[2] = {
778 sd.g[Dim::I][i] * sd.w[Dim::J][j],
779 sd.w[Dim::I][i] * sd.g[Dim::J][j] };
780
781 for ( int d1 = 0; d1 < 2; ++d1 )
782 {
783 for ( int d0 = 0; d0 < 2; ++d0 )
784 view_access( sd.s[Dim::I][i], sd.s[Dim::J][j], d0 ) +=
785 rg[d1] * point_data[d0][d1];
786 }
787 }
788}
789
790//---------------------------------------------------------------------------//
791
792} // end namespace P2G
793
794//---------------------------------------------------------------------------//
795// GLOBAL INTERPOLATION
796//---------------------------------------------------------------------------//
797
798//---------------------------------------------------------------------------//
799// Global grid-to-Point
800//---------------------------------------------------------------------------//
831template <class ExecutionSpace, class PointEvalFunctor, class PointCoordinates,
832 class ArrayScalar, class MeshScalar, class EntityType,
833 int SplineOrder, std::size_t NumSpaceDim, class MemorySpace,
834 class... ArrayParams>
835void g2p(
836 ExecutionSpace,
837 const Array<ArrayScalar, EntityType, UniformMesh<MeshScalar, NumSpaceDim>,
838 ArrayParams...>& array,
839 const Halo<MemorySpace>& halo, const PointCoordinates& points,
840 const std::size_t num_point, Spline<SplineOrder>,
841 const PointEvalFunctor& functor )
842{
843 using array_type =
844 Array<ArrayScalar, EntityType, UniformMesh<MeshScalar, NumSpaceDim>,
845 ArrayParams...>;
846 static_assert(
847 std::is_same<MemorySpace, typename array_type::memory_space>::value,
848 "Mismatching points/array memory space." );
849
850 // Create the local mesh.
851 auto local_mesh =
852 createLocalMesh<MemorySpace>( *( array.layout()->localGrid() ) );
853
854 // Gather data into the halo before interpolating.
855 halo.gather( ExecutionSpace(), array );
856
857 // Get a view of the array data.
858 auto array_view = array.view();
859
860 // Loop over points and interpolate from the grid.
861 Kokkos::parallel_for(
862 "Cabana::Grid::g2p",
863 Kokkos::RangePolicy<ExecutionSpace>( 0, num_point ),
864 KOKKOS_LAMBDA( const int p ) {
865 // Get the point coordinates.
866 MeshScalar px[NumSpaceDim];
867 for ( std::size_t d = 0; d < NumSpaceDim; ++d )
868 {
869 px[d] = points( p, d );
870 }
871
872 // Create the local spline data.
873 using sd_type =
874 SplineData<MeshScalar, SplineOrder, NumSpaceDim, EntityType>;
875 sd_type sd;
876 evaluateSpline( local_mesh, px, sd );
877
878 // Evaluate the functor.
879 functor( sd, p, array_view );
880 } );
881}
882
912template <class PointEvalFunctor, class PointCoordinates, class ArrayScalar,
913 class MeshScalar, class EntityType, int SplineOrder,
914 std::size_t NumSpaceDim, class MemorySpace, class... ArrayParams>
915void g2p(
916 const Array<ArrayScalar, EntityType, UniformMesh<MeshScalar, NumSpaceDim>,
917 ArrayParams...>& array,
918 const Halo<MemorySpace>& halo, const PointCoordinates& points,
919 const std::size_t num_point, Spline<SplineOrder>,
920 const PointEvalFunctor& functor )
921{
922 using exec_space = typename Array<ArrayScalar, EntityType,
923 UniformMesh<MeshScalar, NumSpaceDim>,
924 ArrayParams...>::execution_space;
925 g2p( exec_space{}, array, halo, points, num_point, Spline<SplineOrder>{},
926 functor );
927}
928
929//---------------------------------------------------------------------------//
938template <class ViewType>
939struct ScalarValueG2P
940{
942 using value_type = typename ViewType::value_type;
943
945 ViewType _x;
947 value_type _multiplier;
948
950 ScalarValueG2P( const ViewType& x, const value_type multiplier )
951 : _x( x )
952 , _multiplier( multiplier )
953 {
954 static_assert( 1 == ViewType::rank, "View must be of scalars" );
955 }
956
958 template <class SplineDataType, class GridViewType>
959 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
960 const int p,
961 const GridViewType& view ) const
962 {
963 value_type result;
964 G2P::value( view, sd, result );
965 _x( p ) += _multiplier * result;
966 }
967};
968
971template <class ViewType>
972ScalarValueG2P<ViewType>
973createScalarValueG2P( const ViewType& x,
974 const typename ViewType::value_type& multiplier )
975{
976 return ScalarValueG2P<ViewType>( x, multiplier );
977}
978
979//---------------------------------------------------------------------------//
988template <class ViewType>
989struct VectorValueG2P
990{
992 using value_type = typename ViewType::value_type;
993
995 ViewType _x;
997 value_type _multiplier;
998
1000 VectorValueG2P( const ViewType& x, const value_type multiplier )
1001 : _x( x )
1002 , _multiplier( multiplier )
1003 {
1004 static_assert( 2 == ViewType::rank, "View must be of vectors" );
1005 }
1006
1008 template <class SplineDataType, class GridViewType>
1009 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1010 const int p,
1011 const GridViewType& view ) const
1012 {
1013 value_type result[SplineDataType::num_space_dim];
1014 G2P::value( view, sd, result );
1015 for ( std::size_t d = 0; d < SplineDataType::num_space_dim; ++d )
1016 _x( p, d ) += _multiplier * result[d];
1017 }
1018};
1019
1022template <class ViewType>
1023VectorValueG2P<ViewType>
1024createVectorValueG2P( const ViewType& x,
1025 const typename ViewType::value_type& multiplier )
1026{
1027 return VectorValueG2P<ViewType>( x, multiplier );
1028}
1029
1030//---------------------------------------------------------------------------//
1039template <class ViewType>
1040struct ScalarGradientG2P
1041{
1043 using value_type = typename ViewType::value_type;
1044
1046 ViewType _x;
1048 value_type _multiplier;
1049
1051 ScalarGradientG2P( const ViewType& x, const value_type multiplier )
1052 : _x( x )
1053 , _multiplier( multiplier )
1054 {
1055 static_assert( 2 == ViewType::rank, "View must be of vectors" );
1056 }
1057
1059 template <class SplineDataType, class GridViewType>
1060 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1061 const int p,
1062 const GridViewType& view ) const
1063 {
1064 value_type result[SplineDataType::num_space_dim];
1065 G2P::gradient( view, sd, result );
1066 for ( std::size_t d = 0; d < SplineDataType::num_space_dim; ++d )
1067 _x( p, d ) += _multiplier * result[d];
1068 }
1069};
1070
1073template <class ViewType>
1074ScalarGradientG2P<ViewType>
1075createScalarGradientG2P( const ViewType& x,
1076 const typename ViewType::value_type& multiplier )
1077{
1078 return ScalarGradientG2P<ViewType>( x, multiplier );
1079}
1080
1081//---------------------------------------------------------------------------//
1090template <class ViewType>
1091struct VectorGradientG2P
1092{
1094 using value_type = typename ViewType::value_type;
1095
1097 ViewType _x;
1099 value_type _multiplier;
1100
1102 VectorGradientG2P( const ViewType& x, const value_type multiplier )
1103 : _x( x )
1104 , _multiplier( multiplier )
1105 {
1106 static_assert( 3 == ViewType::rank, "View must be of tensors" );
1107 }
1108
1110 template <class SplineDataType, class GridViewType>
1111 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1112 const int p,
1113 const GridViewType& view ) const
1114 {
1115 value_type result[SplineDataType::num_space_dim]
1116 [SplineDataType::num_space_dim];
1117 G2P::gradient( view, sd, result );
1118 for ( std::size_t d0 = 0; d0 < SplineDataType::num_space_dim; ++d0 )
1119 for ( std::size_t d1 = 0; d1 < SplineDataType::num_space_dim; ++d1 )
1120 _x( p, d0, d1 ) += _multiplier * result[d0][d1];
1121 }
1122};
1123
1126template <class ViewType>
1127VectorGradientG2P<ViewType>
1128createVectorGradientG2P( const ViewType& x,
1129 const typename ViewType::value_type& multiplier )
1130{
1131 return VectorGradientG2P<ViewType>( x, multiplier );
1132}
1133
1134//---------------------------------------------------------------------------//
1143template <class ViewType>
1144struct VectorDivergenceG2P
1145{
1147 using value_type = typename ViewType::value_type;
1148
1150 ViewType _x;
1152 value_type _multiplier;
1153
1155 VectorDivergenceG2P( const ViewType& x, const value_type multiplier )
1156 : _x( x )
1157 , _multiplier( multiplier )
1158 {
1159 static_assert( 1 == ViewType::rank, "View must be of scalars" );
1160 }
1161
1163 template <class SplineDataType, class GridViewType>
1164 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1165 const int p,
1166 const GridViewType& view ) const
1167 {
1168 value_type result;
1169 G2P::divergence( view, sd, result );
1170 _x( p ) += result * _multiplier;
1171 }
1172};
1173
1176template <class ViewType>
1177VectorDivergenceG2P<ViewType>
1178createVectorDivergenceG2P( const ViewType& x,
1179 const typename ViewType::value_type& multiplier )
1180{
1181 return VectorDivergenceG2P<ViewType>( x, multiplier );
1182}
1183
1184//---------------------------------------------------------------------------//
1185// Global point-to-grid
1186//---------------------------------------------------------------------------//
1217template <class ExecutionSpace, class PointEvalFunctor, class PointCoordinates,
1218 class ArrayScalar, class MeshScalar, std::size_t NumSpaceDim,
1219 class EntityType, int SplineOrder, class MemorySpace,
1220 class... ArrayParams>
1221void p2g( ExecutionSpace, const PointEvalFunctor& functor,
1222 const PointCoordinates& points, const std::size_t num_point,
1223 Spline<SplineOrder>, const Halo<MemorySpace>& halo,
1224 Array<ArrayScalar, EntityType, UniformMesh<MeshScalar, NumSpaceDim>,
1225 ArrayParams...>& array )
1226{
1227 using array_type =
1228 Array<ArrayScalar, EntityType, UniformMesh<MeshScalar, NumSpaceDim>,
1229 ArrayParams...>;
1230 static_assert(
1231 std::is_same<MemorySpace, typename array_type::memory_space>::value,
1232 "Mismatching points/array memory space." );
1233
1234 // Create the local mesh.
1235 auto local_mesh =
1236 createLocalMesh<MemorySpace>( *( array.layout()->localGrid() ) );
1237
1238 // Create a scatter view of the array.
1239 auto array_view = array.view();
1240 auto array_sv = Kokkos::Experimental::create_scatter_view( array_view );
1241
1242 // Loop over points and interpolate to the grid.
1243 Kokkos::parallel_for(
1244 "Cabana::Grid::p2g",
1245 Kokkos::RangePolicy<ExecutionSpace>( 0, num_point ),
1246 KOKKOS_LAMBDA( const int p ) {
1247 // Get the point coordinates.
1248 MeshScalar px[NumSpaceDim];
1249 for ( std::size_t d = 0; d < NumSpaceDim; ++d )
1250 {
1251 px[d] = points( p, d );
1252 }
1253
1254 // Create the local spline data.
1255 using sd_type =
1256 SplineData<MeshScalar, SplineOrder, NumSpaceDim, EntityType>;
1257 sd_type sd;
1258 evaluateSpline( local_mesh, px, sd );
1259
1260 // Evaluate the functor.
1261 functor( sd, p, array_sv );
1262 } );
1263 Kokkos::Experimental::contribute( array_view, array_sv );
1264
1265 // Scatter interpolation contributions in the halo back to their owning
1266 // ranks.
1267 halo.scatter( ExecutionSpace(), ScatterReduce::Sum(), array );
1268}
1269
1299template <class PointEvalFunctor, class PointCoordinates, class ArrayScalar,
1300 class MeshScalar, std::size_t NumSpaceDim, class EntityType,
1301 int SplineOrder, class MemorySpace, class... ArrayParams>
1302void p2g( const PointEvalFunctor& functor, const PointCoordinates& points,
1303 const std::size_t num_point, Spline<SplineOrder>,
1304 const Halo<MemorySpace>& halo,
1305 Array<ArrayScalar, EntityType, UniformMesh<MeshScalar, NumSpaceDim>,
1306 ArrayParams...>& array )
1307{
1308 using exec_space = typename Array<ArrayScalar, EntityType,
1309 UniformMesh<MeshScalar, NumSpaceDim>,
1310 ArrayParams...>::execution_space;
1311 p2g( exec_space{}, functor, points, num_point, Spline<SplineOrder>{}, halo,
1312 array );
1313}
1314
1315//---------------------------------------------------------------------------//
1324template <class ViewType>
1325struct ScalarValueP2G
1326{
1328 using value_type = typename ViewType::value_type;
1329
1331 ViewType _x;
1333 value_type _multiplier;
1334
1336 ScalarValueP2G( const ViewType& x, const value_type multiplier )
1337 : _x( x )
1338 , _multiplier( multiplier )
1339 {
1340 static_assert( 1 == ViewType::rank, "View must be of scalars" );
1341 }
1342
1344 template <class SplineDataType, class GridViewType>
1345 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1346 const int p,
1347 const GridViewType& view ) const
1348 {
1349 value_type point_data = _x( p ) * _multiplier;
1350 P2G::value( point_data, sd, view );
1351 }
1352};
1353
1356template <class ViewType>
1357ScalarValueP2G<ViewType>
1358createScalarValueP2G( const ViewType& x,
1359 const typename ViewType::value_type& multiplier )
1360{
1361 return ScalarValueP2G<ViewType>( x, multiplier );
1362}
1363
1364//---------------------------------------------------------------------------//
1373template <class ViewType>
1374struct VectorValueP2G
1375{
1377 using value_type = typename ViewType::value_type;
1378
1380 ViewType _x;
1382 value_type _multiplier;
1383
1385 VectorValueP2G( const ViewType& x, const value_type multiplier )
1386 : _x( x )
1387 , _multiplier( multiplier )
1388 {
1389 static_assert( 2 == ViewType::rank, "View must be of vectors" );
1390 }
1391
1393 template <class SplineDataType, class GridViewType>
1394 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1395 const int p,
1396 const GridViewType& view ) const
1397 {
1398 value_type point_data[SplineDataType::num_space_dim];
1399 for ( std::size_t d = 0; d < SplineDataType::num_space_dim; ++d )
1400 point_data[d] = _multiplier * _x( p, d );
1401 P2G::value( point_data, sd, view );
1402 }
1403};
1404
1407template <class ViewType>
1408VectorValueP2G<ViewType>
1409createVectorValueP2G( const ViewType& x,
1410 const typename ViewType::value_type& multiplier )
1411{
1412 return VectorValueP2G<ViewType>( x, multiplier );
1413}
1414
1415//---------------------------------------------------------------------------//
1424template <class ViewType>
1425struct ScalarGradientP2G
1426{
1428 using value_type = typename ViewType::value_type;
1429
1431 ViewType _x;
1433 value_type _multiplier;
1434
1436 ScalarGradientP2G( const ViewType& x, const value_type multiplier )
1437 : _x( x )
1438 , _multiplier( multiplier )
1439 {
1440 static_assert( 1 == ViewType::rank, "View must be of scalars" );
1441 }
1442
1444 template <class SplineDataType, class GridViewType>
1445 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1446 const int p,
1447 const GridViewType& view ) const
1448 {
1449 value_type point_data = _x( p ) * _multiplier;
1450 P2G::gradient( point_data, sd, view );
1451 }
1452};
1453
1456template <class ViewType>
1457ScalarGradientP2G<ViewType>
1458createScalarGradientP2G( const ViewType& x,
1459 const typename ViewType::value_type& multiplier )
1460{
1461 return ScalarGradientP2G<ViewType>( x, multiplier );
1462}
1463
1464//---------------------------------------------------------------------------//
1473template <class ViewType>
1474struct VectorDivergenceP2G
1475{
1477 using value_type = typename ViewType::value_type;
1478
1480 ViewType _x;
1482 value_type _multiplier;
1483
1485 VectorDivergenceP2G( const ViewType& x, const value_type multiplier )
1486 : _x( x )
1487 , _multiplier( multiplier )
1488 {
1489 static_assert( 2 == ViewType::rank, "View must be of vectors" );
1490 }
1491
1493 template <class SplineDataType, class GridViewType>
1494 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1495 const int p,
1496 const GridViewType& view ) const
1497 {
1498 value_type point_data[SplineDataType::num_space_dim];
1499 for ( std::size_t d = 0; d < SplineDataType::num_space_dim; ++d )
1500 point_data[d] = _multiplier * _x( p, d );
1501 P2G::divergence( point_data, sd, view );
1502 }
1503};
1504
1507template <class ViewType>
1508VectorDivergenceP2G<ViewType>
1509createVectorDivergenceP2G( const ViewType& x,
1510 const typename ViewType::value_type& multiplier )
1511{
1512 return VectorDivergenceP2G<ViewType>( x, multiplier );
1513}
1514
1515//---------------------------------------------------------------------------//
1524template <class ViewType>
1525struct TensorDivergenceP2G
1526{
1528 using value_type = typename ViewType::value_type;
1529
1531 ViewType _x;
1533 value_type _multiplier;
1534
1536 TensorDivergenceP2G( const ViewType& x, const value_type multiplier )
1537 : _x( x )
1538 , _multiplier( multiplier )
1539 {
1540 static_assert( 3 == ViewType::rank, "View must be of tensors" );
1541 }
1542
1544 template <class SplineDataType, class GridViewType>
1545 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1546 const int p,
1547 const GridViewType& view ) const
1548 {
1549 value_type point_data[SplineDataType::num_space_dim]
1550 [SplineDataType::num_space_dim];
1551 for ( std::size_t d0 = 0; d0 < SplineDataType::num_space_dim; ++d0 )
1552 for ( std::size_t d1 = 0; d1 < SplineDataType::num_space_dim; ++d1 )
1553 point_data[d0][d1] = _multiplier * _x( p, d0, d1 );
1554 P2G::divergence( point_data, sd, view );
1555 }
1556};
1557
1560template <class ViewType>
1561TensorDivergenceP2G<ViewType>
1562createTensorDivergenceP2G( const ViewType& x,
1563 const typename ViewType::value_type& multiplier )
1564{
1565 return TensorDivergenceP2G<ViewType>( x, multiplier );
1566}
1567
1568//---------------------------------------------------------------------------//
1569
1570} // namespace Grid
1571} // namespace Cabana
1572
1573#endif // end CABANA_GRID_INTERPOLATION_HPP
Cabana_Grid_Array.hpp
Grid field arrays.
Cabana_Grid_Halo.hpp
Multi-node grid scatter/gather.
Cabana::Grid::createVectorDivergenceG2P
VectorDivergenceG2P< ViewType > createVectorDivergenceG2P(const ViewType &x, const typename ViewType::value_type &multiplier)
Creation function for grid-to-point with vector divergence.
Definition Cabana_Grid_Interpolation.hpp:1178
Cabana::Grid::createVectorDivergenceP2G
VectorDivergenceP2G< ViewType > createVectorDivergenceP2G(const ViewType &x, const typename ViewType::value_type &multiplier)
Creation function for point-to-grid with vector divergence.
Definition Cabana_Grid_Interpolation.hpp:1509
Cabana::Grid::createTensorDivergenceP2G
TensorDivergenceP2G< ViewType > createTensorDivergenceP2G(const ViewType &x, const typename ViewType::value_type &multiplier)
Creation function for point-to-grid with tensor divergence.
Definition Cabana_Grid_Interpolation.hpp:1562
Cabana::Grid::createScalarGradientG2P
ScalarGradientG2P< ViewType > createScalarGradientG2P(const ViewType &x, const typename ViewType::value_type &multiplier)
Creation function for grid-to-point with scalar gradient.
Definition Cabana_Grid_Interpolation.hpp:1075
Cabana::Grid::G2P::gradient
KOKKOS_INLINE_FUNCTION std::enable_if_t< 3==SplineDataType::num_space_dim, void > gradient(const ViewType &view, const SplineDataType &sd, PointDataType result[3], typename std::enable_if<(std::rank< PointDataType >::value==0), void * >::type=0)
Interpolate a scalar gradient to a point. 3D specialization.
Definition Cabana_Grid_Interpolation.hpp:171
Cabana::Grid::createVectorGradientG2P
VectorGradientG2P< ViewType > createVectorGradientG2P(const ViewType &x, const typename ViewType::value_type &multiplier)
Creation function for grid-to-point with vector gradient.
Definition Cabana_Grid_Interpolation.hpp:1128
Cabana::Grid::createScalarValueP2G
ScalarValueP2G< ViewType > createScalarValueP2G(const ViewType &x, const typename ViewType::value_type &multiplier)
Creation function for point-to-grid with scalar value.
Definition Cabana_Grid_Interpolation.hpp:1358
Cabana::Grid::P2G::divergence
KOKKOS_INLINE_FUNCTION std::enable_if_t< 3==SplineDataType::num_space_dim, void > divergence(const PointDataType point_data[3], const SplineDataType &sd, const ScatterViewType &view, typename std::enable_if<(std::rank< PointDataType >::value==0), void * >::type=0)
Interpolate the divergence of a vector to the grid. 3D specialization.
Definition Cabana_Grid_Interpolation.hpp:634
Cabana::Grid::P2G::gradient
KOKKOS_INLINE_FUNCTION std::enable_if_t< 3==SplineDataType::num_space_dim, void > gradient(const PointDataType point_data, const SplineDataType &sd, const ScatterViewType &view)
Interpolate the gradient of a scalar to the grid. 3D specialization.
Definition Cabana_Grid_Interpolation.hpp:560
Cabana::Grid::createVectorValueP2G
VectorValueP2G< ViewType > createVectorValueP2G(const ViewType &x, const typename ViewType::value_type &multiplier)
Creation function for point-to-grid with vector value.
Definition Cabana_Grid_Interpolation.hpp:1409
Cabana::Grid::createVectorValueG2P
VectorValueG2P< ViewType > createVectorValueG2P(const ViewType &x, const typename ViewType::value_type &multiplier)
Creation function for grid-to-point with vector value.
Definition Cabana_Grid_Interpolation.hpp:1024
Cabana::Grid::P2G::value
KOKKOS_INLINE_FUNCTION std::enable_if_t< 3==SplineDataType::num_space_dim, void > value(const PointDataType &point_data, const SplineDataType &sd, const ScatterViewType &view, typename std::enable_if<(std::rank< PointDataType >::value==0), void * >::type=0)
Interpolate a scalar value to the grid. 3D specialization.
Definition Cabana_Grid_Interpolation.hpp:440
Cabana::Grid::g2p
void g2p(ExecutionSpace, const Array< ArrayScalar, EntityType, UniformMesh< MeshScalar, NumSpaceDim >, ArrayParams... > &array, const Halo< MemorySpace > &halo, const PointCoordinates &points, const std::size_t num_point, Spline< SplineOrder >, const PointEvalFunctor &functor)
Global Grid-to-Point interpolation.
Definition Cabana_Grid_Interpolation.hpp:835
Cabana::Grid::createScalarGradientP2G
ScalarGradientP2G< ViewType > createScalarGradientP2G(const ViewType &x, const typename ViewType::value_type &multiplier)
Creation function for point-to-grid with scalar gradient.
Definition Cabana_Grid_Interpolation.hpp:1458
Cabana::Grid::G2P::divergence
KOKKOS_INLINE_FUNCTION std::enable_if_t< 3==SplineDataType::num_space_dim, void > divergence(const ViewType &view, const SplineDataType &sd, PointDataType &result, typename std::enable_if<(std::rank< PointDataType >::value==0), void * >::type=0)
Interpolate a vector divergence to a point. 3D specialization.
Definition Cabana_Grid_Interpolation.hpp:336
Cabana::Grid::G2P::value
KOKKOS_INLINE_FUNCTION std::enable_if_t< 3==SplineDataType::num_space_dim, void > value(const ViewType &view, const SplineDataType &sd, PointDataType &result, typename std::enable_if<(std::rank< PointDataType >::value==0), void * >::type=0)
Interpolate a scalar value to a point. 3D specialization.
Definition Cabana_Grid_Interpolation.hpp:56
Cabana::Grid::p2g
void p2g(ExecutionSpace, const PointEvalFunctor &functor, const PointCoordinates &points, const std::size_t num_point, Spline< SplineOrder >, const Halo< MemorySpace > &halo, Array< ArrayScalar, EntityType, UniformMesh< MeshScalar, NumSpaceDim >, ArrayParams... > &array)
Global Point-to-Grid interpolation.
Definition Cabana_Grid_Interpolation.hpp:1221
Cabana::Grid::createScalarValueG2P
ScalarValueG2P< ViewType > createScalarValueG2P(const ViewType &x, const typename ViewType::value_type &multiplier)
Creation function for grid-to-point with scalar value.
Definition Cabana_Grid_Interpolation.hpp:973
Cabana_Grid_LocalMesh.hpp
Local mesh.
Cabana::Grid::createLocalMesh
LocalMesh< MemorySpace, MeshType > createLocalMesh(const LocalGrid< MeshType > &local_grid)
Creation function for local mesh.
Definition Cabana_Grid_LocalMesh.hpp:791
Cabana_Grid_Splines.hpp
Spline functions.
Cabana::Grid::evaluateSpline
KOKKOS_INLINE_FUNCTION void evaluateSpline(const LocalMesh< MemorySpace, UniformMesh< Scalar, NumSpaceDim > > &local_mesh, const Scalar p[NumSpaceDim], SplineData< Scalar, Order, NumSpaceDim, EntityType, DataTags > &data)
Evaluate spline data at a point in a uniform mesh.
Definition Cabana_Grid_Splines.hpp:1283
Cabana_Grid_Types.hpp
Grid type tags.
Cabana_Utils.hpp
Cabana utilities.
Cabana::Grid::Array
Array of field data on the local mesh.
Definition Cabana_Grid_Array.hpp:229
Cabana::Grid::Halo
Definition Cabana_Grid_Halo.hpp:201
Cabana::Grid::Halo::scatter
void scatter(const ExecutionSpace &exec_space, const ReduceOp &reduce_op, const ArrayTypes &... arrays) const
Scatter data from our ghosts to their owners using the given type of reduce operation.
Definition Cabana_Grid_Halo.hpp:376
Cabana::Grid::Halo::gather
void gather(const ExecutionSpace &exec_space, const ArrayTypes &... arrays) const
Gather data into our ghosts from their owners.
Definition Cabana_Grid_Halo.hpp:288
Cabana
Core: particle data structures and algorithms.
Definition Cabana_AoSoA.hpp:36
Cabana::Grid::P2G::is_scatter_view
Scatter-View static type checker.
Definition Cabana_Grid_Interpolation.hpp:427
Cabana::Grid::ScalarGradientG2P
Grid-to-point scalar gradient functor.
Definition Cabana_Grid_Interpolation.hpp:1041
Cabana::Grid::ScalarGradientG2P::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1046
Cabana::Grid::ScalarGradientG2P::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1043
Cabana::Grid::ScalarGradientG2P::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1048
Cabana::Grid::ScalarGradientG2P::operator()
KOKKOS_INLINE_FUNCTION void operator()(const SplineDataType &sd, const int p, const GridViewType &view) const
Apply spline interplation.
Definition Cabana_Grid_Interpolation.hpp:1060
Cabana::Grid::ScalarGradientG2P::ScalarGradientG2P
ScalarGradientG2P(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1051
Cabana::Grid::ScalarGradientP2G
Point-to-grid scalar gradient functor.
Definition Cabana_Grid_Interpolation.hpp:1426
Cabana::Grid::ScalarGradientP2G::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1433
Cabana::Grid::ScalarGradientP2G::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1428
Cabana::Grid::ScalarGradientP2G::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1431
Cabana::Grid::ScalarGradientP2G::ScalarGradientP2G
ScalarGradientP2G(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1436
Cabana::Grid::ScalarGradientP2G::operator()
KOKKOS_INLINE_FUNCTION void operator()(const SplineDataType &sd, const int p, const GridViewType &view) const
Apply spline interplation.
Definition Cabana_Grid_Interpolation.hpp:1445
Cabana::Grid::ScalarValueG2P
Grid-to-point scalar value functor.
Definition Cabana_Grid_Interpolation.hpp:940
Cabana::Grid::ScalarValueG2P::ScalarValueG2P
ScalarValueG2P(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:950
Cabana::Grid::ScalarValueG2P::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:942
Cabana::Grid::ScalarValueG2P::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:945
Cabana::Grid::ScalarValueG2P::operator()
KOKKOS_INLINE_FUNCTION void operator()(const SplineDataType &sd, const int p, const GridViewType &view) const
Apply spline interplation.
Definition Cabana_Grid_Interpolation.hpp:959
Cabana::Grid::ScalarValueG2P::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:947
Cabana::Grid::ScalarValueP2G
Point-to-grid scalar value functor.
Definition Cabana_Grid_Interpolation.hpp:1326
Cabana::Grid::ScalarValueP2G::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1331
Cabana::Grid::ScalarValueP2G::ScalarValueP2G
ScalarValueP2G(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1336
Cabana::Grid::ScalarValueP2G::operator()
KOKKOS_INLINE_FUNCTION void operator()(const SplineDataType &sd, const int p, const GridViewType &view) const
Apply spline interplation.
Definition Cabana_Grid_Interpolation.hpp:1345
Cabana::Grid::ScalarValueP2G::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1333
Cabana::Grid::ScalarValueP2G::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1328
Cabana::Grid::ScatterReduce::Sum
Sum values from neighboring ranks into this rank's data.
Definition Cabana_Grid_Halo.hpp:161
Cabana::Grid::SplineData
Spline data container.
Definition Cabana_Grid_Splines.hpp:1054
Cabana::Grid::Spline
B-Spline interface for uniform grids.
Definition Cabana_Grid_Splines.hpp:33
Cabana::Grid::TensorDivergenceP2G
Point-to-grid tensor divergence functor.
Definition Cabana_Grid_Interpolation.hpp:1526
Cabana::Grid::TensorDivergenceP2G::TensorDivergenceP2G
TensorDivergenceP2G(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1536
Cabana::Grid::TensorDivergenceP2G::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1531
Cabana::Grid::TensorDivergenceP2G::operator()
KOKKOS_INLINE_FUNCTION void operator()(const SplineDataType &sd, const int p, const GridViewType &view) const
Apply spline interplation.
Definition Cabana_Grid_Interpolation.hpp:1545
Cabana::Grid::TensorDivergenceP2G::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1528
Cabana::Grid::TensorDivergenceP2G::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1533
Cabana::Grid::UniformMesh
Uniform mesh tag.
Definition Cabana_Grid_Types.hpp:227
Cabana::Grid::VectorDivergenceG2P
Grid-to-point vector value functor.
Definition Cabana_Grid_Interpolation.hpp:1145
Cabana::Grid::VectorDivergenceG2P::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1150
Cabana::Grid::VectorDivergenceG2P::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1152
Cabana::Grid::VectorDivergenceG2P::VectorDivergenceG2P
VectorDivergenceG2P(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1155
Cabana::Grid::VectorDivergenceG2P::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1147
Cabana::Grid::VectorDivergenceG2P::operator()
KOKKOS_INLINE_FUNCTION void operator()(const SplineDataType &sd, const int p, const GridViewType &view) const
Apply spline interplation.
Definition Cabana_Grid_Interpolation.hpp:1164
Cabana::Grid::VectorDivergenceP2G
Point-to-grid vector divergence functor.
Definition Cabana_Grid_Interpolation.hpp:1475
Cabana::Grid::VectorDivergenceP2G::VectorDivergenceP2G
VectorDivergenceP2G(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1485
Cabana::Grid::VectorDivergenceP2G::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1480
Cabana::Grid::VectorDivergenceP2G::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1477
Cabana::Grid::VectorDivergenceP2G::operator()
KOKKOS_INLINE_FUNCTION void operator()(const SplineDataType &sd, const int p, const GridViewType &view) const
Apply spline interplation.
Definition Cabana_Grid_Interpolation.hpp:1494
Cabana::Grid::VectorDivergenceP2G::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1482
Cabana::Grid::VectorGradientG2P
Grid-to-point vector gradient functor.
Definition Cabana_Grid_Interpolation.hpp:1092
Cabana::Grid::VectorGradientG2P::VectorGradientG2P
VectorGradientG2P(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1102
Cabana::Grid::VectorGradientG2P::operator()
KOKKOS_INLINE_FUNCTION void operator()(const SplineDataType &sd, const int p, const GridViewType &view) const
Apply spline interplation.
Definition Cabana_Grid_Interpolation.hpp:1111
Cabana::Grid::VectorGradientG2P::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1099
Cabana::Grid::VectorGradientG2P::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1097
Cabana::Grid::VectorGradientG2P::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1094
Cabana::Grid::VectorValueG2P
Grid-to-point vector value functor.
Definition Cabana_Grid_Interpolation.hpp:990
Cabana::Grid::VectorValueG2P::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:995
Cabana::Grid::VectorValueG2P::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:997
Cabana::Grid::VectorValueG2P::operator()
KOKKOS_INLINE_FUNCTION void operator()(const SplineDataType &sd, const int p, const GridViewType &view) const
Apply spline interplation.
Definition Cabana_Grid_Interpolation.hpp:1009
Cabana::Grid::VectorValueG2P::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:992
Cabana::Grid::VectorValueG2P::VectorValueG2P
VectorValueG2P(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1000
Cabana::Grid::VectorValueP2G
Point-to-grid vector value functor.
Definition Cabana_Grid_Interpolation.hpp:1375
Cabana::Grid::VectorValueP2G::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1382
Cabana::Grid::VectorValueP2G::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1380
Cabana::Grid::VectorValueP2G::VectorValueP2G
VectorValueP2G(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1385
Cabana::Grid::VectorValueP2G::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1377
Cabana::Grid::VectorValueP2G::operator()
KOKKOS_INLINE_FUNCTION void operator()(const SplineDataType &sd, const int p, const GridViewType &view) const
Apply spline interplation.
Definition Cabana_Grid_Interpolation.hpp:1394