ParticleAttrib.h

//
// Class ParticleAttrib
//   Templated class for all particle attribute classes.
//
//   This templated class is used to represent a single particle attribute.
//   An attribute is one data element within a particle object, and is
//   stored as a Kokkos::View. This class stores the type information for the
//   attribute, and provides methods to create and destroy new items, and
//   to perform operations involving this attribute with others.
//
//   ParticleAttrib is the primary element involved in expressions for
//   particles (just as LField is the primary element there).  This file
//   defines the necessary templated classes and functions to make
//   ParticleAttrib a capable expression-template participant.
//
#ifndef IPPL_PARTICLE_ATTRIB_H
#define IPPL_PARTICLE_ATTRIB_H
 
#include <cstring>
 
#include "Expression/IpplExpressions.h"
 
#include "Interpolation/CIC.h"
#include "Particle/ParticleAttribBase.h"
 
namespace ippl {
 
    // ParticleAttrib class definition
    template <typename T, class... Properties>
    class ParticleAttrib : public detail::ParticleAttribBase<>::with_properties<Properties...>,
                           public detail::Expression<
                               ParticleAttrib<T, Properties...>,
                               sizeof(typename detail::ViewType<T, 1, Properties...>::view_type)> {
    public:
        typedef T value_type;
        constexpr static unsigned dim = 1;
 
        using Base = typename detail::ParticleAttribBase<>::with_properties<Properties...>;
 
        using hash_type = typename Base::hash_type;
 
        using view_type = typename detail::ViewType<T, 1, Properties...>::view_type;
 
        using host_mirror_type = typename view_type::host_mirror_type;
 
        using memory_space    = typename view_type::memory_space;
        using execution_space = typename view_type::execution_space;
 
        using size_type = detail::size_type;
 
        // Create storage for M particle attributes. The storage is uninitialized.
        // New items are appended to the end of the array. When non_destructive is
        // true, existing entries are preserved across a capacity grow.
        void create(size_type, bool non_destructive = false) override;
 
        // Allocate capacity for n particles (multiplied by the default overallocation
        // factor) without touching the logical particle count. Existing data is
        // discarded.
        void alloc(size_type) override;
 
        void destroy(const hash_type& deleteIndex, const hash_type& keepIndex,
                     size_type invalidCount) override;
 
        void pack(const hash_type&) override;
 
        void unpack(size_type) override;
 
        void serialize(detail::Archive<memory_space>& ar, size_type nsends) override {
            ar.serialize(buf_m, nsends);
        }
 
        void deserialize(detail::Archive<memory_space>& ar, size_type nrecvs) override {
            ar.deserialize(buf_m, nrecvs);
        }
 
        virtual ~ParticleAttrib() = default;
        
        size_type size() const override { return dview_m.extent(0); }
        
        size_type packedSize(const size_type count) const override {
            return count * sizeof(value_type);
        }
        
        void resize(size_type n) { Kokkos::resize(dview_m, n); }
 
        void realloc(size_type n) { Kokkos::realloc(dview_m, n); }
 
        void print() {
            host_mirror_type hview = Kokkos::create_mirror_view(dview_m);
            Kokkos::deep_copy(hview, dview_m);
            for (size_type i = 0; i < *(this->localNum_mp); ++i) {
                std::cout << hview(i) << std::endl;
            }
        }
 
        KOKKOS_INLINE_FUNCTION T& operator()(const size_t i) const { return dview_m(i); }
 
        view_type& getView() { return dview_m; }
 
        const view_type& getView() const { return dview_m; }
 
        host_mirror_type getHostMirror() const { return Kokkos::create_mirror(dview_m); }
 
        void set_name(const std::string& name_) override {
            size_t len = name_.size();
            if (len >= detail::ATTRIB_NAME_MAX_LEN) {
                len = detail::ATTRIB_NAME_MAX_LEN - 1;
            }
            std::memcpy(this->name_m, name_.c_str(), len);
            this->name_m[len] = '\0';
        }
 
        std::string get_name() const override { return std::string(this->name_m); }
 
        // KOKKOS_INLINE_FUNCTION
        ParticleAttrib<T, Properties...>& operator=(T x);
 
        template <typename E, size_t N>
        // KOKKOS_INLINE_FUNCTION
        ParticleAttrib<T, Properties...>& operator=(detail::Expression<E, N> const& expr);
 
        template <typename Field, typename P2, typename policy_type>
        void scatter(Field& f, const ParticleAttrib<Vector<P2, Field::dim>, Properties...>& pp,
                     policy_type iteration_policy, hash_type hash_array = {}) const;
 
        template <typename Field, typename P2>
        void gather(Field& f, const ParticleAttrib<Vector<P2, Field::dim>, Properties...>& pp,
                    const bool addToAttribute = false);
 
        T sum();
        T max();
        T min();
        T prod();
 
        void applyPermutation(const hash_type& permutation) override;
 
        void internalCopy(const hash_type& indices) override;
 
    private:
        view_type dview_m;
        view_type buf_m;
    };
}  // namespace ippl
 
#include "Particle/ParticleAttrib.hpp"
 
#endif