Phold.H

Go to the documentation of this file.

#ifndef PHOLD_H
#define PHOLD_H
#include <AMReX_ParmParse.H>
#include <AMReX_Geometry.H>
#include "Source/Constants.H"
#include "Source/Utilities.H"
#include "Source/MessageOps.H"
#include "Source/MessageData.H"
#include "Source/EntityData.H"
 
namespace spades::models {
 
class Phold
{
public:
    static std::string identifier() { return "phold"; }
 
    explicit Phold();
 
    void read_parameters();
 
    [[nodiscard]] const amrex::Geometry& geom() const { return m_geom; }
 
    struct ProcessOp
    {
        template <class MParrs, class EParrs>
        AMREX_GPU_DEVICE int operator()(
            const MParrs& msg_parrs,
            const EParrs& ent_parrs,
            const amrex::IntVect& iv,
            const int rcv_msg,
            const int snd_msg,
            const int ent,
            const int ent_idx,
            amrex::RandomEngine const& engine) const
        {
            const auto& dlo = m_dom.smallEnd();
            const auto& dhi = m_dom.bigEnd();
            const auto ts =
                msg_parrs
                    .m_rdata[particles::CommonRealData::timestamp][rcv_msg];
 
            msg_parrs
                .m_rdata[particles::MessageRealData::old_timestamp][rcv_msg] =
                ent_parrs
                    .m_rdata[particles::CommonRealData::timestamp][ent_idx];
            ent_parrs.m_rdata[particles::CommonRealData::timestamp][ent_idx] =
                ts;
            msg_parrs.m_idata[particles::CommonIntData::type_id][rcv_msg] =
                particles::MessageTypes::PROCESSED;
 
            const auto ent_lvt =
                ent_parrs
                    .m_rdata[particles::CommonRealData::timestamp][ent_idx];
            const amrex::IntVect iv_dest(AMREX_D_DECL(
                amrex::Random_int(dhi[0] - dlo[0] + 1, engine) + dlo[0],
                amrex::Random_int(dhi[1] - dlo[1] + 1, engine) + dlo[1],
                amrex::Random_int(dhi[2] - dlo[2] + 1, engine) + dlo[2]));
            const amrex::GpuArray<amrex::Real, AMREX_SPACEDIM> pos = {
                AMREX_D_DECL(
                    m_plo[0] + (iv_dest[0] + constants::HALF) * m_dx[0],
                    m_plo[1] + (iv_dest[1] + constants::HALF) * m_dx[1],
                    m_plo[2] + (iv_dest[2] + constants::HALF) * m_dx[2])};
            const int rcv_ent =
                static_cast<int>(amrex::Random_int(m_entities_per_lp, engine));
            const amrex::Real next_ts =
                ent_lvt + random_exponential(m_lambda, engine) + m_lookahead;
 
            particles::CreateMessage()(
                snd_msg, msg_parrs, next_ts, pos, iv_dest,
                static_cast<int>(m_dom.index(iv)), ent,
                static_cast<int>(m_dom.index(iv_dest)), rcv_ent);
            const int n_sent_messages = 1;
            return n_sent_messages;
        }
 
        amrex::Real m_lookahead{1.0};
 
        amrex::Real m_lambda{1.0};
 
        int m_entities_per_lp{1};
 
        amrex::GpuArray<amrex::Real, AMREX_SPACEDIM> m_dx;
 
        amrex::Box m_dom;
 
        amrex::GpuArray<amrex::Real, AMREX_SPACEDIM> m_plo;
    };
 
    using ProcessType = ProcessOp;
 
    [[nodiscard]] ProcessType process_op() const { return m_process_op; }
 
    // Message processing operator
    ProcessOp m_process_op;
 
    struct InitEntityOp
    {
        template <class EParrs>
        AMREX_GPU_DEVICE void
        operator()(const EParrs& ent_parrs, const int n) const
        {
            const amrex::Real ts = 0.0;
 
            ent_parrs.m_rdata[particles::CommonRealData::timestamp][n] = ts;
            ent_parrs.m_idata[particles::CommonIntData::type_id][n] =
                particles::EntityTypes::ENTITY;
        }
 
        int m_entities_per_lp{1};
    };
 
    using InitEntityType = InitEntityOp;
 
    [[nodiscard]] InitEntityType init_entity_op() const
    {
        return m_init_entity_op;
    }
 
    // Initialize entity operator
    InitEntityOp m_init_entity_op;
 
    struct InitMessageOp
    {
        template <class MParrs>
        AMREX_GPU_DEVICE void operator()(
            const MParrs& msg_parrs,
            const int n,
            amrex::RandomEngine const& engine) const
        {
            const amrex::Real ts =
                random_exponential(m_lambda, engine) + m_lookahead;
            msg_parrs.m_idata[particles::CommonIntData::type_id][n] =
                particles::MessageTypes::MESSAGE;
            msg_parrs.m_rdata[particles::CommonRealData::timestamp][n] = ts;
            msg_parrs.m_rdata[particles::MessageRealData::creation_time][n] =
                0.0;
        }
 
        amrex::Real m_lookahead{1.0};
 
        int m_messages_per_lp{1};
 
        amrex::Real m_lambda{1.0};
    };
 
    using InitMessageType = InitMessageOp;
 
    [[nodiscard]] InitMessageType init_message_op() const
    {
        return m_init_message_op;
    }
 
    // Initialize message operator
    InitMessageOp m_init_message_op;
 
private:
    // Domain geometry
    amrex::Geometry m_geom;
};
 
} // namespace spades::models
#endif /* PHOLD_H */