RefinementCriteria.H

Go to the documentation of this file.

#ifndef REFINEMENTCRITERIA_H
#define REFINEMENTCRITERIA_H
 
#include "AMReX_AmrCore.H"
#include "AMReX_TagBox.H"
 
#include "src/core/Factory.H"

 
namespace kynema_sgf {
 
namespace tagging {

enum class TaggingOperator : std::uint8_t { AND, OR, AND_NOT, OR_NOT };

AMREX_FORCE_INLINE TaggingOperator string_to_operator(const std::string& op)
{
    if (op == "and") {
        return TaggingOperator::AND;
    }
    if (op == "or") {
        return TaggingOperator::OR;
    }
    if (op == "and_not") {
        return TaggingOperator::AND_NOT;
    }
    if (op == "or_not") {
        return TaggingOperator::OR_NOT;
    }
    amrex::Abort(
        "Invalid operator for tagging criteria: " + op +
        ". Must be one of: and, or, and_not, or_not.");
    // Unreachable, but avoids compiler warning
    return TaggingOperator::AND;
}
 
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::TagBox::TagVal tag_val(
    const bool previous_val, const bool current_val, const TaggingOperator& op)
{
    switch (op) {
    case TaggingOperator::AND:
        return (previous_val && current_val) ? amrex::TagBox::SET
                                             : amrex::TagBox::CLEAR;
    case TaggingOperator::OR:
        return (previous_val || current_val) ? amrex::TagBox::SET
                                             : amrex::TagBox::CLEAR;
    case TaggingOperator::AND_NOT:
        return (previous_val && !current_val) ? amrex::TagBox::SET
                                              : amrex::TagBox::CLEAR;
    case TaggingOperator::OR_NOT:
        return (previous_val || !current_val) ? amrex::TagBox::SET
                                              : amrex::TagBox::CLEAR;
    }
    // Unreachable, but avoids compiler warning
    return amrex::TagBox::CLEAR;
}
 
} // namespace tagging
 
class CFDSim;

class RefinementCriteria : public Factory<RefinementCriteria, CFDSim&>
{
public:
    static std::string base_identifier() { return "RefinementCriteria"; }
 
    [[nodiscard]] tagging::TaggingOperator tag_operator() const
    {
        return m_tag_operator;
    }
 
    void tag_operator(const tagging::TaggingOperator& op)
    {
        m_tag_operator = op;
    }
 
    RefinementCriteria() = default;
 
    ~RefinementCriteria() override = default;

    virtual void initialize(const std::string& key) = 0;

    virtual void operator()(
        int level, amrex::TagBoxArray& tags, amrex::Real time, int ngrow) = 0;
 
private:
    tagging::TaggingOperator m_tag_operator{tagging::TaggingOperator::OR};
};

class RefineCriteriaManager
{
public:
    explicit RefineCriteriaManager(CFDSim& sim);
 
    ~RefineCriteriaManager() = default;
 
    void initialize();
 
    void
    tag_cells(int lev, amrex::TagBoxArray& tags, amrex::Real time, int ngrow);
 
private:
    CFDSim& m_sim;
 
    amrex::Vector<std::unique_ptr<RefinementCriteria>> m_refiners;
};
 
} // namespace kynema_sgf
 
#endif /* REFINEMENTCRITERIA_H */