ParticleOps.H

Go to the documentation of this file.

#ifndef PARTICLEOPS_H
#define PARTICLEOPS_H
 
#include <AMReX.H>
#include <AMReX_Array4.H>
#include <AMReX_Print.H>
#include "ParticleData.H"
 
namespace spades::particles {
 
template <size_t NRealT, size_t NIntT, class P, class RT, class IT>
struct ParticleArrays
{
    static constexpr size_t NREAL = NRealT;
    static constexpr size_t NINT = NIntT;
 
    ParticleArrays(
        P* aos, std::array<RT, NRealT>& rdata, std::array<IT, NIntT>& idata)
        : m_aos(aos)
    {
        for (size_t i = 0; i < NRealT; i++) {
            m_rdata[i] = rdata[i].data();
        }
        for (size_t i = 0; i < NIntT; i++) {
            m_idata[i] = idata[i].data();
        }
    }
 
    P* m_aos = nullptr;
 
    amrex::GpuArray<amrex::Real*, NRealT> m_rdata;
 
    amrex::GpuArray<int*, NIntT> m_idata;
};
 
struct Print
{
    template <class PArrs>
    void operator()(const amrex::Long n, PArrs& parrs) const
    {
        auto& p = parrs.m_aos[n];
        amrex::Print() << "Particle data: \n"
                       << "  id = " << p.id() << "\n"
                       << "  cpu = " << p.cpu() << "\n"
                       << "  type = "
                       << parrs.m_idata[CommonIntData::type_id][n] << "\n";
        for (size_t i = 0; i < PArrs::NINT; i++) {
            amrex::Print() << "  int comp(" << i
                           << ") = " << parrs.m_idata[i][n] << "\n";
        }
        for (size_t i = 0; i < PArrs::NREAL; i++) {
            amrex::Print() << "  real comp(" << i
                           << ") = " << parrs.m_rdata[i][n] << "\n";
        }
    }
};
 
struct DevicePrint
{
    template <class PArrs>
    AMREX_GPU_DEVICE void operator()(const amrex::Long n, PArrs& parrs) const
    {
        auto& p = parrs.m_aos[n];
        printf(
            "Particle data: id = %ld, cpu = %ld, type = %d, timestamp = %.8e\n",
            static_cast<amrex::Long>(p.id()), static_cast<amrex::Long>(p.cpu()),
            parrs.m_idata[CommonIntData::type_id][n],
            parrs.m_rdata[CommonRealData::timestamp][n]);
    }
};
 
struct Copy
{
    template <class PArrs>
    AMREX_GPU_DEVICE AMREX_FORCE_INLINE void
    operator()(const amrex::Long p1, const amrex::Long p2, PArrs& parrs) const
    {
        for (size_t i = 0; i < PArrs::NREAL; i++) {
            parrs.m_rdata[i][p2] = parrs.m_rdata[i][p1];
        }
        for (size_t i = 0; i < PArrs::NINT; i++) {
            parrs.m_idata[i][p2] = parrs.m_idata[i][p1];
        }
    }
};
 
template <class PArrs>
struct Get
{
    AMREX_GPU_DEVICE AMREX_FORCE_INLINE
    Get(const amrex::IntVect& iv,
        const amrex::Array4<const int>& counts,
        const amrex::Array4<const int>& offsets,
        PArrs& parrs)
        : m_iv(iv), m_counts(counts), m_offsets(offsets), m_parrs(parrs)
    {}
 
    AMREX_GPU_DEVICE AMREX_FORCE_INLINE int
    operator()(const int n, const int typ) const
    {
 
        AMREX_ASSERT(m_counts(m_iv, typ) > n);
        const int idx = m_offsets(m_iv, typ) + n;
 
        AMREX_ASSERT(m_parrs.m_aos[idx].id() >= 0);
        AMREX_ASSERT(m_parrs.m_idata[CommonIntData::type_id][idx] == typ);
 
        return idx;
    }
 
    AMREX_GPU_DEVICE AMREX_FORCE_INLINE bool
    check(const int n, const int typ) const
    {
        AMREX_ASSERT(m_counts(m_iv, typ) > n);
        const int idx = m_offsets(m_iv, typ) + n;
        return m_parrs.m_idata[CommonIntData::type_id][idx] == typ;
    }
 
    AMREX_GPU_DEVICE AMREX_FORCE_INLINE void
    assert_different(const int n, const int typ, const int expected_type) const
    {
#ifdef AMREX_DEBUG
        const int idx = m_offsets(m_iv, typ) + n;
        AMREX_ASSERT(
            m_parrs.m_idata[CommonIntData::type_id][idx] == expected_type);
#else
        amrex::ignore_unused(n, typ, expected_type);
#endif
    }
 
    const amrex::IntVect& m_iv;
 
    const amrex::Array4<const int>& m_counts;
 
    const amrex::Array4<const int>& m_offsets;
 
    PArrs& m_parrs;
};
 
struct CheckPair
{
    template <class P>
    AMREX_GPU_DEVICE AMREX_FORCE_INLINE bool
    operator()(const P& /*p1*/, const P& /*p2*/) const
    {
        return false;
    }
};
 
struct CompareParticle
{
    template <class PArrs>
    AMREX_GPU_DEVICE AMREX_FORCE_INLINE bool
    operator()(const amrex::Long p1, const amrex::Long p2, PArrs& parrs) const
    {
        // sort by iv, then particle type then by timestamp
        const amrex::IntVect piv1(AMREX_D_DECL(
            parrs.m_idata[CommonIntData::i][p1],
            parrs.m_idata[CommonIntData::j][p1],
            parrs.m_idata[CommonIntData::k][p1]));
        const amrex::IntVect piv2(AMREX_D_DECL(
            parrs.m_idata[CommonIntData::i][p2],
            parrs.m_idata[CommonIntData::j][p2],
            parrs.m_idata[CommonIntData::k][p2]));
 
        const auto m1 = parrs.m_idata[CommonIntData::type_id][p1];
        const auto m2 = parrs.m_idata[CommonIntData::type_id][p2];
        const auto t1 = parrs.m_rdata[CommonRealData::timestamp][p1];
        const auto t2 = parrs.m_rdata[CommonRealData::timestamp][p2];
        return (piv1 < piv2) ||
               (piv1 == piv2 && ((m1 < m2) || (m1 == m2 && t1 < t2)));
    }
};
 
} // namespace spades::particles
#endif