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 "g2p", Kokkos::RangePolicy<ExecutionSpace>( 0, num_point ),
863 KOKKOS_LAMBDA( const int p ) {
864 // Get the point coordinates.
865 MeshScalar px[NumSpaceDim];
866 for ( std::size_t d = 0; d < NumSpaceDim; ++d )
867 {
868 px[d] = points( p, d );
869 }
870
871 // Create the local spline data.
872 using sd_type =
873 SplineData<MeshScalar, SplineOrder, NumSpaceDim, EntityType>;
874 sd_type sd;
875 evaluateSpline( local_mesh, px, sd );
876
877 // Evaluate the functor.
878 functor( sd, p, array_view );
879 } );
880}
881
911template <class PointEvalFunctor, class PointCoordinates, class ArrayScalar,
912 class MeshScalar, class EntityType, int SplineOrder,
913 std::size_t NumSpaceDim, class MemorySpace, class... ArrayParams>
914void g2p(
915 const Array<ArrayScalar, EntityType, UniformMesh<MeshScalar, NumSpaceDim>,
916 ArrayParams...>& array,
917 const Halo<MemorySpace>& halo, const PointCoordinates& points,
918 const std::size_t num_point, Spline<SplineOrder>,
919 const PointEvalFunctor& functor )
920{
921 using exec_space = typename Array<ArrayScalar, EntityType,
922 UniformMesh<MeshScalar, NumSpaceDim>,
923 ArrayParams...>::execution_space;
924 g2p( exec_space{}, array, halo, points, num_point, Spline<SplineOrder>{},
925 functor );
926}
927
928//---------------------------------------------------------------------------//
937template <class ViewType>
938struct ScalarValueG2P
939{
941 using value_type = typename ViewType::value_type;
942
944 ViewType _x;
946 value_type _multiplier;
947
949 ScalarValueG2P( const ViewType& x, const value_type multiplier )
950 : _x( x )
951 , _multiplier( multiplier )
952 {
953 static_assert( 1 == ViewType::rank, "View must be of scalars" );
954 }
955
957 template <class SplineDataType, class GridViewType>
958 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
959 const int p,
960 const GridViewType& view ) const
961 {
962 value_type result;
963 G2P::value( view, sd, result );
964 _x( p ) += _multiplier * result;
965 }
966};
967
970template <class ViewType>
971ScalarValueG2P<ViewType>
972createScalarValueG2P( const ViewType& x,
973 const typename ViewType::value_type& multiplier )
974{
975 return ScalarValueG2P<ViewType>( x, multiplier );
976}
977
978//---------------------------------------------------------------------------//
987template <class ViewType>
988struct VectorValueG2P
989{
991 using value_type = typename ViewType::value_type;
992
994 ViewType _x;
996 value_type _multiplier;
997
999 VectorValueG2P( const ViewType& x, const value_type multiplier )
1000 : _x( x )
1001 , _multiplier( multiplier )
1002 {
1003 static_assert( 2 == ViewType::rank, "View must be of vectors" );
1004 }
1005
1007 template <class SplineDataType, class GridViewType>
1008 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1009 const int p,
1010 const GridViewType& view ) const
1011 {
1012 value_type result[SplineDataType::num_space_dim];
1013 G2P::value( view, sd, result );
1014 for ( std::size_t d = 0; d < SplineDataType::num_space_dim; ++d )
1015 _x( p, d ) += _multiplier * result[d];
1016 }
1017};
1018
1021template <class ViewType>
1022VectorValueG2P<ViewType>
1023createVectorValueG2P( const ViewType& x,
1024 const typename ViewType::value_type& multiplier )
1025{
1026 return VectorValueG2P<ViewType>( x, multiplier );
1027}
1028
1029//---------------------------------------------------------------------------//
1038template <class ViewType>
1039struct ScalarGradientG2P
1040{
1042 using value_type = typename ViewType::value_type;
1043
1045 ViewType _x;
1047 value_type _multiplier;
1048
1050 ScalarGradientG2P( const ViewType& x, const value_type multiplier )
1051 : _x( x )
1052 , _multiplier( multiplier )
1053 {
1054 static_assert( 2 == ViewType::rank, "View must be of vectors" );
1055 }
1056
1058 template <class SplineDataType, class GridViewType>
1059 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1060 const int p,
1061 const GridViewType& view ) const
1062 {
1063 value_type result[SplineDataType::num_space_dim];
1064 G2P::gradient( view, sd, result );
1065 for ( std::size_t d = 0; d < SplineDataType::num_space_dim; ++d )
1066 _x( p, d ) += _multiplier * result[d];
1067 }
1068};
1069
1072template <class ViewType>
1073ScalarGradientG2P<ViewType>
1074createScalarGradientG2P( const ViewType& x,
1075 const typename ViewType::value_type& multiplier )
1076{
1077 return ScalarGradientG2P<ViewType>( x, multiplier );
1078}
1079
1080//---------------------------------------------------------------------------//
1089template <class ViewType>
1090struct VectorGradientG2P
1091{
1093 using value_type = typename ViewType::value_type;
1094
1096 ViewType _x;
1098 value_type _multiplier;
1099
1101 VectorGradientG2P( const ViewType& x, const value_type multiplier )
1102 : _x( x )
1103 , _multiplier( multiplier )
1104 {
1105 static_assert( 3 == ViewType::rank, "View must be of tensors" );
1106 }
1107
1109 template <class SplineDataType, class GridViewType>
1110 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1111 const int p,
1112 const GridViewType& view ) const
1113 {
1114 value_type result[SplineDataType::num_space_dim]
1115 [SplineDataType::num_space_dim];
1116 G2P::gradient( view, sd, result );
1117 for ( std::size_t d0 = 0; d0 < SplineDataType::num_space_dim; ++d0 )
1118 for ( std::size_t d1 = 0; d1 < SplineDataType::num_space_dim; ++d1 )
1119 _x( p, d0, d1 ) += _multiplier * result[d0][d1];
1120 }
1121};
1122
1125template <class ViewType>
1126VectorGradientG2P<ViewType>
1127createVectorGradientG2P( const ViewType& x,
1128 const typename ViewType::value_type& multiplier )
1129{
1130 return VectorGradientG2P<ViewType>( x, multiplier );
1131}
1132
1133//---------------------------------------------------------------------------//
1142template <class ViewType>
1143struct VectorDivergenceG2P
1144{
1146 using value_type = typename ViewType::value_type;
1147
1149 ViewType _x;
1151 value_type _multiplier;
1152
1154 VectorDivergenceG2P( const ViewType& x, const value_type multiplier )
1155 : _x( x )
1156 , _multiplier( multiplier )
1157 {
1158 static_assert( 1 == ViewType::rank, "View must be of scalars" );
1159 }
1160
1162 template <class SplineDataType, class GridViewType>
1163 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1164 const int p,
1165 const GridViewType& view ) const
1166 {
1167 value_type result;
1168 G2P::divergence( view, sd, result );
1169 _x( p ) += result * _multiplier;
1170 }
1171};
1172
1175template <class ViewType>
1176VectorDivergenceG2P<ViewType>
1177createVectorDivergenceG2P( const ViewType& x,
1178 const typename ViewType::value_type& multiplier )
1179{
1180 return VectorDivergenceG2P<ViewType>( x, multiplier );
1181}
1182
1183//---------------------------------------------------------------------------//
1184// Global point-to-grid
1185//---------------------------------------------------------------------------//
1216template <class ExecutionSpace, class PointEvalFunctor, class PointCoordinates,
1217 class ArrayScalar, class MeshScalar, std::size_t NumSpaceDim,
1218 class EntityType, int SplineOrder, class MemorySpace,
1219 class... ArrayParams>
1220void p2g( ExecutionSpace, const PointEvalFunctor& functor,
1221 const PointCoordinates& points, const std::size_t num_point,
1222 Spline<SplineOrder>, const Halo<MemorySpace>& halo,
1223 Array<ArrayScalar, EntityType, UniformMesh<MeshScalar, NumSpaceDim>,
1224 ArrayParams...>& array )
1225{
1226 using array_type =
1227 Array<ArrayScalar, EntityType, UniformMesh<MeshScalar, NumSpaceDim>,
1228 ArrayParams...>;
1229 static_assert(
1230 std::is_same<MemorySpace, typename array_type::memory_space>::value,
1231 "Mismatching points/array memory space." );
1232
1233 // Create the local mesh.
1234 auto local_mesh =
1235 createLocalMesh<MemorySpace>( *( array.layout()->localGrid() ) );
1236
1237 // Create a scatter view of the array.
1238 auto array_view = array.view();
1239 auto array_sv = Kokkos::Experimental::create_scatter_view( array_view );
1240
1241 // Loop over points and interpolate to the grid.
1242 Kokkos::parallel_for(
1243 "p2g", Kokkos::RangePolicy<ExecutionSpace>( 0, num_point ),
1244 KOKKOS_LAMBDA( const int p ) {
1245 // Get the point coordinates.
1246 MeshScalar px[NumSpaceDim];
1247 for ( std::size_t d = 0; d < NumSpaceDim; ++d )
1248 {
1249 px[d] = points( p, d );
1250 }
1251
1252 // Create the local spline data.
1253 using sd_type =
1254 SplineData<MeshScalar, SplineOrder, NumSpaceDim, EntityType>;
1255 sd_type sd;
1256 evaluateSpline( local_mesh, px, sd );
1257
1258 // Evaluate the functor.
1259 functor( sd, p, array_sv );
1260 } );
1261 Kokkos::Experimental::contribute( array_view, array_sv );
1262
1263 // Scatter interpolation contributions in the halo back to their owning
1264 // ranks.
1265 halo.scatter( ExecutionSpace(), ScatterReduce::Sum(), array );
1266}
1267
1297template <class PointEvalFunctor, class PointCoordinates, class ArrayScalar,
1298 class MeshScalar, std::size_t NumSpaceDim, class EntityType,
1299 int SplineOrder, class MemorySpace, class... ArrayParams>
1300void p2g( const PointEvalFunctor& functor, const PointCoordinates& points,
1301 const std::size_t num_point, Spline<SplineOrder>,
1302 const Halo<MemorySpace>& halo,
1303 Array<ArrayScalar, EntityType, UniformMesh<MeshScalar, NumSpaceDim>,
1304 ArrayParams...>& array )
1305{
1306 using exec_space = typename Array<ArrayScalar, EntityType,
1307 UniformMesh<MeshScalar, NumSpaceDim>,
1308 ArrayParams...>::execution_space;
1309 p2g( exec_space{}, functor, points, num_point, Spline<SplineOrder>{}, halo,
1310 array );
1311}
1312
1313//---------------------------------------------------------------------------//
1322template <class ViewType>
1323struct ScalarValueP2G
1324{
1326 using value_type = typename ViewType::value_type;
1327
1329 ViewType _x;
1331 value_type _multiplier;
1332
1334 ScalarValueP2G( const ViewType& x, const value_type multiplier )
1335 : _x( x )
1336 , _multiplier( multiplier )
1337 {
1338 static_assert( 1 == ViewType::rank, "View must be of scalars" );
1339 }
1340
1342 template <class SplineDataType, class GridViewType>
1343 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1344 const int p,
1345 const GridViewType& view ) const
1346 {
1347 value_type point_data = _x( p ) * _multiplier;
1348 P2G::value( point_data, sd, view );
1349 }
1350};
1351
1354template <class ViewType>
1355ScalarValueP2G<ViewType>
1356createScalarValueP2G( const ViewType& x,
1357 const typename ViewType::value_type& multiplier )
1358{
1359 return ScalarValueP2G<ViewType>( x, multiplier );
1360}
1361
1362//---------------------------------------------------------------------------//
1371template <class ViewType>
1372struct VectorValueP2G
1373{
1375 using value_type = typename ViewType::value_type;
1376
1378 ViewType _x;
1380 value_type _multiplier;
1381
1383 VectorValueP2G( const ViewType& x, const value_type multiplier )
1384 : _x( x )
1385 , _multiplier( multiplier )
1386 {
1387 static_assert( 2 == ViewType::rank, "View must be of vectors" );
1388 }
1389
1391 template <class SplineDataType, class GridViewType>
1392 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1393 const int p,
1394 const GridViewType& view ) const
1395 {
1396 value_type point_data[SplineDataType::num_space_dim];
1397 for ( std::size_t d = 0; d < SplineDataType::num_space_dim; ++d )
1398 point_data[d] = _multiplier * _x( p, d );
1399 P2G::value( point_data, sd, view );
1400 }
1401};
1402
1405template <class ViewType>
1406VectorValueP2G<ViewType>
1407createVectorValueP2G( const ViewType& x,
1408 const typename ViewType::value_type& multiplier )
1409{
1410 return VectorValueP2G<ViewType>( x, multiplier );
1411}
1412
1413//---------------------------------------------------------------------------//
1422template <class ViewType>
1423struct ScalarGradientP2G
1424{
1426 using value_type = typename ViewType::value_type;
1427
1429 ViewType _x;
1431 value_type _multiplier;
1432
1434 ScalarGradientP2G( const ViewType& x, const value_type multiplier )
1435 : _x( x )
1436 , _multiplier( multiplier )
1437 {
1438 static_assert( 1 == ViewType::rank, "View must be of scalars" );
1439 }
1440
1442 template <class SplineDataType, class GridViewType>
1443 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1444 const int p,
1445 const GridViewType& view ) const
1446 {
1447 value_type point_data = _x( p ) * _multiplier;
1448 P2G::gradient( point_data, sd, view );
1449 }
1450};
1451
1454template <class ViewType>
1455ScalarGradientP2G<ViewType>
1456createScalarGradientP2G( const ViewType& x,
1457 const typename ViewType::value_type& multiplier )
1458{
1459 return ScalarGradientP2G<ViewType>( x, multiplier );
1460}
1461
1462//---------------------------------------------------------------------------//
1471template <class ViewType>
1472struct VectorDivergenceP2G
1473{
1475 using value_type = typename ViewType::value_type;
1476
1478 ViewType _x;
1480 value_type _multiplier;
1481
1483 VectorDivergenceP2G( const ViewType& x, const value_type multiplier )
1484 : _x( x )
1485 , _multiplier( multiplier )
1486 {
1487 static_assert( 2 == ViewType::rank, "View must be of vectors" );
1488 }
1489
1491 template <class SplineDataType, class GridViewType>
1492 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1493 const int p,
1494 const GridViewType& view ) const
1495 {
1496 value_type point_data[SplineDataType::num_space_dim];
1497 for ( std::size_t d = 0; d < SplineDataType::num_space_dim; ++d )
1498 point_data[d] = _multiplier * _x( p, d );
1499 P2G::divergence( point_data, sd, view );
1500 }
1501};
1502
1505template <class ViewType>
1506VectorDivergenceP2G<ViewType>
1507createVectorDivergenceP2G( const ViewType& x,
1508 const typename ViewType::value_type& multiplier )
1509{
1510 return VectorDivergenceP2G<ViewType>( x, multiplier );
1511}
1512
1513//---------------------------------------------------------------------------//
1522template <class ViewType>
1523struct TensorDivergenceP2G
1524{
1526 using value_type = typename ViewType::value_type;
1527
1529 ViewType _x;
1531 value_type _multiplier;
1532
1534 TensorDivergenceP2G( const ViewType& x, const value_type multiplier )
1535 : _x( x )
1536 , _multiplier( multiplier )
1537 {
1538 static_assert( 3 == ViewType::rank, "View must be of tensors" );
1539 }
1540
1542 template <class SplineDataType, class GridViewType>
1543 KOKKOS_INLINE_FUNCTION void operator()( const SplineDataType& sd,
1544 const int p,
1545 const GridViewType& view ) const
1546 {
1547 value_type point_data[SplineDataType::num_space_dim]
1548 [SplineDataType::num_space_dim];
1549 for ( std::size_t d0 = 0; d0 < SplineDataType::num_space_dim; ++d0 )
1550 for ( std::size_t d1 = 0; d1 < SplineDataType::num_space_dim; ++d1 )
1551 point_data[d0][d1] = _multiplier * _x( p, d0, d1 );
1552 P2G::divergence( point_data, sd, view );
1553 }
1554};
1555
1558template <class ViewType>
1559TensorDivergenceP2G<ViewType>
1560createTensorDivergenceP2G( const ViewType& x,
1561 const typename ViewType::value_type& multiplier )
1562{
1563 return TensorDivergenceP2G<ViewType>( x, multiplier );
1564}
1565
1566//---------------------------------------------------------------------------//
1567
1568} // namespace Grid
1569} // namespace Cabana
1570
1571#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:1177
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:1507
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:1560
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:1074
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:1127
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:1356
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:1407
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:1023
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:1456
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:1220
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:972
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:1040
Cabana::Grid::ScalarGradientG2P::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1045
Cabana::Grid::ScalarGradientG2P::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1042
Cabana::Grid::ScalarGradientG2P::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1047
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:1059
Cabana::Grid::ScalarGradientG2P::ScalarGradientG2P
ScalarGradientG2P(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1050
Cabana::Grid::ScalarGradientP2G
Point-to-grid scalar gradient functor.
Definition Cabana_Grid_Interpolation.hpp:1424
Cabana::Grid::ScalarGradientP2G::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1431
Cabana::Grid::ScalarGradientP2G::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1426
Cabana::Grid::ScalarGradientP2G::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1429
Cabana::Grid::ScalarGradientP2G::ScalarGradientP2G
ScalarGradientP2G(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1434
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:1443
Cabana::Grid::ScalarValueG2P
Grid-to-point scalar value functor.
Definition Cabana_Grid_Interpolation.hpp:939
Cabana::Grid::ScalarValueG2P::ScalarValueG2P
ScalarValueG2P(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:949
Cabana::Grid::ScalarValueG2P::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:941
Cabana::Grid::ScalarValueG2P::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:944
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:958
Cabana::Grid::ScalarValueG2P::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:946
Cabana::Grid::ScalarValueP2G
Point-to-grid scalar value functor.
Definition Cabana_Grid_Interpolation.hpp:1324
Cabana::Grid::ScalarValueP2G::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1329
Cabana::Grid::ScalarValueP2G::ScalarValueP2G
ScalarValueP2G(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1334
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:1343
Cabana::Grid::ScalarValueP2G::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1331
Cabana::Grid::ScalarValueP2G::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1326
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:1524
Cabana::Grid::TensorDivergenceP2G::TensorDivergenceP2G
TensorDivergenceP2G(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1534
Cabana::Grid::TensorDivergenceP2G::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1529
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:1543
Cabana::Grid::TensorDivergenceP2G::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1526
Cabana::Grid::TensorDivergenceP2G::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1531
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:1144
Cabana::Grid::VectorDivergenceG2P::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1149
Cabana::Grid::VectorDivergenceG2P::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1151
Cabana::Grid::VectorDivergenceG2P::VectorDivergenceG2P
VectorDivergenceG2P(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1154
Cabana::Grid::VectorDivergenceG2P::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1146
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:1163
Cabana::Grid::VectorDivergenceP2G
Point-to-grid vector divergence functor.
Definition Cabana_Grid_Interpolation.hpp:1473
Cabana::Grid::VectorDivergenceP2G::VectorDivergenceP2G
VectorDivergenceP2G(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1483
Cabana::Grid::VectorDivergenceP2G::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1478
Cabana::Grid::VectorDivergenceP2G::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1475
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:1492
Cabana::Grid::VectorDivergenceP2G::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1480
Cabana::Grid::VectorGradientG2P
Grid-to-point vector gradient functor.
Definition Cabana_Grid_Interpolation.hpp:1091
Cabana::Grid::VectorGradientG2P::VectorGradientG2P
VectorGradientG2P(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1101
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:1110
Cabana::Grid::VectorGradientG2P::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1098
Cabana::Grid::VectorGradientG2P::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1096
Cabana::Grid::VectorGradientG2P::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1093
Cabana::Grid::VectorValueG2P
Grid-to-point vector value functor.
Definition Cabana_Grid_Interpolation.hpp:989
Cabana::Grid::VectorValueG2P::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:994
Cabana::Grid::VectorValueG2P::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:996
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:1008
Cabana::Grid::VectorValueG2P::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:991
Cabana::Grid::VectorValueG2P::VectorValueG2P
VectorValueG2P(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:999
Cabana::Grid::VectorValueP2G
Point-to-grid vector value functor.
Definition Cabana_Grid_Interpolation.hpp:1373
Cabana::Grid::VectorValueP2G::_multiplier
value_type _multiplier
Scalar multiplier.
Definition Cabana_Grid_Interpolation.hpp:1380
Cabana::Grid::VectorValueP2G::_x
ViewType _x
Spline evaluation locations.
Definition Cabana_Grid_Interpolation.hpp:1378
Cabana::Grid::VectorValueP2G::VectorValueP2G
VectorValueP2G(const ViewType &x, const value_type multiplier)
Constructor.
Definition Cabana_Grid_Interpolation.hpp:1383
Cabana::Grid::VectorValueP2G::value_type
typename ViewType::value_type value_type
Scalar value type.
Definition Cabana_Grid_Interpolation.hpp:1375
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:1392