BareField.h

Go to the documentation of this file.

//
// Class BareField
//   A BareField represents a field.
//
#ifndef IPPL_BARE_FIELD_H
#define IPPL_BARE_FIELD_H
 
#include <Kokkos_Core.hpp>
 
#include <cstdlib>
#include <iostream>
 
#include "Types/IpplTypes.h"
 
#include "Utility/IpplInfo.h"
#include "Utility/PAssert.h"
#include "Utility/ViewUtils.h"
 
#include "Expression/IpplExpressions.h"
 
#include "Field/HaloCells.h"
#include "FieldLayout/FieldLayout.h"
 
namespace ippl {
    class Index;


    template <typename T, unsigned Dim, class... ViewArgs>
    class BareField : public detail::Expression<
                          BareField<T, Dim, ViewArgs...>,
                          sizeof(typename detail::ViewType<T, Dim, ViewArgs...>::view_type)> {
    public:
        using Layout_t = FieldLayout<Dim>;

        using Domain_t = NDIndex<Dim>;

        using view_type = typename detail::ViewType<T, Dim, ViewArgs...>::view_type;
        typedef typename view_type::memory_space memory_space;
        typedef typename view_type::execution_space execution_space;
        using HostMirror = typename view_type::host_mirror_type;
        template <class... PolicyArgs>
        using policy_type = typename RangePolicy<Dim, PolicyArgs...>::policy_type;
 
        using halo_type = detail::HaloCells<T, Dim, ViewArgs...>;
 
        using value_type              = T;
        constexpr static unsigned dim = Dim;

        BareField();
 
        BareField(const BareField&) = default;

        BareField(Layout_t& l, int nghost = 1);

        BareField deepCopy() const;
 
        // Destroy the BareField.
        ~BareField() = default;

        template <typename... Args>
        void resize(Args... args);

        void initialize(Layout_t& l, int nghost = 1);
 
        // ML
        void updateLayout(Layout_t&, int nghost = 1);

        detail::size_type size(unsigned d) const { return owned_m[d].length(); }

        const Domain_t& getOwned() const { return owned_m; }

        const Domain_t getAllocated() const { return owned_m.grow(nghost_m); }
 
        int getNghost() const { return nghost_m; }
 
        void fillHalo();
        void accumulateHalo();
        void accumulateHalo_noghost(int nghost = 1);
 
        auto& getCommunicator() const { return getLayout().comm; }
 
        // Access to the layout.
        Layout_t& getLayout() const {
            PAssert(layout_m != 0);
            return *layout_m;
        }
 
        const Index& getIndex(unsigned d) const { return getLayout().getDomain()[d]; }
        const NDIndex<Dim>& getDomain() const { return getLayout().getDomain(); }
 
        halo_type& getHalo() { return halo_m; }
 
        // Assignment from a constant.
        BareField& operator=(T x);

        template <typename E, size_t N>
        BareField& operator=(const detail::Expression<E, N>& expr);

        template <typename... Args>
        KOKKOS_INLINE_FUNCTION T operator()(Args... args) const {
            return dview_m(args...);
        }
 
        view_type& getView() { return dview_m; }
 
        const view_type& getView() const { return dview_m; }
 
        HostMirror getHostMirror() const { return Kokkos::create_mirror(dview_m); }

        template <class... PolicyArgs>
        policy_type<execution_space, PolicyArgs...> getFieldRangePolicy(
            const int nghost = 0) const {
            PAssert_LE(nghost, nghost_m);
            const size_t shift = nghost_m - nghost;
            return getRangePolicy(dview_m, shift);
        }

        void write(std::ostream& out = std::cout) const;

        void write(Inform& inf) const;
 
        T sum(int nghost = 0) const;
        T max(int nghost = 0) const;
        T min(int nghost = 0) const;
        T prod(int nghost = 0) const;
 
    private:
        int nghost_m;

        view_type dview_m;

        Domain_t owned_m;
 
        halo_type halo_m;

        void setup();

        Layout_t* layout_m = nullptr;
    };
 
}  // namespace ippl
 
#include "Field/BareField.hpp"
#include "Field/BareFieldOperations.hpp"
 
#endif