HaloCells.h

Go to the documentation of this file.

//
// Class HaloCells
//   The guard / ghost cells of BareField.
//
#ifndef IPPL_HALO_CELLS_H
#define IPPL_HALO_CELLS_H
 
#include <array>
 
#include "Types/IpplTypes.h"
#include "Types/ViewTypes.h"
 
#include "Communicate/Archive.h"
#include "FieldLayout/FieldLayout.h"
#include "Index/NDIndex.h"
 
namespace ippl {
    namespace detail {
        template <typename T, class... ViewArgs>
        struct FieldBufferData {
            using view_type    = typename detail::ViewType<T, 1, ViewArgs...>::view_type;
            using archive_type = Archive<typename view_type::memory_space>;
 
            void serialize(archive_type& ar, size_type nsends) { ar.serialize(buffer, nsends); }
 
            void deserialize(archive_type& ar, size_type nrecvs) { ar.deserialize(buffer, nrecvs); }
 
            view_type buffer;
        };

        template <typename T, unsigned Dim, class... ViewArgs>
        class HaloCells {
        public:
            using view_type       = typename detail::ViewType<T, Dim, ViewArgs...>::view_type;
            using Layout_t        = FieldLayout<Dim>;
            using bound_type      = typename Layout_t::bound_type;
            using databuffer_type = FieldBufferData<T, ViewArgs...>;
 
            enum SendOrder {
                HALO_TO_INTERNAL,
                INTERNAL_TO_HALO,
                HALO_TO_INTERNAL_NOGHOST
            };
 
            HaloCells();

            void accumulateHalo(view_type& view, Layout_t* layout);

            void accumulateHalo_noghost(view_type& view, Layout_t* layout, int nghost);

            void fillHalo(view_type&, Layout_t* layout);

            void pack(const bound_type& range, const view_type& view, databuffer_type& fd,
                      size_type& nsends);

            template <typename Op>
            void unpack(const bound_type& range, const view_type& view, databuffer_type& fd);

            struct assign {
                KOKKOS_INLINE_FUNCTION void operator()(T& lhs, const T& rhs) const { lhs = rhs; }
            };

            struct lhs_plus_assign {
                KOKKOS_INLINE_FUNCTION void operator()(T& lhs, const T& rhs) const { lhs += rhs; }
            };

            struct rhs_plus_assign {
                KOKKOS_INLINE_FUNCTION void operator()(const T& lhs, T& rhs) const { rhs += lhs; }
            };

            template <typename Op>
            void applyPeriodicSerialDim(view_type& view, const Layout_t* layout, const int nghost);
 
        private:
            template <class Op>
            void exchangeBoundaries(view_type& view, Layout_t* layout, SendOrder order, int nghost = 1);

            auto makeSubview(const view_type& view, const bound_type& intersect);
 
            databuffer_type haloData_m;
        };
    }  // namespace detail
}  // namespace ippl
 
#include "Field/HaloCells.hpp"
 
#endif